Home | History | Annotate | Download | only in gle2
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Eclipse Public License, Version 1.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.eclipse.org/org/documents/epl-v10.php
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package com.android.ide.eclipse.adt.internal.editors.layout.gle2;
     17 
     18 import static com.android.SdkConstants.ANDROID_URI;
     19 import static com.android.SdkConstants.TOOLS_URI;
     20 
     21 import org.w3c.dom.Document;
     22 import org.w3c.dom.Element;
     23 
     24 import java.util.Arrays;
     25 
     26 import javax.xml.parsers.DocumentBuilder;
     27 import javax.xml.parsers.DocumentBuilderFactory;
     28 
     29 import junit.framework.TestCase;
     30 
     31 @SuppressWarnings("javadoc")
     32 public class DomUtilitiesTest extends TestCase {
     33 
     34     public void testIsEquivalent() throws Exception {
     35         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     36         factory.setNamespaceAware(true);
     37         factory.setValidating(false);
     38         DocumentBuilder builder = factory.newDocumentBuilder();
     39         Document document1 = builder.newDocument();
     40         Document document2 = builder.newDocument();
     41         document1.appendChild(document1.createElement("root"));
     42         document2.appendChild(document2.createElement("root"));
     43 
     44         assertFalse(DomUtilities.isEquivalent(null, null));
     45         Element root1 = document1.getDocumentElement();
     46         assertFalse(DomUtilities.isEquivalent(null, root1));
     47         Element root2 = document2.getDocumentElement();
     48         assertFalse(DomUtilities.isEquivalent(root2, null));
     49         assertTrue(DomUtilities.isEquivalent(root1, root2));
     50 
     51         root1.appendChild(document1.createTextNode("    "));
     52         // Differences in text are NOT significant!
     53         assertTrue(DomUtilities.isEquivalent(root1, root2));
     54         root2.appendChild(document2.createTextNode("    "));
     55         assertTrue(DomUtilities.isEquivalent(root1, root2));
     56 
     57         Element foo1 = document1.createElement("foo");
     58         Element foo2 = document2.createElement("foo");
     59         root1.appendChild(foo1);
     60         assertFalse(DomUtilities.isEquivalent(root1, root2));
     61         root2.appendChild(foo2);
     62         assertTrue(DomUtilities.isEquivalent(root1, root2));
     63 
     64         root1.appendChild(document1.createElement("bar"));
     65         assertFalse(DomUtilities.isEquivalent(root1, root2));
     66         root2.appendChild(document2.createElement("bar"));
     67         assertTrue(DomUtilities.isEquivalent(root1, root2));
     68 
     69         // Add attributes in opposite order
     70         foo1.setAttribute("attribute1", "value1");
     71         foo1.setAttribute("attribute2", "value2");
     72         assertFalse(DomUtilities.isEquivalent(root1, root2));
     73         foo2.setAttribute("attribute2", "value2");
     74         foo2.setAttribute("attribute1", "valueWrong");
     75         assertFalse(DomUtilities.isEquivalent(root1, root2));
     76         foo2.setAttribute("attribute1", "value1");
     77         assertTrue(DomUtilities.isEquivalent(root1, root2));
     78         foo2.setAttributeNS(TOOLS_URI, "foo", "bar");
     79         assertTrue(DomUtilities.isEquivalent(root1, root2));
     80         foo2.setAttributeNS(ANDROID_URI, "foo", "bar");
     81         assertFalse(DomUtilities.isEquivalent(root1, root2));
     82 
     83         // TODO - test different tag names
     84         // TODO - test different name spaces!
     85     }
     86 
     87     public void testIsContiguous() throws Exception {
     88         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     89         factory.setNamespaceAware(true);
     90         factory.setValidating(false);
     91         DocumentBuilder builder = factory.newDocumentBuilder();
     92         Document document = builder.newDocument();
     93         document.appendChild(document.createElement("root"));
     94         Element root = document.getDocumentElement();
     95         root.appendChild(document.createTextNode("    "));
     96         Element foo = document.createElement("foo");
     97         root.appendChild(foo);
     98         root.appendChild(document.createTextNode("    "));
     99         Element bar = document.createElement("bar");
    100         root.appendChild(bar);
    101         Element baz = document.createElement("baz");
    102         root.appendChild(baz);
    103 
    104         assertTrue(DomUtilities.isContiguous(Arrays.asList(foo)));
    105         assertTrue(DomUtilities.isContiguous(Arrays.asList(foo, bar)));
    106         assertTrue(DomUtilities.isContiguous(Arrays.asList(foo, bar, baz)));
    107         assertTrue(DomUtilities.isContiguous(Arrays.asList(foo, bar, baz)));
    108         assertTrue(DomUtilities.isContiguous(Arrays.asList(bar, baz, foo)));
    109         assertTrue(DomUtilities.isContiguous(Arrays.asList(baz, bar, foo)));
    110         assertTrue(DomUtilities.isContiguous(Arrays.asList(baz, foo, bar)));
    111 
    112         assertFalse(DomUtilities.isContiguous(Arrays.asList(foo, baz)));
    113         assertFalse(DomUtilities.isContiguous(Arrays.asList(root, baz)));
    114     }
    115 
    116     public void testGetCommonAncestor() throws Exception {
    117         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    118         factory.setNamespaceAware(true);
    119         factory.setValidating(false);
    120         DocumentBuilder builder = factory.newDocumentBuilder();
    121         Document document = builder.newDocument();
    122 
    123         //            A
    124         //          /   \
    125         //         B     C
    126         //              / \
    127         //             D   E
    128 
    129         document.appendChild(document.createElement("A"));
    130         Element a = document.getDocumentElement();
    131         assertSame(a, DomUtilities.getCommonAncestor(a, a));
    132 
    133         Element b = document.createElement("B");
    134         a.appendChild(b);
    135         Element c = document.createElement("C");
    136         a.appendChild(c);
    137         Element d = document.createElement("D");
    138         c.appendChild(d);
    139         Element e = document.createElement("E");
    140         c.appendChild(e);
    141 
    142         assertSame(a, DomUtilities.getCommonAncestor(a, b));
    143         assertSame(a, DomUtilities.getCommonAncestor(b, a));
    144         assertSame(a, DomUtilities.getCommonAncestor(b, c));
    145         assertSame(a, DomUtilities.getCommonAncestor(b, d));
    146         assertSame(a, DomUtilities.getCommonAncestor(b, e));
    147         assertSame(a, DomUtilities.getCommonAncestor(a, e));
    148 
    149         assertSame(c, DomUtilities.getCommonAncestor(d, e));
    150         assertSame(c, DomUtilities.getCommonAncestor(c, e));
    151         assertSame(c, DomUtilities.getCommonAncestor(d, c));
    152         assertSame(c, DomUtilities.getCommonAncestor(c, c));
    153     }
    154 
    155     public void testGetDepth() throws Exception {
    156         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    157         factory.setNamespaceAware(true);
    158         factory.setValidating(false);
    159         DocumentBuilder builder = factory.newDocumentBuilder();
    160         Document document = builder.newDocument();
    161 
    162         //            A
    163         //          /   \
    164         //         B     C
    165         //              / \
    166         //             D   E
    167 
    168         document.appendChild(document.createElement("A"));
    169         Element a = document.getDocumentElement();
    170         assertSame(a, DomUtilities.getCommonAncestor(a, a));
    171         Element b = document.createElement("B");
    172         a.appendChild(b);
    173         Element c = document.createElement("C");
    174         a.appendChild(c);
    175         Element d = document.createElement("D");
    176         c.appendChild(d);
    177         Element e = document.createElement("E");
    178         c.appendChild(e);
    179 
    180         assertEquals(0, DomUtilities.getDepth(document));
    181 
    182         assertEquals(1, DomUtilities.getDepth(a));
    183         assertEquals(2, DomUtilities.getDepth(b));
    184         assertEquals(2, DomUtilities.getDepth(c));
    185         assertEquals(3, DomUtilities.getDepth(d));
    186         assertEquals(3, DomUtilities.getDepth(e));
    187     }
    188 
    189     public void testHasChildren() throws Exception {
    190         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    191         factory.setNamespaceAware(true);
    192         factory.setValidating(false);
    193         DocumentBuilder builder = factory.newDocumentBuilder();
    194         Document document = builder.newDocument();
    195         assertFalse(DomUtilities.hasElementChildren(document));
    196         document.appendChild(document.createElement("A"));
    197         Element a = document.getDocumentElement();
    198         assertFalse(DomUtilities.hasElementChildren(a));
    199         a.appendChild(document.createTextNode("foo"));
    200         assertFalse(DomUtilities.hasElementChildren(a));
    201         Element b = document.createElement("B");
    202         a.appendChild(b);
    203         assertTrue(DomUtilities.hasElementChildren(a));
    204         assertFalse(DomUtilities.hasElementChildren(b));
    205     }
    206 }
    207