001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: /**
018: * @author Alexey A. Ivanov
019: * @version $Revision$
020: */package javax.swing.text.html;
021:
022: import javax.swing.text.html.CSS.Attribute;
023:
024: import junit.framework.TestCase;
025:
026: /**
027: * Tests the values of fields of <code>CSS.Attribute</code> class, i.e.
028: * its name (<code>toString()</code>), default value and inheritance.
029: *
030: */
031: public class CSS_AttributeTest extends TestCase {
032: private Attribute attr;
033:
034: public void testBackground() {
035: attr = CSS.Attribute.BACKGROUND;
036: assertEquals("background", attr.toString());
037: assertNull(attr.getDefaultValue());
038: assertFalse(attr.isInherited());
039: }
040:
041: public void testBackgroundAttachment() {
042: attr = CSS.Attribute.BACKGROUND_ATTACHMENT;
043: assertEquals("background-attachment", attr.toString());
044: assertEquals("scroll", attr.getDefaultValue());
045: assertFalse(attr.isInherited());
046: }
047:
048: public void testBackgroundColor() {
049: attr = CSS.Attribute.BACKGROUND_COLOR;
050: assertEquals("background-color", attr.toString());
051: assertEquals("transparent", attr.getDefaultValue());
052: assertFalse(attr.isInherited());
053: }
054:
055: public void testBackgroundImage() {
056: attr = CSS.Attribute.BACKGROUND_IMAGE;
057: assertEquals("background-image", attr.toString());
058: assertEquals("none", attr.getDefaultValue());
059: assertFalse(attr.isInherited());
060: }
061:
062: public void testBackgroundPosition() {
063: attr = CSS.Attribute.BACKGROUND_POSITION;
064: assertEquals("background-position", attr.toString());
065: assertNull(attr.getDefaultValue());
066: assertFalse(attr.isInherited());
067: }
068:
069: public void testBackgroundRepeat() {
070: attr = CSS.Attribute.BACKGROUND_REPEAT;
071: assertEquals("background-repeat", attr.toString());
072: assertEquals("repeat", attr.getDefaultValue());
073: assertFalse(attr.isInherited());
074: }
075:
076: public void testBorder() {
077: attr = CSS.Attribute.BORDER;
078: assertEquals("border", attr.toString());
079: assertNull(attr.getDefaultValue());
080: assertFalse(attr.isInherited());
081: }
082:
083: public void testBorderBottom() {
084: attr = CSS.Attribute.BORDER_BOTTOM;
085: assertEquals("border-bottom", attr.toString());
086: assertNull(attr.getDefaultValue());
087: assertFalse(attr.isInherited());
088: }
089:
090: public void testBorderBottomWidth() {
091: attr = CSS.Attribute.BORDER_BOTTOM_WIDTH;
092: assertEquals("border-bottom-width", attr.toString());
093: assertEquals("medium", attr.getDefaultValue());
094: assertFalse(attr.isInherited());
095: }
096:
097: public void testBorderColor() {
098: attr = CSS.Attribute.BORDER_COLOR;
099: assertEquals("border-color", attr.toString());
100: assertNull(attr.getDefaultValue());
101: assertFalse(attr.isInherited());
102: }
103:
104: public void testBorderLeft() {
105: attr = CSS.Attribute.BORDER_LEFT;
106: assertEquals("border-left", attr.toString());
107: assertNull(attr.getDefaultValue());
108: assertFalse(attr.isInherited());
109: }
110:
111: public void testBorderLeftWidth() {
112: attr = CSS.Attribute.BORDER_LEFT_WIDTH;
113: assertEquals("border-left-width", attr.toString());
114: assertEquals("medium", attr.getDefaultValue());
115: assertFalse(attr.isInherited());
116: }
117:
118: public void testBorderRight() {
119: attr = CSS.Attribute.BORDER_RIGHT;
120: assertEquals("border-right", attr.toString());
121: assertNull(attr.getDefaultValue());
122: assertFalse(attr.isInherited());
123: }
124:
125: public void testBorderRightWidth() {
126: attr = CSS.Attribute.BORDER_RIGHT_WIDTH;
127: assertEquals("border-right-width", attr.toString());
128: assertEquals("medium", attr.getDefaultValue());
129: assertFalse(attr.isInherited());
130: }
131:
132: public void testBorderStyle() {
133: attr = CSS.Attribute.BORDER_STYLE;
134: assertEquals("border-style", attr.toString());
135: assertEquals("none", attr.getDefaultValue());
136: assertFalse(attr.isInherited());
137: }
138:
139: public void testBorderTop() {
140: attr = CSS.Attribute.BORDER_TOP;
141: assertEquals("border-top", attr.toString());
142: assertNull(attr.getDefaultValue());
143: assertFalse(attr.isInherited());
144: }
145:
146: public void testBorderTopWidth() {
147: attr = CSS.Attribute.BORDER_TOP_WIDTH;
148: assertEquals("border-top-width", attr.toString());
149: assertEquals("medium", attr.getDefaultValue());
150: assertFalse(attr.isInherited());
151: }
152:
153: public void testBorderWidth() {
154: attr = CSS.Attribute.BORDER_WIDTH;
155: assertEquals("border-width", attr.toString());
156: assertEquals("medium", attr.getDefaultValue());
157: assertFalse(attr.isInherited());
158: }
159:
160: public void testClear() {
161: attr = CSS.Attribute.CLEAR;
162: assertEquals("clear", attr.toString());
163: assertEquals("none", attr.getDefaultValue());
164: assertFalse(attr.isInherited());
165: }
166:
167: public void testColor() {
168: attr = CSS.Attribute.COLOR;
169: assertEquals("color", attr.toString());
170: assertNull(attr.getDefaultValue());
171: assertTrue(attr.isInherited());
172: }
173:
174: public void testDisplay() {
175: attr = CSS.Attribute.DISPLAY;
176: assertEquals("display", attr.toString());
177: assertEquals("block", attr.getDefaultValue());
178: assertFalse(attr.isInherited());
179: }
180:
181: public void testFloat() {
182: attr = CSS.Attribute.FLOAT;
183: assertEquals("float", attr.toString());
184: assertEquals("none", attr.getDefaultValue());
185: assertFalse(attr.isInherited());
186: }
187:
188: public void testFont() {
189: attr = CSS.Attribute.FONT;
190: assertEquals("font", attr.toString());
191: assertNull(attr.getDefaultValue());
192: assertTrue(attr.isInherited());
193: }
194:
195: public void testFontFamily() {
196: attr = CSS.Attribute.FONT_FAMILY;
197: assertEquals("font-family", attr.toString());
198: assertNull(attr.getDefaultValue());
199: assertTrue(attr.isInherited());
200: }
201:
202: public void testFontSize() {
203: attr = CSS.Attribute.FONT_SIZE;
204: assertEquals("font-size", attr.toString());
205: assertEquals("medium", attr.getDefaultValue());
206: assertTrue(attr.isInherited());
207: }
208:
209: public void testFontStyle() {
210: attr = CSS.Attribute.FONT_STYLE;
211: assertEquals("font-style", attr.toString());
212: assertEquals("normal", attr.getDefaultValue());
213: assertTrue(attr.isInherited());
214: }
215:
216: public void testFontVariant() {
217: attr = CSS.Attribute.FONT_VARIANT;
218: assertEquals("font-variant", attr.toString());
219: assertEquals("normal", attr.getDefaultValue());
220: assertTrue(attr.isInherited());
221: }
222:
223: public void testFontWeight() {
224: attr = CSS.Attribute.FONT_WEIGHT;
225: assertEquals("font-weight", attr.toString());
226: assertEquals("normal", attr.getDefaultValue());
227: assertTrue(attr.isInherited());
228: }
229:
230: public void testHeight() {
231: attr = CSS.Attribute.HEIGHT;
232: assertEquals("height", attr.toString());
233: assertEquals("auto", attr.getDefaultValue());
234: assertFalse(attr.isInherited());
235: }
236:
237: public void testLetterSpacing() {
238: attr = CSS.Attribute.LETTER_SPACING;
239: assertEquals("letter-spacing", attr.toString());
240: assertEquals("normal", attr.getDefaultValue());
241: assertTrue(attr.isInherited());
242: }
243:
244: public void testLineHeight() {
245: attr = CSS.Attribute.LINE_HEIGHT;
246: assertEquals("line-height", attr.toString());
247: assertEquals("normal", attr.getDefaultValue());
248: assertTrue(attr.isInherited());
249: }
250:
251: public void testListStyle() {
252: attr = CSS.Attribute.LIST_STYLE;
253: assertEquals("list-style", attr.toString());
254: assertNull(attr.getDefaultValue());
255: assertTrue(attr.isInherited());
256: }
257:
258: public void testListStyleImage() {
259: attr = CSS.Attribute.LIST_STYLE_IMAGE;
260: assertEquals("list-style-image", attr.toString());
261: assertEquals("none", attr.getDefaultValue());
262: assertTrue(attr.isInherited());
263: }
264:
265: public void testListStylePosition() {
266: attr = CSS.Attribute.LIST_STYLE_POSITION;
267: assertEquals("list-style-position", attr.toString());
268: assertEquals("outside", attr.getDefaultValue());
269: assertTrue(attr.isInherited());
270: }
271:
272: public void testListStyleType() {
273: attr = CSS.Attribute.LIST_STYLE_TYPE;
274: assertEquals("list-style-type", attr.toString());
275: assertEquals("disc", attr.getDefaultValue());
276: assertTrue(attr.isInherited());
277: }
278:
279: public void testMargin() {
280: attr = CSS.Attribute.MARGIN;
281: assertEquals("margin", attr.toString());
282: assertNull(attr.getDefaultValue());
283: assertFalse(attr.isInherited());
284: }
285:
286: public void testMarginBottom() {
287: attr = CSS.Attribute.MARGIN_BOTTOM;
288: assertEquals("margin-bottom", attr.toString());
289: assertEquals("0", attr.getDefaultValue());
290: assertFalse(attr.isInherited());
291: }
292:
293: public void testMarginLeft() {
294: attr = CSS.Attribute.MARGIN_LEFT;
295: assertEquals("margin-left", attr.toString());
296: assertEquals("0", attr.getDefaultValue());
297: assertFalse(attr.isInherited());
298: }
299:
300: public void testMarginRight() {
301: attr = CSS.Attribute.MARGIN_RIGHT;
302: assertEquals("margin-right", attr.toString());
303: assertEquals("0", attr.getDefaultValue());
304: assertFalse(attr.isInherited());
305: }
306:
307: public void testMarginTop() {
308: attr = CSS.Attribute.MARGIN_TOP;
309: assertEquals("margin-top", attr.toString());
310: assertEquals("0", attr.getDefaultValue());
311: assertFalse(attr.isInherited());
312: }
313:
314: public void testPadding() {
315: attr = CSS.Attribute.PADDING;
316: assertEquals("padding", attr.toString());
317: assertNull(attr.getDefaultValue());
318: assertFalse(attr.isInherited());
319: }
320:
321: public void testPaddingBottom() {
322: attr = CSS.Attribute.PADDING_BOTTOM;
323: assertEquals("padding-bottom", attr.toString());
324: assertEquals("0", attr.getDefaultValue());
325: assertFalse(attr.isInherited());
326: }
327:
328: public void testPaddingLeft() {
329: attr = CSS.Attribute.PADDING_LEFT;
330: assertEquals("padding-left", attr.toString());
331: assertEquals("0", attr.getDefaultValue());
332: assertFalse(attr.isInherited());
333: }
334:
335: public void testPaddingRight() {
336: attr = CSS.Attribute.PADDING_RIGHT;
337: assertEquals("padding-right", attr.toString());
338: assertEquals("0", attr.getDefaultValue());
339: assertFalse(attr.isInherited());
340: }
341:
342: public void testPaddingTop() {
343: attr = CSS.Attribute.PADDING_TOP;
344: assertEquals("padding-top", attr.toString());
345: assertEquals("0", attr.getDefaultValue());
346: assertFalse(attr.isInherited());
347: }
348:
349: public void testTextAlign() {
350: attr = CSS.Attribute.TEXT_ALIGN;
351: assertEquals("text-align", attr.toString());
352: assertNull(attr.getDefaultValue());
353: assertTrue(attr.isInherited());
354: }
355:
356: public void testTextDecoration() {
357: attr = CSS.Attribute.TEXT_DECORATION;
358: assertEquals("text-decoration", attr.toString());
359: assertEquals("none", attr.getDefaultValue());
360: assertTrue(attr.isInherited());
361: }
362:
363: public void testTextIndent() {
364: attr = CSS.Attribute.TEXT_INDENT;
365: assertEquals("text-indent", attr.toString());
366: assertEquals("0", attr.getDefaultValue());
367: assertTrue(attr.isInherited());
368: }
369:
370: public void testTextTransform() {
371: attr = CSS.Attribute.TEXT_TRANSFORM;
372: assertEquals("text-transform", attr.toString());
373: assertEquals("none", attr.getDefaultValue());
374: assertTrue(attr.isInherited());
375: }
376:
377: public void testVerticalAlign() {
378: attr = CSS.Attribute.VERTICAL_ALIGN;
379: assertEquals("vertical-align", attr.toString());
380: assertEquals("baseline", attr.getDefaultValue());
381: assertFalse(attr.isInherited());
382: }
383:
384: public void testWhiteSpace() {
385: attr = CSS.Attribute.WHITE_SPACE;
386: assertEquals("white-space", attr.toString());
387: assertEquals("normal", attr.getDefaultValue());
388: assertTrue(attr.isInherited());
389: }
390:
391: public void testWidth() {
392: attr = CSS.Attribute.WIDTH;
393: assertEquals("width", attr.toString());
394: assertEquals("auto", attr.getDefaultValue());
395: assertFalse(attr.isInherited());
396: }
397:
398: public void testWordSpacing() {
399: attr = CSS.Attribute.WORD_SPACING;
400: assertEquals("word-spacing", attr.toString());
401: assertEquals("normal", attr.getDefaultValue());
402: assertTrue(attr.isInherited());
403: }
404: }
|