← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to gis/dhis-gis-geostat/mfbase/openlayers/tests/xml_eq.js

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
gis/dhis-gis-geostat/mfbase/openlayers/tests/xml_eq.js
 
1
/**
 
2
 * File: xml_eq.js
 
3
 * Adds a xml_eq method to AnotherWay test objects.
 
4
 *
 
5
 */
 
6
 
 
7
(function() {
 
8
 
 
9
    /**
 
10
     * Function: createNode
 
11
     * Given a string, try to create an XML DOM node.  Throws string messages
 
12
     *     on failure.
 
13
     * 
 
14
     * Parameters:
 
15
     * text - {String} An XML string.
 
16
     *
 
17
     * Returns:
 
18
     * {DOMElement} An element node.
 
19
     */
 
20
    function createNode(text) {
 
21
        
 
22
        var index = text.indexOf('<');
 
23
        if(index > 0) {
 
24
            text = text.substring(index);
 
25
        }
 
26
        
 
27
        var doc;
 
28
        if(window.ActiveXObject && !this.xmldom) {
 
29
            doc = new ActiveXObject("Microsoft.XMLDOM");
 
30
            try {
 
31
                doc.loadXML(text);
 
32
            } catch(err) {
 
33
                throw "ActiveXObject loadXML failed: " + err;
 
34
            }
 
35
        } else if(window.DOMParser) {
 
36
            try {
 
37
                doc = new DOMParser().parseFromString(text, 'text/xml');
 
38
            } catch(err) {
 
39
                throw "DOMParser.parseFromString failed";
 
40
            }
 
41
            if(doc.documentElement && doc.documentElement.nodeName == "parsererror") {
 
42
                throw "DOMParser.parseFromString returned parsererror";
 
43
            }
 
44
        } else {
 
45
            var req = new XMLHttpRequest();
 
46
            req.open("GET", "data:text/xml;charset=utf-8," +
 
47
                     encodeURIComponent(text), false);
 
48
            if(req.overrideMimeType) {
 
49
                req.overrideMimeType("text/xml");
 
50
            }
 
51
            req.send(null);
 
52
            doc = req.responseXML;
 
53
        }
 
54
        
 
55
        var root = doc.documentElement;
 
56
        if(!root) {
 
57
            throw "no documentElement";
 
58
        }
 
59
        return root;
 
60
    }
 
61
    
 
62
    /**
 
63
     * Function assertEqual
 
64
     * Test two objects for equivalence (based on ==).  Throw an exception
 
65
     *     if not equivalent.
 
66
     * 
 
67
     * Parameters:
 
68
     * got - {Object}
 
69
     * expected - {Object}
 
70
     * msg - {String} The message to be thrown.  This message will be appended
 
71
     *     with ": got {got} but expected {expected}" where got and expected are
 
72
     *     replaced with string representations of the above arguments.
 
73
     */
 
74
    function assertEqual(got, expected, msg) {
 
75
        if(got === undefined) {
 
76
            got = "undefined";
 
77
        } else if (got === null) {
 
78
            got = "null";
 
79
        }
 
80
        if(expected === undefined) {
 
81
            expected = "undefined";
 
82
        } else if (expected === null) {
 
83
            expected = "null";
 
84
        }
 
85
        if(got != expected) {
 
86
            throw msg + ": got '" + got + "' but expected '" + expected + "'";
 
87
        }
 
88
    }
 
89
    
 
90
    /**
 
91
     * Function assertElementNodesEqual
 
92
     * Test two element nodes for equivalence.  Nodes are considered equivalent
 
93
     *     if they are of the same type, have the same name, have the same
 
94
     *     namespace prefix and uri, and if all child nodes are equivalent.
 
95
     *     Throws a message as exception if not equivalent.
 
96
     * 
 
97
     * Parameters:
 
98
     * got - {DOMElement}
 
99
     * expected - {DOMElement}
 
100
     * options - {Object} Optional object for configuring test options.
 
101
     *
 
102
     * Valid options:
 
103
     * prefix - {Boolean} Compare element and attribute
 
104
     *     prefixes (namespace uri always tested).  Default is false.
 
105
     * includeWhiteSpace - {Boolean} Include whitespace only nodes when
 
106
     *     comparing child nodes.  Default is false.
 
107
     */
 
108
    function assertElementNodesEqual(got, expected, options) {
 
109
        var testPrefix = (options && options.prefix === true);
 
110
        
 
111
        // compare types
 
112
        assertEqual(got.nodeType, expected.nodeType, "Node type mismatch");
 
113
        
 
114
        // compare names
 
115
        var gotName = testPrefix ?
 
116
            got.nodeName : got.nodeName.split(":").pop();
 
117
        var expName = testPrefix ?
 
118
            expected.nodeName : expected.nodeName.split(":").pop();
 
119
        assertEqual(gotName, expName, "Node name mismatch");
 
120
        
 
121
        // for text nodes compare value
 
122
        if(got.nodeType == 3) {
 
123
            assertEqual(
 
124
                got.nodeValue, expected.nodeValue, "Node value mismatch"
 
125
            );
 
126
        }
 
127
        // for element type nodes compare namespace, attributes, and children
 
128
        else if(got.nodeType == 1) {
 
129
            
 
130
            // test namespace alias and uri
 
131
            if(got.prefix || expected.prefix) {
 
132
                if(testPrefix) {
 
133
                    assertEqual(
 
134
                        got.prefix, expected.prefix,
 
135
                        "Bad prefix for " + got.nodeName
 
136
                    );
 
137
                }
 
138
            }
 
139
            if(got.namespaceURI || expected.namespaceURI) {
 
140
                assertEqual(
 
141
                    got.namespaceURI, expected.namespaceURI,
 
142
                    "Bad namespaceURI for " + got.nodeName
 
143
                );
 
144
            }
 
145
            
 
146
            // compare attributes - disregard xmlns given namespace handling above
 
147
            var gotAttrLen = 0;
 
148
            var gotAttr = {};
 
149
            var expAttrLen = 0;
 
150
            var expAttr = {};
 
151
            var ga, ea, gn, en;
 
152
            for(var i=0; i<got.attributes.length; ++i) {
 
153
                ga = got.attributes[i];
 
154
                if(ga.specified === undefined || ga.specified === true) {
 
155
                    if(ga.name.split(":").shift() != "xmlns") {
 
156
                        gn = testPrefix ? ga.name : ga.name.split(":").pop();
 
157
                        gotAttr[gn] = ga;
 
158
                        ++gotAttrLen;
 
159
                    }
 
160
                }
 
161
            }
 
162
            for(var i=0; i<expected.attributes.length; ++i) {
 
163
                ea = expected.attributes[i];
 
164
                if(ea.specified === undefined || ea.specified === true) {
 
165
                    if(ea.name.split(":").shift() != "xmlns") {
 
166
                        en = testPrefix ? ea.name : ea.name.split(":").pop();
 
167
                        expAttr[en] = ea;
 
168
                        ++expAttrLen;
 
169
                    }
 
170
                }
 
171
            }
 
172
            assertEqual(
 
173
                gotAttrLen, expAttrLen,
 
174
                "Attributes length mismatch for " + got.nodeName
 
175
            );
 
176
            var gv, ev;
 
177
            for(var name in gotAttr) {
 
178
                if(expAttr[name] == undefined) {
 
179
                    throw "Attribute name " + gotAttr[name].name + " expected for element " + got.nodeName;
 
180
                }
 
181
                // test attribute namespace
 
182
                assertEqual(
 
183
                    gotAttr[name].namespaceURI, expAttr[name].namespaceURI,
 
184
                    "Attribute namespace mismatch for element " +
 
185
                    got.nodeName + " attribute name " + gotAttr[name].name
 
186
                );
 
187
                // test attribute value
 
188
                assertEqual(
 
189
                    gotAttr[name].value, expAttr[name].value,
 
190
                    "Attribute value mismatch for element " + got.nodeName +
 
191
                    " attribute name " + gotAttr[name].name
 
192
                );
 
193
            }
 
194
            
 
195
            // compare children
 
196
            var gotChildNodes = getChildNodes(got, options);
 
197
            var expChildNodes = getChildNodes(expected, options);
 
198
 
 
199
            assertEqual(
 
200
                gotChildNodes.length, expChildNodes.length,
 
201
                "Children length mismatch for " + got.nodeName
 
202
            );
 
203
            for(var j=0; j<gotChildNodes.length; ++j) {
 
204
                try {
 
205
                    assertElementNodesEqual(
 
206
                        gotChildNodes[j], expChildNodes[j], options
 
207
                    );
 
208
                } catch(err) {
 
209
                    throw "Bad child " + j + " for element " + got.nodeName + ": " + err;
 
210
                }
 
211
            }
 
212
        }
 
213
        return true;
 
214
    }
 
215
 
 
216
    /**
 
217
     * Function getChildNodes
 
218
     * Returns the child nodes of the specified nodes. By default this method
 
219
     *     will ignore child text nodes which are made up of whitespace content.
 
220
     *     The 'includeWhiteSpace' option is used to control this behaviour.
 
221
     * 
 
222
     * Parameters:
 
223
     * node - {DOMElement}
 
224
     * options - {Object} Optional object for test configuration.
 
225
     * 
 
226
     * Valid options:
 
227
     * includeWhiteSpace - {Boolean} Include whitespace only nodes when
 
228
     *     comparing child nodes.  Default is false.
 
229
     * 
 
230
     * Returns:
 
231
     * {Array} of {DOMElement}
 
232
     */
 
233
    function getChildNodes(node, options) {
 
234
        //check whitespace
 
235
        if (options && options.includeWhiteSpace) {
 
236
            return node.childNodes;
 
237
        }
 
238
        else {
 
239
           nodes = [];
 
240
           for (var i = 0; i < node.childNodes.length; i++ ) {
 
241
              var child = node.childNodes[i];
 
242
              if (child.nodeType == 1) {
 
243
                 //element node, add it 
 
244
                 nodes.push(child);
 
245
              }
 
246
              else if (child.nodeType == 3) {
 
247
                 //text node, add if non empty
 
248
                 if (child.nodeValue && 
 
249
                       child.nodeValue.replace(/^\s*(.*?)\s*$/, "$1") != "" ) { 
 
250
 
 
251
                    nodes.push(child);
 
252
                 }
 
253
              }
 
254
           }
 
255
  
 
256
           return nodes;
 
257
        }
 
258
    } 
 
259
    
 
260
    /**
 
261
     * Function: Test.AnotherWay._test_object_t.xml_eq
 
262
     * Test if two XML nodes are equivalent.  Tests for same node types, same
 
263
     *     node names, same namespace URI, same attributes, and recursively
 
264
     *     tests child nodes for same criteria.
 
265
     *
 
266
     * (code)
 
267
     * t.xml_eq(got, expected, message);
 
268
     * (end)
 
269
     * 
 
270
     * Parameters:
 
271
     * got - {DOMElement | String} A DOM node or XML string to test.
 
272
     * expected - {DOMElement | String} The expected DOM node or XML string.
 
273
     * msg - {String} A message to print with test output.
 
274
     * options - {Object} Optional object for configuring test.
 
275
     *
 
276
     * Valid options:
 
277
     * prefix - {Boolean} Compare element and attribute
 
278
     *     prefixes (namespace uri always tested).  Default is false.
 
279
     * includeWhiteSpace - {Boolean} Include whitespace only nodes when
 
280
     *     comparing child nodes.  Default is false.
 
281
     */
 
282
    var proto = Test.AnotherWay._test_object_t.prototype;
 
283
    proto.xml_eq = function(got, expected, msg, options) {
 
284
        // convert arguments to nodes if string
 
285
        if(typeof got == "string") {
 
286
            try {
 
287
                got = createNode(got);
 
288
            } catch(err) {
 
289
                this.fail(msg + ": got argument could not be converted to an XML node: " + err);
 
290
                return;
 
291
            }
 
292
        }
 
293
        if(typeof expected == "string") {
 
294
            try {
 
295
                expected = createNode(expected);
 
296
            } catch(err) {
 
297
                this.fail(msg + ": expected argument could not be converted to an XML node: " + err);
 
298
                return;
 
299
            }
 
300
        }
 
301
        
 
302
        // test nodes for equivalence
 
303
        try {
 
304
            assertElementNodesEqual(got, expected, options);
 
305
            this.ok(true, msg);
 
306
        } catch(err) {
 
307
            this.fail(msg + ": " + err);
 
308
        }
 
309
    }
 
310
    
 
311
})();