harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mloe...@apache.org
Subject svn commit: r427121 [27/29] - in /incubator/harmony/enhanced/classlib/trunk/modules/swing: make/ src/main/java/common/javax/swing/ src/main/java/common/javax/swing/text/ src/main/java/common/javax/swing/text/html/ src/main/java/common/javax/swing/text/...
Date Mon, 31 Jul 2006 14:08:55 GMT
Added: incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_RulesTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_RulesTest.java?rev=427121&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_RulesTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_RulesTest.java Mon Jul 31 07:08:47 2006
@@ -0,0 +1,337 @@
+/*
+ *  Copyright 2005 - 2006 The Apache Software Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/**
+ * @author Alexey A. Ivanov
+ * @version $Revision$
+ */
+package javax.swing.text.html;
+
+import java.awt.Color;
+import java.util.Enumeration;
+
+import javax.swing.BasicSwingTestCase;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.MutableAttributeSet;
+import javax.swing.text.SimpleAttributeSet;
+import javax.swing.text.Style;
+import javax.swing.text.StyleConstants;
+import javax.swing.text.StyleContext;
+import javax.swing.text.html.CSS.Attribute;
+
+public class StyleSheet_RulesTest extends BasicSwingTestCase {
+    private StyleSheet ss;
+    private Enumeration rules;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        ss = new StyleSheet();
+    }
+
+    /**
+     * Several rules (selector - property list pairs) in one string.
+     */
+    public void testAddRule01() throws Exception {
+        ss.addRule("p { text-align: right; }\nem {color: red}");
+        Style pStyle = null;
+        Style emStyle = null;
+        Style defStyle = null;
+        rules = ss.getStyleNames();
+        while (rules.hasMoreElements()) {
+            String name = (String)rules.nextElement();
+            Style style = ss.getStyle(name);
+            if ("p".equals(name)) {
+                pStyle = style;
+            } else if ("em".equals(name)) {
+                emStyle = style;
+            } else if (StyleContext.DEFAULT_STYLE.equals(name)) {
+                defStyle = style;
+            } else {
+                fail("Unexpected style: " + style);
+            }
+        }
+
+        assertEquals(2, pStyle.getAttributeCount());
+        assertEquals("right",
+                     pStyle.getAttribute(Attribute.TEXT_ALIGN).toString());
+        assertNotNull(pStyle.getAttribute(AttributeSet.NameAttribute));
+        assertEquals(StyleConstants.ALIGN_RIGHT,
+                     ((Integer)pStyle.getAttribute(StyleConstants.Alignment))
+                     .intValue());
+
+        assertEquals(2, emStyle.getAttributeCount());
+        assertEquals("red",
+                     emStyle.getAttribute(Attribute.COLOR).toString());
+        assertNotNull(emStyle.getAttribute(AttributeSet.NameAttribute));
+        assertEquals(Color.RED,
+                     emStyle.getAttribute(StyleConstants.Foreground));
+
+        assertEquals(1, defStyle.getAttributeCount());
+        assertNotNull(defStyle.getAttribute(AttributeSet.NameAttribute));
+    }
+
+    /**
+     * Several properties defined for one selector.
+     */
+    public void testAddRule02() throws Exception {
+        ss.addRule("p { text-align: justify; background-color: black; " +
+                   "color: white }");
+        Style pStyle = null;
+        rules = ss.getStyleNames();
+        while (rules.hasMoreElements()) {
+            String name = (String)rules.nextElement();
+            Style style = ss.getStyle(name);
+            if ("p".equals(name)) {
+                pStyle = style;
+            } else if (!StyleContext.DEFAULT_STYLE.equals(name)) {
+                fail("Unexpected style: " + style);
+            }
+        }
+
+        assertEquals(4, pStyle.getAttributeCount());
+        assertEquals("justify",
+                     pStyle.getAttribute(Attribute.TEXT_ALIGN).toString());
+        assertEquals(StyleConstants.ALIGN_JUSTIFIED,
+                     ((Integer)pStyle.getAttribute(StyleConstants.Alignment))
+                     .intValue());
+
+        assertEquals("white",
+                     pStyle.getAttribute(Attribute.COLOR).toString());
+        assertEquals(Color.WHITE,
+                     pStyle.getAttribute(StyleConstants.Foreground));
+
+        assertEquals("black",
+                     pStyle.getAttribute(Attribute.BACKGROUND_COLOR).toString());
+        assertEquals(Color.BLACK,
+                     pStyle.getAttribute(StyleConstants.Background));
+        assertNotNull(pStyle.getAttribute(AttributeSet.NameAttribute));
+    }
+
+    /**
+     * Tests that <code>addRule</code> uses <code>addCSSAttribute</code>
+     * to fill the attribute set.
+     */
+    public void testAddRule03() throws Exception {
+        final Marker marker = new Marker();
+        ss = new StyleSheet() {
+            public void addCSSAttribute(final MutableAttributeSet attr,
+                                        final Attribute key,
+                                        final String value) {
+                marker.setOccurred();
+//                assertFalse(attr instanceof Style);
+                assertSame(Attribute.FONT_SIZE, key);
+                assertEquals("21pt", value);
+                super.addCSSAttribute(attr, key, value);
+            }
+        };
+        ss.addRule("   p    {  font-size   :   21pt   }    ");
+
+        assertTrue(marker.isOccurred());
+    }
+
+    /**
+     * Tests that <code>addRule</code> calls <code>addStyle</code> to actually
+     * add the rule.
+     */
+    public void testAddRule04() throws Exception {
+        final Marker marker = new Marker();
+        ss = new StyleSheet() {
+            public Style addStyle(String name, Style parent) {
+                marker.setOccurred();
+                if (marker.getAuxiliary() != null) {
+                    assertEquals("p", name);
+                    assertNull(parent);
+                } else {
+                    assertEquals("default", name);
+                    marker.setAuxiliary(name);
+                }
+                return super.addStyle(name, parent);
+            }
+        };
+        assertTrue(marker.isOccurred());
+        marker.setOccurred(false);
+
+        ss.addRule("   p    {  font-size   :   21pt   }    ");
+        assertTrue(marker.isOccurred());
+    }
+
+    /**
+     * Tests that <code>addRule</code> stores rule as Style.
+     */
+    public void testAddRule05() throws Exception {
+        ss.addRule("em { text-decoration: underline }");
+        Style emStyle = ss.getStyle("em");
+
+        assertEquals(2, emStyle.getAttributeCount());
+        assertEquals("underline",
+                     emStyle.getAttribute(CSS.Attribute.TEXT_DECORATION)
+                     .toString());
+        assertEquals("em", emStyle.getAttribute(AttributeSet.NameAttribute));
+    }
+
+    /**
+     * Adding Style IS/IS NOT equivalent to adding a rule.
+     */
+    public void testAddRule06() throws Exception {
+        Style emStyle = ss.getStyle("em");
+        assertNull(emStyle);
+
+        emStyle = ss.addStyle("em", null);
+        ss.addCSSAttribute(emStyle, CSS.Attribute.TEXT_DECORATION, "underline");
+
+        Style emRule = ss.getRule("em");
+        assertNotNull(emRule);
+        assertEquals(isHarmony() ? 2 : 0, emRule.getAttributeCount());
+    }
+
+    /**
+     * Adding a property with several selectors.
+     */
+    public void testAddRule07() throws Exception {
+        assertNull(ss.getStyle("ol"));
+        assertNull(ss.getStyle("ul"));
+
+        ss.addRule("ol, ul { margin-left: 3pt }");
+
+        Style ol = ss.getStyle("ol");
+        assertNotNull(ol.getAttribute(Attribute.MARGIN_LEFT));
+
+        Style ul = ss.getStyle("ul");
+        assertNotNull(ul.getAttribute(Attribute.MARGIN_LEFT));
+    }
+
+    /**
+     * Tags are not case-sensitive in HTML.
+     */
+    public void testAddRule08() throws Exception {
+        assertNull(ss.getStyle("h1"));
+        assertNull(ss.getStyle("H1"));
+        ss.addRule("H1 { color: blue }");
+        assertNotNull(ss.getStyle("h1"));
+        assertNull(ss.getStyle("H1"));
+
+
+        Style h1 = ss.getRule("h1");
+        assertEquals(2, h1.getAttributeCount());
+        assertEquals("blue", h1.getAttribute(CSS.Attribute.COLOR).toString());
+
+        Style H1 = ss.getRule("H1");
+        if (isHarmony()) {
+            assertEquals(2, H1.getAttributeCount());
+            assertEquals("blue", H1.getAttribute(CSS.Attribute.COLOR).toString());
+            assertSame(h1, H1);
+        } else {
+            assertEquals(0, H1.getAttributeCount());
+            assertNull(H1.getAttribute(CSS.Attribute.COLOR));
+            assertNotSame(h1, H1);
+        }
+    }
+
+    /**
+     * Classes are case-sensitive.
+     */
+    public void testAddRule09() throws Exception {
+        assertNull(ss.getStyle(".header"));
+        assertNull(ss.getStyle(".HEADER"));
+        ss.addRule(".HEADER { color: blue }");
+        Style headerStyle = ss.getStyle(".header");
+        Style HEADERstyle = ss.getStyle(".HEADER");
+        Style headerRule = ss.getRule(".header");
+        Style HEADERrule = ss.getRule(".HEADER");
+        if (isHarmony()) {
+            assertNull(headerStyle);
+            assertNotNull(HEADERstyle);
+
+            assertEquals(0, headerRule.getAttributeCount());
+            assertEquals(2, HEADERrule.getAttributeCount());
+        } else {
+            assertNotNull(headerStyle);
+            assertNull(HEADERstyle);
+
+            assertEquals(2, headerRule.getAttributeCount());
+            assertEquals(0, HEADERrule.getAttributeCount());
+        }
+        assertNotSame(headerRule, HEADERrule);
+    }
+
+    /**
+     * ids are case-sensitive.
+     */
+    public void testAddRule10() throws Exception {
+        assertNull(ss.getStyle(".id"));
+        assertNull(ss.getStyle(".ID"));
+        ss.addRule("#ID { color: blue }");
+        Style idStyle = ss.getStyle("#id");
+        Style IDstyle = ss.getStyle("#ID");
+        Style idRule = ss.getRule("#id");
+        Style IDrule = ss.getRule("#ID");
+        if (isHarmony()) {
+            assertNull(idStyle);
+            assertNotNull(IDstyle);
+
+            assertEquals(0, idRule.getAttributeCount());
+            assertEquals(2, IDrule.getAttributeCount());
+        } else {
+            assertNotNull(idStyle);
+            assertNull(IDstyle);
+
+            assertEquals(2, idRule.getAttributeCount());
+            assertEquals(0, IDrule.getAttributeCount());
+        }
+        assertNotSame(idRule, IDrule);
+    }
+
+    /**
+     * Parses one property using <code>addCSSAttribute</code> to add
+     * the attribute to the set.
+     */
+    public void testGetDeclaration01() throws Exception {
+        final Marker marker = new Marker();
+        ss = new StyleSheet() {
+            public void addCSSAttribute(final MutableAttributeSet attr,
+                                        final Attribute key,
+                                        final String value) {
+                marker.setOccurred();
+                assertSame(Attribute.FONT_SIZE, key);
+                assertEquals("13pt", value);
+                super.addCSSAttribute(attr, key, value);
+            }
+        };
+        AttributeSet attr = ss.getDeclaration("font-size: 13pt");
+        assertTrue(marker.isOccurred());
+        assertEquals("13pt", attr.getAttribute(Attribute.FONT_SIZE).toString());
+//        assertEquals(13, ((Integer)attr.getAttribute(StyleConstants.FontSize))
+//                         .intValue());
+        assertNull(attr.getAttribute(StyleConstants.FontSize));
+
+        assertSame(SimpleAttributeSet.class, attr.getClass());
+    }
+
+    /**
+     * Parses several properties at once.
+     */
+    public void testGetDeclaration02() throws Exception {
+        AttributeSet attr = ss.getDeclaration("font-family: monospace; " +
+                                              "color: rgb(11, 33, 99); " +
+                                              "text-align: center");
+        assertEquals(3, attr.getAttributeCount());
+        assertEquals("monospace",
+                     attr.getAttribute(Attribute.FONT_FAMILY).toString());
+        assertEquals("rgb(11, 33, 99)",
+                     attr.getAttribute(Attribute.COLOR).toString());
+        assertEquals("center",
+                     attr.getAttribute(Attribute.TEXT_ALIGN).toString());
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_Small_Test.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_Small_Test.java?rev=427121&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_Small_Test.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_Small_Test.java Mon Jul 31 07:08:47 2006
@@ -0,0 +1,166 @@
+/*
+ *  Copyright 2005 - 2006 The Apache Software Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/**
+ * @author Alexey A. Ivanov
+ * @version $Revision$
+ */
+package javax.swing.text.html;
+
+import java.util.Enumeration;
+
+import javax.swing.BasicSwingTestCase;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.MutableAttributeSet;
+import javax.swing.text.SimpleAttributeSet;
+import javax.swing.text.StyleConstants;
+import javax.swing.text.html.CSS.Attribute;
+
+/**
+ * Tests <code>SmallAttributeSet</code> returned by
+ * <code>StyleSheet.addAttribute</code> method. The returned attribute set
+ * contains <code>CSS.Attribute</code>. It converts the value to
+ * <code>StyleConstants</code> when a <code>StyleConstants</code> attribute
+ * is requested.
+ * <p>
+ * The attribute used for testing is <code>StyleConstants.Bold</code>.
+ * It corresponds to <code>Attribute.FONT_WEIGHT</code>.
+ *
+ * @see StyleSheet
+ * @see StyleSheet#addAttribute(Object, Object)
+ * @see StyleSheet#createSmallAttributeSet(AttributeSet)
+ * @see CSS.Attribute
+ * @see javax.swing.text.StyleContext.SmallAttributeSet
+ */
+public class StyleSheet_Small_Test extends BasicSwingTestCase {
+    private static final Object scAttribute  = StyleConstants.Bold;
+    private static final Object scValue      = Boolean.TRUE;
+    private static final Object cssAttribute = Attribute.FONT_WEIGHT;
+
+    private StyleSheet ss;
+    private AttributeSet empty;
+    private AttributeSet attr;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        ss = new StyleSheet();
+        empty = ss.getEmptySet();
+
+        attr = ss.addAttribute(empty, scAttribute, scValue);
+    }
+
+    public void testGetAttribute() throws Exception {
+        Object value = attr.getAttribute(cssAttribute);
+        assertNotSame(Boolean.class, value.getClass());
+        assertNotSame(String.class, value.getClass());
+        assertEquals("bold", value.toString());
+
+        value = attr.getAttribute(scAttribute);
+        assertSame(Boolean.class, value.getClass());
+        assertTrue(((Boolean)value).booleanValue());
+        assertSame(scValue, value);
+    }
+
+    public void testIsDefined() throws Exception {
+        assertTrue(attr.isDefined(scAttribute));
+        assertTrue(attr.isDefined(cssAttribute));
+    }
+
+    public void testGetNames() throws Exception {
+        final Enumeration keys = attr.getAttributeNames();
+        final Object key = keys.nextElement();
+        assertSame(cssAttribute, key);
+        assertFalse(keys.hasMoreElements());
+    }
+
+    public void testGetAttributeCount() throws Exception {
+        assertEquals(1, attr.getAttributeCount());
+    }
+
+    public void testIsEqualSame() throws Exception {
+        assertTrue(attr.isEqual(attr));
+
+        final MutableAttributeSet simple = new SimpleAttributeSet(attr);
+        assertTrue(attr.isEqual(simple));
+        assertTrue(simple.isEqual(attr));
+    }
+
+    public void testIsEqualMutable() throws Exception {
+        final MutableAttributeSet simple = new SimpleAttributeSet();
+        simple.addAttribute(scAttribute, scValue);
+
+        assertTrue(attr.isEqual(simple));
+        if (isHarmony()) {
+            assertTrue(simple.isEqual(attr));
+        } else {
+            assertFalse(simple.isEqual(attr));
+        }
+    }
+
+    public void testCopyAttributes() throws Exception {
+        assertSame(attr, attr.copyAttributes());
+    }
+
+    public void testContainsAttribute() throws Exception {
+        assertTrue(attr.containsAttribute(cssAttribute,
+                                          attr.getAttribute(cssAttribute)));
+        assertTrue(attr.containsAttribute(scAttribute, scValue));
+    }
+
+    public void testContainsAttributeAnother() throws Exception {
+        final AttributeSet another = ss.addAttribute(empty,
+                                                     scAttribute, scValue);
+
+        assertEquals(attr.getAttribute(cssAttribute).toString(),
+                     another.getAttribute(cssAttribute).toString());
+        if (isHarmony()) {
+            assertTrue(attr.containsAttribute(cssAttribute,
+                                              another.getAttribute(cssAttribute)));
+        } else {
+            assertFalse(attr.containsAttribute(cssAttribute,
+                                               another.getAttribute(cssAttribute)));
+        }
+    }
+
+    public void testContainsAttributesSame() throws Exception {
+        assertTrue(attr.containsAttributes(attr));
+
+        final MutableAttributeSet simple = new SimpleAttributeSet(attr);
+
+        assertTrue(attr.containsAttributes(simple));
+        assertTrue(simple.containsAttributes(attr));
+    }
+
+    public void testContainsAttributesMutable() throws Exception {
+        final MutableAttributeSet simple = new SimpleAttributeSet();
+        simple.addAttribute(scAttribute, scValue);
+
+        assertTrue(attr.containsAttributes(simple));
+        assertFalse(simple.containsAttributes(attr));
+    }
+
+    public void testContainsAttributesSmall() throws Exception {
+        final AttributeSet another = ss.addAttribute(empty,
+                                                     scAttribute, scValue);
+
+        if (isHarmony()) {
+            assertTrue(attr.containsAttributes(another));
+            assertTrue(another.containsAttributes(attr));
+        } else {
+            assertFalse(attr.containsAttributes(another));
+            assertFalse(another.containsAttributes(attr));
+        }
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_StyleSheetsTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_StyleSheetsTest.java?rev=427121&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_StyleSheetsTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_StyleSheetsTest.java Mon Jul 31 07:08:47 2006
@@ -0,0 +1,135 @@
+/*
+ *  Copyright 2005 - 2006 The Apache Software Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/**
+ * @author Alexey A. Ivanov
+ * @version $Revision$
+ */
+package javax.swing.text.html;
+
+import javax.swing.text.Style;
+import javax.swing.text.html.CSS.Attribute;
+
+import junit.framework.TestCase;
+
+public class StyleSheet_StyleSheetsTest extends TestCase {
+    private StyleSheet ss;
+    private StyleSheet second;
+    private StyleSheet third;
+    private StyleSheet[] sheets;
+    private Style rule;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        ss = new StyleSheet();
+    }
+
+    public void testGetStyleSheets() {
+        sheets = ss.getStyleSheets();
+        assertNull(sheets);
+
+        second = new StyleSheet();
+        ss.addStyleSheet(second);
+        sheets = ss.getStyleSheets();
+        assertEquals(1, sheets.length);
+        assertSame(second, sheets[0]);
+    }
+
+    public void testAddStyleSheet() {
+        second = new StyleSheet();
+        third = new StyleSheet();
+        ss.addStyleSheet(second);
+        ss.addStyleSheet(third);
+
+        sheets = ss.getStyleSheets();
+        assertEquals(2, sheets.length);
+        assertSame(third, sheets[0]);
+        assertSame(second, sheets[1]);
+    }
+
+    public void testAddStyleSheetDuplicate() {
+        second = new StyleSheet();
+        ss.addStyleSheet(second);
+        assertEquals(1, ss.getStyleSheets().length);
+        ss.addStyleSheet(second);
+        assertEquals(1, ss.getStyleSheets().length);
+    }
+
+    public void testAddStyleSheetUpdateRule() {
+        rule = ss.getRule("p");
+        second = new StyleSheet();
+        second.addRule("p { color: red }");
+        ss.addStyleSheet(second);
+
+        assertEquals(2, rule.getAttributeCount());
+        assertEquals("red", rule.getAttribute(Attribute.COLOR).toString());
+
+        third = new StyleSheet();
+        third.addRule("p { color: blue }");
+        ss.addStyleSheet(third);
+
+        assertEquals(4, rule.getAttributeCount());
+        assertEquals("blue", rule.getAttribute(Attribute.COLOR).toString());
+    }
+
+    public void testAddStyleSheetOverrideRule() {
+        ss.addRule("p { color: black }");
+        rule = ss.getRule("p");
+        assertEquals("black", rule.getAttribute(Attribute.COLOR).toString());
+
+        second = new StyleSheet();
+        second.addRule("p { color: red }");
+        ss.addStyleSheet(second);
+        assertEquals("black", rule.getAttribute(Attribute.COLOR).toString());
+    }
+
+    public void testRemoveStyleSheet() {
+        second = new StyleSheet();
+        third  = new StyleSheet();
+        ss.addStyleSheet(second);
+        ss.addStyleSheet(third);
+
+        assertEquals(2, ss.getStyleSheets().length);
+
+        ss.removeStyleSheet(second);
+        assertEquals(1, ss.getStyleSheets().length);
+        assertEquals(third, ss.getStyleSheets()[0]);
+
+        ss.removeStyleSheet(second);
+        assertEquals(1, ss.getStyleSheets().length);
+
+        ss.removeStyleSheet(third);
+        assertNull(ss.getStyleSheets());
+    }
+
+    public void testRemoveStyleSheetRuleChange() {
+        rule = ss.getRule("p");
+        second = new StyleSheet();
+        second.addRule("p { color: red }");
+        ss.addStyleSheet(second);
+
+        third = new StyleSheet();
+        third.addRule("p { color: blue }");
+        ss.addStyleSheet(third);
+        assertEquals("blue", rule.getAttribute(Attribute.COLOR).toString());
+
+        ss.removeStyleSheet(third);
+        assertEquals("red", rule.getAttribute(Attribute.COLOR).toString());
+
+        ss.removeStyleSheet(second);
+        assertEquals(0, rule.getAttributeCount());
+        assertNull(rule.getAttribute(Attribute.COLOR));
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_TranslateHTMLToCSS.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_TranslateHTMLToCSS.java?rev=427121&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_TranslateHTMLToCSS.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_TranslateHTMLToCSS.java Mon Jul 31 07:08:47 2006
@@ -0,0 +1,473 @@
+/*
+ *  Copyright 2005 - 2006 The Apache Software Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/**
+ * @author Alexey A. Ivanov
+ * @version $Revision$
+ */
+package javax.swing.text.html;
+
+import java.awt.Rectangle;
+import java.io.StringReader;
+
+import javax.swing.BasicSwingTestCase;
+import javax.swing.event.DocumentEvent;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.DefaultStyledDocument;
+import javax.swing.text.Document;
+import javax.swing.text.Element;
+import javax.swing.text.MutableAttributeSet;
+import javax.swing.text.SimpleAttributeSet;
+import javax.swing.text.StyledDocument;
+import javax.swing.text.View;
+import javax.swing.text.AbstractDocument.AbstractElement;
+import javax.swing.text.AbstractDocument.BranchElement;
+import javax.swing.text.StyleContext.NamedStyle;
+import javax.swing.text.html.HTMLDocument.BlockElement;
+import javax.swing.text.html.HTMLDocument.RunElement;
+
+public class StyleSheet_TranslateHTMLToCSS extends BasicSwingTestCase {
+    private static class TestDocument extends HTMLDocument {
+        public TestDocument() {
+            super();
+        }
+
+        public TestDocument(final StyleSheet ss) {
+            super(ss);
+        }
+
+        public void lockWrite() {
+            writeLock();
+        }
+
+        public void unlockWrite() {
+            writeUnlock();
+        }
+    }
+
+    private TestDocument doc;
+    private StyleSheet ss;
+    private AttributeSet attr;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        setIgnoreNotImplemented(true);
+        doc = new TestDocument();
+        doc.insertString(0, "normal test text", null);
+        ss = new StyleSheet();
+
+        doc.lockWrite();
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+
+        doc.unlockWrite();
+    }
+
+    public void testTranslateHTMLToCSSBody() throws Exception {
+        AbstractElement body =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", body.getName());
+        assertTrue(body instanceof BlockElement);
+
+        body.addAttribute(HTML.Attribute.BGCOLOR, "#ffffff");
+        body.addAttribute(HTML.Attribute.BACKGROUND, "bg.jpg");
+        body.addAttribute(HTML.Attribute.TEXT, "black");
+        body.addAttribute(HTML.Attribute.LINK, "blue");
+        body.addAttribute(HTML.Attribute.ALINK, "red");
+        body.addAttribute(HTML.Attribute.VLINK, "purple");
+        attr = ss.translateHTMLToCSS(body);
+        assertSame(NamedStyle.class, attr.getClass());
+        assertNull(((NamedStyle)attr).getName());
+        assertEquals(3, attr.getAttributeCount());
+        assertEquals(isHarmony() ? "url(bg.jpg)" : "bg.jpg",
+                     attr.getAttribute(CSS.Attribute.BACKGROUND_IMAGE)
+                     .toString());
+        assertEquals("#ffffff",
+                     attr.getAttribute(CSS.Attribute.BACKGROUND_COLOR)
+                     .toString());
+        assertEquals("black",
+                     attr.getAttribute(CSS.Attribute.COLOR).toString());
+    }
+
+    public void testTranslateHTMLToCSSP() throws Exception {
+        AbstractElement p =
+            (AbstractElement)doc.getDefaultRootElement()
+                             .getElement(0).getElement(0);
+        assertEquals("p", p.getName());
+        assertTrue(p instanceof BlockElement);
+
+        p.addAttribute(HTML.Attribute.BGCOLOR, "#ffffff");
+        p.addAttribute(HTML.Attribute.BACKGROUND, "bg.jpg");
+        p.addAttribute(HTML.Attribute.TEXT, "black");
+        p.addAttribute(HTML.Attribute.LINK, "blue");
+        p.addAttribute(HTML.Attribute.ALINK, "red");
+        p.addAttribute(HTML.Attribute.VLINK, "purple");
+
+        attr = ss.translateHTMLToCSS(p);
+        assertSame(NamedStyle.class, attr.getClass());
+        assertNull(((NamedStyle)attr).getName());
+
+        assertEquals(4, attr.getAttributeCount());
+        assertEquals(isHarmony() ? "url(bg.jpg)" : "bg.jpg",
+                     attr.getAttribute(CSS.Attribute.BACKGROUND_IMAGE)
+                     .toString());
+        assertEquals("#ffffff",
+                     attr.getAttribute(CSS.Attribute.BACKGROUND_COLOR)
+                     .toString());
+        assertEquals("black",
+                     attr.getAttribute(CSS.Attribute.COLOR).toString());
+
+        assertEquals("0",
+                     attr.getAttribute(CSS.Attribute.MARGIN_TOP).toString());
+    }
+
+    public void testTranslateHTMLToCSSPContent() throws Exception {
+        AbstractElement content =
+            (AbstractElement)doc.getDefaultRootElement()
+                             .getElement(0).getElement(0).getElement(0);
+        assertEquals("content", content.getName());
+        assertTrue(content instanceof RunElement);
+
+        content.addAttribute(HTML.Attribute.BGCOLOR, "#ffffff");
+        content.addAttribute(HTML.Attribute.BACKGROUND, "bg.jpg");
+        content.addAttribute(HTML.Attribute.TEXT, "black");
+        content.addAttribute(HTML.Attribute.LINK, "blue");
+        content.addAttribute(HTML.Attribute.ALINK, "red");
+        content.addAttribute(HTML.Attribute.VLINK, "purple");
+
+        attr = ss.translateHTMLToCSS(content);
+        assertSame(NamedStyle.class, attr.getClass());
+        assertNull(((NamedStyle)attr).getName());
+        if (isHarmony()) {
+            assertEquals("url(bg.jpg)",
+                         attr.getAttribute(CSS.Attribute.BACKGROUND_IMAGE)
+                         .toString());
+            assertEquals("#ffffff",
+                         attr.getAttribute(CSS.Attribute.BACKGROUND_COLOR)
+                         .toString());
+            assertEquals("black",
+                         attr.getAttribute(CSS.Attribute.COLOR).toString());
+        } else {
+            assertEquals(0, attr.getAttributeCount());
+        }
+    }
+
+    public void testTranslateHTMLToCSSStyledDocument() throws Exception {
+        StyledDocument doc = new DefaultStyledDocument();
+        doc.insertString(0, "line1\nline2", null);
+
+        MutableAttributeSet mas = new SimpleAttributeSet();
+        mas.addAttribute(HTML.Attribute.BGCOLOR, "#ffffff");
+        mas.addAttribute(HTML.Attribute.TEXT, "black");
+        doc.setParagraphAttributes(0, 1, mas, false);
+
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("paragraph", branch.getName());
+        assertTrue(branch instanceof BranchElement);
+        assertSame(BranchElement.class, branch.getClass());
+
+
+        attr = ss.translateHTMLToCSS(branch);
+        assertSame(NamedStyle.class, attr.getClass());
+        assertNull(((NamedStyle)attr).getName());
+
+        assertEquals(2, attr.getAttributeCount());
+        assertEquals("#ffffff",
+                     attr.getAttribute(CSS.Attribute.BACKGROUND_COLOR)
+                     .toString());
+        assertEquals("black",
+                     attr.getAttribute(CSS.Attribute.COLOR).toString());
+    }
+
+    public void testTranslateHTMLToCSSA() throws Exception {
+        doc.remove(0, doc.getLength());
+        HTMLEditorKit kit = new HTMLEditorKit();
+        kit.read(new StringReader("<a href=\"http://go\">link</a>"), doc, 0);
+
+        AbstractElement body =
+            (AbstractElement)doc.getDefaultRootElement().getElement(1);
+        assertEquals("body", body.getName());
+
+        body.addAttribute(HTML.Attribute.BGCOLOR, "#ffffff");
+        body.addAttribute(HTML.Attribute.BACKGROUND, "bg.jpg");
+        body.addAttribute(HTML.Attribute.TEXT, "black");
+        body.addAttribute(HTML.Attribute.LINK, "blue");
+        body.addAttribute(HTML.Attribute.ALINK, "red");
+        body.addAttribute(HTML.Attribute.VLINK, "purple");
+
+        AbstractElement a = (AbstractElement)doc.getCharacterElement(2);
+        assertNotNull(a.getAttribute(HTML.Tag.A));
+        attr = ss.translateHTMLToCSS(a);
+        assertNull(((NamedStyle)attr).getName());
+        assertEquals(0, attr.getAttributeCount());
+    }
+
+    public void testTranslateHTMLToCSSAlignLeft() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.ALIGN, "left");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(1, attr.getAttributeCount());
+        assertEquals("left",
+                     attr.getAttribute(CSS.Attribute.TEXT_ALIGN).toString());
+    }
+
+    public void testTranslateHTMLToCSSAlignCenter() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.ALIGN, "center");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(1, attr.getAttributeCount());
+        assertEquals("center",
+                     attr.getAttribute(CSS.Attribute.TEXT_ALIGN).toString());
+    }
+
+    public void testTranslateHTMLToCSSAlignRight() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.ALIGN, "right");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(1, attr.getAttributeCount());
+        assertEquals("right",
+                     attr.getAttribute(CSS.Attribute.TEXT_ALIGN).toString());
+    }
+
+    public void testTranslateHTMLToCSSAlignJustify() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.ALIGN, "justify");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(1, attr.getAttributeCount());
+        assertEquals("justify",
+                     attr.getAttribute(CSS.Attribute.TEXT_ALIGN).toString());
+    }
+
+    public void testTranslateHTMLToCSSAlignTop() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.ALIGN, "top");
+        attr = ss.translateHTMLToCSS(branch);
+        if (isHarmony()) {
+            assertEquals(0, attr.getAttributeCount());
+            assertNull(attr.getAttribute(CSS.Attribute.TEXT_ALIGN));
+        } else {
+            assertEquals(1, attr.getAttributeCount());
+            assertEquals("top",
+                         attr.getAttribute(CSS.Attribute.TEXT_ALIGN).toString());
+        }
+    }
+
+    public void testTranslateHTMLToCSSAlignBottom() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.ALIGN, "bottom");
+        attr = ss.translateHTMLToCSS(branch);
+        if (isHarmony()) {
+            assertEquals(0, attr.getAttributeCount());
+            assertNull(attr.getAttribute(CSS.Attribute.TEXT_ALIGN));
+        } else {
+            assertEquals(1, attr.getAttributeCount());
+            assertEquals("bottom",
+                         attr.getAttribute(CSS.Attribute.TEXT_ALIGN).toString());
+        }
+    }
+
+    public void testTranslateHTMLToCSSAlignChar() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.ALIGN, "char");
+        attr = ss.translateHTMLToCSS(branch);
+        if (isHarmony()) {
+            assertEquals(0, attr.getAttributeCount());
+            assertNull(attr.getAttribute(CSS.Attribute.TEXT_ALIGN));
+        } else {
+            assertEquals(1, attr.getAttributeCount());
+            assertEquals("char",
+                         attr.getAttribute(CSS.Attribute.TEXT_ALIGN).toString());
+        }
+    }
+
+    public void testTranslateHTMLToCSSVAlignTop() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.VALIGN, "top");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(1, attr.getAttributeCount());
+        assertEquals("top",
+                     attr.getAttribute(CSS.Attribute.VERTICAL_ALIGN).toString());
+    }
+
+    public void testTranslateHTMLToCSSVAlignMiddle() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.VALIGN, "middle");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(1, attr.getAttributeCount());
+        assertEquals("middle",
+                     attr.getAttribute(CSS.Attribute.VERTICAL_ALIGN).toString());
+    }
+
+    public void testTranslateHTMLToCSSVAlignBottom() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.VALIGN, "bottom");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(1, attr.getAttributeCount());
+        assertEquals("bottom",
+                     attr.getAttribute(CSS.Attribute.VERTICAL_ALIGN).toString());
+    }
+
+    public void testTranslateHTMLToCSSVAlignBaseline() throws Exception {
+        AbstractElement branch =
+            (AbstractElement)doc.getDefaultRootElement().getElement(0);
+        assertEquals("body", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.VALIGN, "baseline");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(1, attr.getAttributeCount());
+        assertEquals("baseline",
+                     attr.getAttribute(CSS.Attribute.VERTICAL_ALIGN).toString());
+    }
+
+    public void testTranslateHTMLToCSSWidth() throws Exception {
+        AbstractElement branch = (AbstractElement)doc.getParagraphElement(0);
+        assertEquals("p", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.WIDTH, "50%");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(2, attr.getAttributeCount());
+        assertEquals("50%",
+                     attr.getAttribute(CSS.Attribute.WIDTH).toString());
+        assertEquals("0",
+                     attr.getAttribute(CSS.Attribute.MARGIN_TOP).toString());
+    }
+
+    public void testTranslateHTMLToCSSHeight() throws Exception {
+        AbstractElement branch = (AbstractElement)doc.getParagraphElement(0);
+        assertEquals("p", branch.getName());
+
+        branch.addAttribute(HTML.Attribute.HEIGHT, "331");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(2, attr.getAttributeCount());
+        assertEquals("331" + (isHarmony() ? "pt" : ""),
+                     attr.getAttribute(CSS.Attribute.HEIGHT).toString());
+        assertEquals("0",
+                     attr.getAttribute(CSS.Attribute.MARGIN_TOP).toString());
+    }
+
+    public void testTranslateHTMLToCSSStyle() throws Exception {
+        AbstractElement branch = (AbstractElement)doc.getParagraphElement(0);
+        assertEquals("p", branch.getName());
+
+        branch.addAttribute(CSS.Attribute.BORDER_BOTTOM_WIDTH, "1pt");
+        attr = ss.translateHTMLToCSS(branch);
+        assertEquals(2, attr.getAttributeCount());
+        assertEquals("1pt", attr.getAttribute(CSS.Attribute.BORDER_BOTTOM_WIDTH)
+                            .toString());
+        assertEquals("0",
+                     attr.getAttribute(CSS.Attribute.MARGIN_TOP).toString());
+    }
+
+    public void testTranslateHTMLToCSSViewAttributes() throws Exception {
+        final Marker gva = new Marker(true);
+        final Marker th2c = new Marker(true);
+        ss = new StyleSheet() {
+            public AttributeSet getViewAttributes(View v) {
+                gva.setOccurred();
+                return super.getViewAttributes(v);
+            }
+            public AttributeSet translateHTMLToCSS(AttributeSet htmlAttrSet) {
+                th2c.setOccurred();
+                return super.translateHTMLToCSS(htmlAttrSet);
+            }
+        };
+        doc = new TestDocument(ss);
+        doc.lockWrite();
+        final AbstractElement branch =
+            (AbstractElement)doc.getParagraphElement(0);
+        assertEquals("p", branch.getName());
+
+        assertFalse(gva.isOccurred());
+        assertFalse(th2c.isOccurred());
+        final View view = new InlineView(branch);
+        assertTrue(gva.isOccurred());
+        assertTrue(th2c.isOccurred());
+
+        final AttributeSet va = view.getAttributes();
+        assertFalse(gva.isOccurred());
+        assertFalse(th2c.isOccurred());
+
+        assertSame(va, view.getAttributes());
+        assertEquals(1, va.getAttributeCount());
+        assertEquals("0",
+                     va.getAttribute(CSS.Attribute.MARGIN_TOP).toString());
+
+        branch.addAttribute(HTML.Attribute.WIDTH, "200");
+
+        assertFalse(gva.isOccurred());
+        assertFalse(th2c.isOccurred());
+
+        view.changedUpdate(new DocumentEvent() {
+            public int getOffset() {
+                return branch.getStartOffset();
+            }
+            public int getLength() {
+                return branch.getEndOffset() - branch.getStartOffset();
+            }
+            public Document getDocument() {
+                return doc;
+            }
+            public EventType getType() {
+                return EventType.CHANGE;
+            }
+            public ElementChange getChange(final Element elem) {
+                return null;
+            }
+        }, new Rectangle(), null);
+        assertTrue(gva.isOccurred());
+        assertTrue(th2c.isOccurred());
+
+        final AttributeSet mva = view.getAttributes();
+        assertFalse(gva.isOccurred());
+        assertFalse(th2c.isOccurred());
+
+        assertNotSame(va, mva);
+        assertSame(mva, view.getAttributes());
+        assertEquals(2, mva.getAttributeCount());
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_ViewAttributesTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_ViewAttributesTest.java?rev=427121&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_ViewAttributesTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/StyleSheet_ViewAttributesTest.java Mon Jul 31 07:08:47 2006
@@ -0,0 +1,181 @@
+/*
+ *  Copyright 2005 - 2006 The Apache Software Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/**
+ * @author Alexey A. Ivanov
+ * @version $Revision$
+ */
+package javax.swing.text.html;
+
+import java.io.StringReader;
+
+import javax.swing.BasicSwingTestCase;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.Element;
+import javax.swing.text.Style;
+import javax.swing.text.View;
+import javax.swing.text.html.HTML.Tag;
+
+public class StyleSheet_ViewAttributesTest extends BasicSwingTestCase {
+    private HTMLDocument doc;
+    private StyleSheet ss;
+    private View view;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        setIgnoreNotImplemented(true);
+        ss = new StyleSheet();
+        doc = new HTMLDocument(ss);
+    }
+
+    public void testViewGetAttributes() throws Exception {
+        final Marker marker = new Marker();
+        ss = new StyleSheet() {
+            public AttributeSet getViewAttributes(final View v) {
+                marker.setOccurred();
+                marker.setAuxiliary(v);
+                return super.getViewAttributes(v);
+            };
+        };
+        doc = new HTMLDocument(ss);
+        view = new InlineView(doc.getCharacterElement(0));
+        assertTrue(marker.isOccurred());
+        assertSame(view, marker.getAuxiliary());
+    }
+
+    public void testGetViewAttributesGetRuleInline() throws Exception {
+        final Marker tag = new Marker();
+        final Marker sel = new Marker();
+        ss = new StyleSheet() {
+            public Style getRule(Tag t, Element elem) {
+                tag.setOccurred();
+                return super.getRule(t, elem);
+            }
+
+            public Style getRule(String selector) {
+                sel.setOccurred();
+                return super.getRule(selector);
+            }
+        };
+        view = new InlineView(doc.getCharacterElement(0));
+        ss.getViewAttributes(view);
+        assertFalse(tag.isOccurred());
+        assertFalse(sel.isOccurred());
+    }
+
+    public void testGetViewAttributesGetRuleBlock() throws Exception {
+        final Marker tag = new Marker();
+        final Marker sel = new Marker();
+        ss = new StyleSheet() {
+            public Style getRule(Tag t, Element elem) {
+                tag.setOccurred();
+                assertSame(HTML.Tag.P, t);
+                assertSame(view.getElement(), elem);
+                return super.getRule(t, elem);
+            }
+
+            public Style getRule(String selector) {
+                sel.setOccurred();
+                return super.getRule(selector);
+            }
+        };
+        view = new BlockView(doc.getParagraphElement(0), View.Y_AXIS);
+        ss.getViewAttributes(view);
+        assertTrue(tag.isOccurred());
+        assertFalse(sel.isOccurred());
+    }
+
+    public void testGetViewAttributesGetRuleInlineEm() throws Exception {
+        final Marker tag = new Marker();
+        final Marker sel = new Marker();
+        ss = new StyleSheet() {
+            public Style getRule(Tag t, Element elem) {
+                if (view != null) {
+                    tag.setOccurred();
+                    assertSame(HTML.Tag.EM, t);
+                    assertSame(view.getElement(), elem);
+                }
+                return super.getRule(t, elem);
+            }
+
+            public Style getRule(String selector) {
+                sel.setOccurred();
+                return super.getRule(selector);
+            }
+        };
+        doc = new HTMLDocument(ss);
+        HTMLEditorKit kit = new HTMLEditorKit();
+        kit.read(new StringReader("<em>emphasized</em>"), doc, 0);
+        Element inline = doc.getCharacterElement(1);
+        assertNotNull(inline.getAttributes()
+                      .getAttribute(AttributeSet.NameAttribute));
+        view = new InlineView(inline);
+        ss.getViewAttributes(view);
+        assertTrue(tag.isOccurred());
+        assertFalse(sel.isOccurred());
+    }
+
+    public void testGetViewAttributesTranslate() throws Exception {
+        final Marker marker = new Marker();
+        final Element block = doc.getParagraphElement(0);
+        ss = new StyleSheet() {
+            public AttributeSet translateHTMLToCSS(final AttributeSet attrs) {
+                marker.setOccurred();
+                assertSame(block, attrs);
+                return super.translateHTMLToCSS(attrs);
+            }
+        };
+        view = new BlockView(block, View.Y_AXIS);
+        assertFalse(marker.isOccurred());
+        ss.getViewAttributes(view);
+        assertTrue(marker.isOccurred());
+    }
+
+    public void testGetViewAttributesResolverNull() throws Exception {
+        final Element block = doc.getParagraphElement(0);
+        view = new BlockView(block, View.Y_AXIS);
+        AttributeSet va = ss.getViewAttributes(view);
+        assertNull(view.getParent());
+        assertNull(va.getResolveParent());
+    }
+
+    public void testGetViewAttributesResolver() throws Exception {
+        final Element block = doc.getParagraphElement(0);
+        final Element inline = block.getElement(0);
+
+        view = new InlineView(inline);
+        View bv = new BlockView(block, View.Y_AXIS);
+        view.setParent(bv);
+
+        AttributeSet va = ss.getViewAttributes(view);
+        assertSame(bv, view.getParent());
+        assertSame(bv.getAttributes(), va.getResolveParent());
+    }
+
+    public void testGetViewAttributesResolverChange() throws Exception {
+        final Element block = doc.getParagraphElement(0);
+        final Element inline = block.getElement(0);
+
+        view = new InlineView(inline);
+        View bv = new BlockView(block, View.Y_AXIS);
+
+        AttributeSet va = ss.getViewAttributes(view);
+        assertNull(view.getParent());
+        assertNull(va.getResolveParent());
+
+        view.setParent(bv);
+        assertSame(bv.getAttributes(), va.getResolveParent());
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/parser/AttributeListTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/parser/AttributeListTest.java?rev=427121&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/parser/AttributeListTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/parser/AttributeListTest.java Mon Jul 31 07:08:47 2006
@@ -0,0 +1,145 @@
+/*
+ *  Copyright 2005 - 2006 The Apache Software Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/**
+ * @author Evgeniya G. Maenkova
+ * @version $Revision$
+ */
+package javax.swing.text.html.parser;
+
+import java.util.Vector;
+import junit.framework.TestCase;
+
+public class AttributeListTest extends TestCase {
+       AttributeList attrList;
+       String name = "first";
+       int type = 26;
+       int modifier = 16;
+       String value = "value";
+       Vector values = new Vector();
+       AttributeList next = new AttributeList("second");
+
+
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        attrList = new AttributeList(name, type, modifier, value, values, next);
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+    }
+
+
+    public void testAttributeListConstr1() {
+        Utils.checkAttributeList(attrList, modifier, type,
+                                 name, next, values, value, true);
+    }
+
+
+    public void testAttributeListConstr2() {
+        assertEquals(0, next.modifier);
+        assertEquals("second", next.name);
+        assertEquals(null, next.next);
+        assertEquals(0, next.type);
+        assertEquals(null, next.value);
+        assertEquals(null, next.values);
+
+        AttributeList attributeList = new AttributeList(null);
+        assertEquals(null, attributeList.name);
+
+        attributeList = new AttributeList("AAA");
+        assertEquals("AAA", attributeList.name);
+    }
+
+    public void testGetNext() {
+        assertEquals(next, attrList.getNext());
+    }
+
+
+    public void testGetValue() {
+        assertEquals(value, attrList.getValue());
+    }
+
+
+    public void testGetValues() {
+        assertEquals(values.elements().getClass(),
+                     attrList.getValues().getClass());
+    }
+
+
+    public void testGetModifier() {
+        assertEquals(modifier, attrList.getModifier());
+    }
+
+
+    public void testGetType() {
+        assertEquals(type, attrList.getType());
+    }
+
+
+    public void testGetName() {
+        assertEquals(name, attrList.getName());
+    }
+
+    String[] names = new String[] {null,
+                                   "CDATA",
+                                   "ENTITY",
+                                   "ENTITIES",
+                                   "ID",
+                                   "IDREF",
+                                   "IDREFS",
+                                   "NAME",
+                                   "NAMES",
+                                   "NMTOKEN",
+                                   "NMTOKENS",
+                                   "NOTATION",
+                                   "NUMBER",
+                                   "NUMBERS",
+                                   "NUTOKEN",
+                                   "NUTOKENS"};
+
+    public void testType2name() {
+        for (int i = 0; i < 300; i++) {
+            assertEquals(i < 16 ? names[i] : null, AttributeList.type2name(i));
+        }
+    }
+
+
+    public void testName2type() {
+        for (int i = 0; i < 300; i++) {
+            if (i > 0 && i < 16) {
+                assertEquals(1, AttributeList.name2type(names[i]
+                                                              .toLowerCase()));
+                assertEquals(i, AttributeList.name2type(names[i]));
+            } else {
+                try {
+                    assertEquals(1, AttributeList.name2type(null));
+                    assertFalse("NPE not thrown", true);
+                } catch (NullPointerException e) {
+                }
+            }
+        }
+        assertEquals(1, AttributeList.name2type("test"));
+    }
+
+    public void testSerialization() {
+        AttributeList attributeList = (AttributeList)Utils
+            .doSerialization(attrList);
+        Utils.checkAttributeList(attributeList,
+                                 modifier, type, name,
+                                 next, values, value, false);
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/parser/ContentModelTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/parser/ContentModelTest.java?rev=427121&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/parser/ContentModelTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/swing/src/test/api/java.injected/javax/swing/text/html/parser/ContentModelTest.java Mon Jul 31 07:08:47 2006
@@ -0,0 +1,548 @@
+/*
+ *  Copyright 2005 - 2006 The Apache Software Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/**
+ * @author Evgeniya G. Maenkova
+ * @version $Revision$
+ */
+package javax.swing.text.html.parser;
+
+import java.awt.Rectangle;
+import java.util.Vector;
+
+import javax.swing.SwingTestCase;
+
+public class ContentModelTest extends SwingTestCase {
+    ContentModel contentModel;
+    Element[] elements;
+    char[] types;
+    Vector elemVec;
+    ContentModel contentModel1;
+    ContentModel contentModel2;
+    ContentModel contentModel3;
+    ContentModel contentModel4;
+    ContentModel contentModel5;
+    ContentModel contentModel6;
+    ContentModel contentModel7;
+    ContentModel contentModel8;
+    ContentModel contentModel9;
+    ContentModel contentModel10;
+    ContentModel contentModel11;
+    ContentModel contentModel12;
+    ContentModel contentModel13;
+    ContentModel contentModel14;
+
+
+    protected void setUp() throws Exception {
+        init();
+        resetElemVec();
+        super.setUp();
+    }
+
+    private void resetElemVec() {
+        if (elemVec == null) {
+            elemVec = new Vector();
+        } else {
+            elemVec.removeAllElements();
+        }
+    }
+
+    private void init() {
+        if (elements == null) {
+            elements = new Element[7];
+            for (int i = 0; i < 7; i++) {
+                elements[i] = new Element();
+                elements[i].name = Integer.toString(i);
+            }
+        }
+        if (types == null) {
+            types = new char[] {'*', '?', '+', ',', '|', '&'};
+        }
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+    }
+
+    public void testContentModelElement() {
+        contentModel = new ContentModel(elements[0]);
+        Utils.checkContentModel(contentModel, elements[0], 0, null);
+
+        contentModel = new ContentModel(null);
+        Utils.checkContentModel(contentModel, null, 0, null);
+    }
+
+    public void testContentModel() {
+        contentModel = new ContentModel();
+        Utils.checkContentModel(contentModel, null, 0, null);
+    }
+
+    public void testContentModelIntContentModel() {
+        contentModel1 = new ContentModel(elements[0]);
+
+        contentModel = new ContentModel('*', contentModel1);
+        Utils.checkContentModel(contentModel, contentModel1, '*', null);
+
+        contentModel = new ContentModel('?', contentModel1);
+        Utils.checkContentModel(contentModel, contentModel1, '?', null);
+
+        contentModel = new ContentModel('+', contentModel1);
+        Utils.checkContentModel(contentModel, contentModel1, '+', null);
+    }
+
+    public void testContentModelIntObjectContentModel() {
+        contentModel1 = new ContentModel(elements[0]);
+        contentModel = new ContentModel(',', elements[1], contentModel1);
+        Utils.checkContentModel(contentModel, elements[1], ',',
+                                contentModel1);
+
+        contentModel = new ContentModel('|', elements[1], contentModel1);
+        Utils.checkContentModel(contentModel, elements[1], '|',
+                                contentModel1);
+
+        contentModel = new ContentModel('&', elements[1], contentModel1);
+        Utils.checkContentModel(contentModel, elements[1], '&',
+                                contentModel1);
+
+        contentModel2 = new ContentModel(elements[1]);
+        contentModel = new ContentModel(',', contentModel2, contentModel1);
+        Utils.checkContentModel(contentModel, contentModel2, ',',
+                                contentModel1);
+
+        contentModel = new ContentModel('|', contentModel2, contentModel1);
+        Utils.checkContentModel(contentModel, contentModel2, '|',
+                                contentModel1);
+
+
+        contentModel = new ContentModel('&', contentModel2, contentModel1);
+        Utils.checkContentModel(contentModel, contentModel2, '&',
+                                contentModel1);
+    }
+
+    public void testIllegalArgumentException_Object() {
+        if (SwingTestCase.isHarmony()) {
+            contentModel1 = new ContentModel(elements[0]);
+            try {
+                contentModel = new ContentModel(',', new Rectangle(),
+                                            contentModel1);
+                throwException("1");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel(',', null,
+                                            contentModel1);
+                throwException("2");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('|', null,
+                                            contentModel1);
+                throwException("3");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('&', null,
+                                            contentModel1);
+                throwException("4");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel(',', elements[2],
+                                            null);
+                throwException("5");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('|', elements[2],
+                                            null);
+                throwException("6");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('&', elements[2],
+                                            null);
+                throwException("7");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('+', null);
+                throwException("8");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('*', null);
+                throwException("9");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('?', null);
+                throwException("10");
+            } catch (IllegalArgumentException e) {
+            }
+        }
+    }
+
+    public void testIllegalArgumentException_Type() {
+        if (SwingTestCase.isHarmony()) {
+            contentModel1 = new ContentModel(elements[0]);
+            try {
+                contentModel = new ContentModel(',', contentModel1);
+                throwException("0");
+            } catch (IllegalArgumentException e) {
+            }
+            try {
+                contentModel = new ContentModel('&', contentModel1);
+                throwException("1");
+            } catch (IllegalArgumentException e) {
+            }
+            try {
+                contentModel = new ContentModel('|', contentModel1);
+                throwException("2");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('a', contentModel1);
+                throwException("3");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('+', elements[0],
+                                                contentModel1);
+                throwException("4");
+            } catch (IllegalArgumentException e) {
+            }
+            try {
+                contentModel = new ContentModel('*', elements[0],
+                                                contentModel1);
+                throwException("5");
+            } catch (IllegalArgumentException e) {
+            }
+            try {
+                contentModel = new ContentModel('?', elements[0],
+                                                contentModel1);
+                throwException("6");
+            } catch (IllegalArgumentException e) {
+            }
+
+            try {
+                contentModel = new ContentModel('a', elements[0],
+                                                contentModel1);
+                throwException("7");
+            } catch (IllegalArgumentException e) {
+            }
+        }
+    }
+
+    private void throwException(final String s) {
+        assertFalse("IllegalArgumentException wasn't thrown:" + s, true);
+    }
+
+
+    public void testFirst() {
+        if (!SwingTestCase.isHarmony()) {
+            return;
+        }
+        initContentModels();
+        assertNull(contentModel1.first());
+        assertNull(contentModel2.first());
+        assertNull(contentModel3.first());
+        assertNull(contentModel4.first());
+        assertNull(contentModel5.first());
+        assertEquals(elements[3], contentModel6.first());
+        assertEquals(elements[2], contentModel7.first());
+        assertEquals(elements[1], contentModel8.first());
+        assertNull(contentModel9.first());
+    }
+
+
+    public void testToString() {
+        if (!SwingTestCase.isHarmony()) {
+            return;
+        }
+        initContentModels();
+        assertEquals("1", contentModel1.toString());
+        assertEquals("2", contentModel2.toString());
+        assertEquals("3", contentModel3.toString());
+        assertEquals("1+", contentModel4.toString());
+        assertEquals("2*", contentModel5.toString());
+        assertEquals("4|3", contentModel6.toString());
+        assertEquals("1+,2*", contentModel7.toString());
+        assertEquals("(4|3)&(1+,2*)", contentModel8.toString());
+        assertEquals("null", contentModel9.toString());
+        assertEquals("1?", contentModel10.toString());
+        assertEquals("1?,3*", contentModel11.toString());
+        assertEquals("(1?,3*)|(1?,3*)", contentModel12.toString());
+        assertEquals("(4|3),((1?,3*)|(1?,3*))", contentModel13.toString());
+        assertEquals("2*&null", contentModel14.toString());
+    }
+
+    private void initContentModels() {
+        contentModel1 = new ContentModel(elements[1]);
+        contentModel2 = new ContentModel(elements[2]);
+        contentModel3 = new ContentModel(elements[3]);
+        contentModel4 = new ContentModel('+', contentModel1);
+        contentModel5 = new ContentModel('*', contentModel2);
+        contentModel6 = new ContentModel('|', elements[4], contentModel3);
+        contentModel7 = new ContentModel(',', contentModel4, contentModel5);
+        contentModel8 = new ContentModel('&', contentModel6, contentModel7);
+        contentModel9 = new ContentModel();
+        contentModel10 = new ContentModel('?', contentModel1);
+        contentModel11 = new ContentModel(',',
+                                          new ContentModel('?', contentModel1),
+                                          new ContentModel('*', contentModel3));
+        contentModel12 = new ContentModel('|', contentModel11, contentModel11);
+        contentModel13 = new ContentModel(',', contentModel6, contentModel12);
+        contentModel14 = new ContentModel('&', contentModel5, contentModel9);
+    }
+
+    public void testFirstObject() {
+        if (!SwingTestCase.isHarmony()) {
+            return;
+        }
+        initContentModels();
+        Object rect = new Rectangle();
+        assertTrue(contentModel1.first(elements[1]));
+        assertTrue(contentModel1.first(null));
+        assertFalse(contentModel1.first(rect));
+        assertFalse(contentModel1.first(contentModel9));
+        assertTrue(contentModel1.first(contentModel1));
+        assertFalse(contentModel1.first(elements[2]));
+
+        assertTrue(contentModel4.first(elements[1]));
+        assertTrue(contentModel4.first(null));
+        assertFalse(contentModel4.first(contentModel9));
+        assertTrue(contentModel4.first(contentModel1));
+        assertFalse(contentModel4.first(elements[2]));
+
+        assertFalse(contentModel5.first(elements[1]));
+        assertTrue(contentModel5.first(null));
+        assertFalse(contentModel5.first(rect));
+        assertFalse(contentModel5.first(contentModel9));
+        assertFalse(contentModel5.first(contentModel1));
+        assertTrue(contentModel5.first(contentModel2));
+        assertTrue(contentModel5.first(elements[2]));
+
+        assertFalse(contentModel6.first(elements[1]));
+        assertTrue(contentModel6.first(null));
+        assertFalse(contentModel6.first(rect));
+        assertFalse(contentModel6.first(contentModel9));
+        assertFalse(contentModel6.first(contentModel1));
+        assertFalse(contentModel6.first(contentModel2));
+        assertFalse(contentModel6.first(elements[2]));
+        assertTrue(contentModel6.first(elements[4]));
+        assertTrue(contentModel6.first(elements[3]));
+        assertTrue(contentModel6.first(contentModel3));
+        assertTrue(contentModel6.first(contentModel6));
+
+
+        assertTrue(contentModel7.first(elements[1]));
+        assertTrue(contentModel7.first(null));
+        assertFalse(contentModel7.first(rect));
+        assertFalse(contentModel7.first(contentModel5));
+        assertTrue(contentModel7.first(contentModel1));
+        assertFalse(contentModel7.first(contentModel2));
+        assertFalse(contentModel7.first(elements[2]));
+        assertFalse(contentModel7.first(elements[4]));
+        assertFalse(contentModel7.first(elements[3]));
+        assertFalse(contentModel7.first(elements[5]));
+        assertFalse(contentModel7.first(contentModel3));
+
+        assertTrue(contentModel8.first(elements[1]));
+        assertTrue(contentModel8.first(null));
+        assertFalse(contentModel8.first(rect));
+        assertFalse(contentModel8.first(contentModel5));
+        assertTrue(contentModel8.first(contentModel6));
+        assertTrue(contentModel8.first(contentModel6));
+        assertFalse(contentModel8.first(contentModel2));
+        assertFalse(contentModel8.first(elements[2]));
+        assertTrue(contentModel8.first(elements[4]));
+        assertTrue(contentModel8.first(elements[3]));
+        assertFalse(contentModel8.first(elements[5]));
+
+        assertFalse(contentModel9.first(elements[1]));
+        assertTrue(contentModel9.first(null));
+        assertFalse(contentModel9.first(rect));
+        assertFalse(contentModel9.first(contentModel5));
+        assertFalse(contentModel9.first(contentModel6));
+
+        assertTrue(contentModel10.first(elements[1]));
+        assertTrue(contentModel10.first(null));
+        assertFalse(contentModel10.first(rect));
+        assertFalse(contentModel10.first(contentModel5));
+        assertTrue(contentModel10.first(contentModel1));
+        assertFalse(contentModel10.first(contentModel2));
+        assertFalse(contentModel10.first(elements[2]));
+
+        assertTrue(contentModel11.first(elements[1]));
+        assertTrue(contentModel11.first(null));
+        assertFalse(contentModel11.first(rect));
+        assertFalse(contentModel11.first(contentModel5));
+        assertTrue(contentModel11.first(contentModel1));
+        assertFalse(contentModel11.first(contentModel2));
+        assertTrue(contentModel11.first(contentModel3));
+        assertFalse(contentModel11.first(elements[2]));
+        assertFalse(contentModel11.first(elements[4]));
+        assertTrue(contentModel11.first(elements[3]));
+        assertFalse(contentModel11.first(elements[5]));
+        assertFalse(contentModel11.first(contentModel7));
+
+        assertTrue(contentModel12.first(elements[1]));
+        assertTrue(contentModel12.first(null));
+        assertFalse(contentModel12.first(rect));
+        assertFalse(contentModel12.first(contentModel5));
+        assertTrue(contentModel12.first(contentModel1));
+        assertFalse(contentModel12.first(contentModel2));
+        assertTrue(contentModel12.first(contentModel3));
+        assertFalse(contentModel12.first(elements[2]));
+        assertFalse(contentModel12.first(elements[4]));
+        assertTrue(contentModel12.first(elements[3]));
+        assertFalse(contentModel12.first(elements[5]));
+        assertFalse(contentModel12.first(contentModel7));
+        assertTrue(contentModel12.first(contentModel11));
+        assertTrue(contentModel12.first(contentModel12));
+
+        assertTrue(contentModel13.first(contentModel6));
+        assertTrue(contentModel13.first(elements[4]));
+        assertTrue(contentModel13.first(elements[3]));
+        assertTrue(contentModel13.first(null));
+        assertTrue(contentModel13.first(contentModel3));
+        assertFalse(contentModel13.first(elements[1]));
+        assertFalse(contentModel13.first(rect));
+        assertFalse(contentModel13.first(contentModel5));
+        assertFalse(contentModel13.first(contentModel1));
+        assertFalse(contentModel13.first(elements[2]));
+        assertFalse(contentModel13.first(elements[5]));
+        assertFalse(contentModel13.first(contentModel7));
+        assertFalse(contentModel13.first(contentModel11));
+        assertFalse(contentModel13.first(contentModel12));
+
+        assertTrue(contentModel14.first(contentModel5));
+        assertTrue(contentModel14.first(null));
+        assertTrue(contentModel14.first(contentModel9));
+        assertTrue(contentModel14.first(elements[2]));
+        assertFalse(contentModel14.first(elements[1]));
+        assertFalse(contentModel14.first(rect));
+        assertFalse(contentModel14.first(contentModel1));
+        assertFalse(contentModel14.first(contentModel6));
+        assertFalse(contentModel14.first(contentModel3));
+        assertFalse(contentModel14.first(elements[4]));
+        assertFalse(contentModel14.first(elements[3]));
+        assertFalse(contentModel14.first(elements[5]));
+        assertFalse(contentModel14.first(contentModel11));
+    }
+
+    private void checkElemVec(final Vector v) {
+        assertEquals(v.size(), elemVec.size());
+        for (int i = 0; i < v.size(); i++) {
+            assertEquals(v.get(i), elemVec.get(i));
+        }
+    }
+
+    public void testGetElements() {
+        resetElemVec();
+        Vector v = new Vector();
+        initContentModels();
+
+        contentModel1.getElements(elemVec);
+        v.add(elements[1]);
+        checkElemVec(v);
+
+        contentModel2.getElements(elemVec);
+        v.add(elements[2]);
+        checkElemVec(v);
+
+        contentModel3.getElements(elemVec);
+        v.add(elements[3]);
+        checkElemVec(v);
+
+        contentModel4.getElements(elemVec);
+        v.add(elements[1]);
+        checkElemVec(v);
+
+        contentModel5.getElements(elemVec);
+        v.add(elements[2]);
+        checkElemVec(v);
+
+        if (!SwingTestCase.isHarmony()) {
+            return;
+        }
+
+        contentModel6.getElements(elemVec);
+        v.add(elements[4]);
+        v.add(elements[3]);
+        checkElemVec(v);
+
+        contentModel7.getElements(elemVec);
+        v.add(elements[1]);
+        v.add(elements[2]);
+        checkElemVec(v);
+
+        contentModel8.getElements(elemVec);
+        v.add(elements[4]);
+        v.add(elements[3]);
+        v.add(elements[1]);
+        v.add(elements[2]);
+        checkElemVec(v);
+
+        contentModel9.getElements(elemVec);
+        checkElemVec(v);
+    }
+
+    public void testEmpty() {
+        //ClassCastException on RI
+        if (!SwingTestCase.isHarmony()) {
+            return;
+        }
+        initContentModels();
+        assertFalse(contentModel1.empty());
+        assertFalse(contentModel2.empty());
+        assertFalse(contentModel3.empty());
+        assertFalse(contentModel4.empty());
+        assertTrue(contentModel5.empty());
+        assertFalse(contentModel6.empty());
+        assertFalse(contentModel7.empty());
+        assertFalse(contentModel8.empty());
+        assertTrue(contentModel9.empty());
+        assertTrue(contentModel10.empty());
+        assertTrue(contentModel11.empty());
+        assertTrue(contentModel12.empty());
+        assertFalse(contentModel13.empty());
+        assertTrue(contentModel14.empty());
+    }
+
+    public void testSerialization() {
+        contentModel1 = new ContentModel(elements[0]);
+        contentModel = new ContentModel('|', elements[1], contentModel1);
+        contentModel2 = (ContentModel)Utils.doSerialization(contentModel);
+        assertEquals('|', contentModel2.type);
+        assertTrue(contentModel2.content instanceof Element);
+        assertEquals(elements[1].name, ((Element)contentModel2.content).name);
+        contentModel3 = contentModel2.next;
+        assertEquals(0, contentModel3.type);
+        assertEquals("0", ((Element)contentModel3.content).name);
+        assertNull(contentModel3.next);
+    }
+}



Mime
View raw message