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 Evgeniya G. Maenkova
019: * @version $Revision$
020: */package javax.swing.text.html.parser;
021:
022: import java.awt.Rectangle;
023: import java.util.Vector;
024:
025: import javax.swing.SwingTestCase;
026:
027: public class ContentModelTest extends SwingTestCase {
028: ContentModel contentModel;
029: Element[] elements;
030: char[] types;
031: Vector elemVec;
032: ContentModel contentModel1;
033: ContentModel contentModel2;
034: ContentModel contentModel3;
035: ContentModel contentModel4;
036: ContentModel contentModel5;
037: ContentModel contentModel6;
038: ContentModel contentModel7;
039: ContentModel contentModel8;
040: ContentModel contentModel9;
041: ContentModel contentModel10;
042: ContentModel contentModel11;
043: ContentModel contentModel12;
044: ContentModel contentModel13;
045: ContentModel contentModel14;
046:
047: protected void setUp() throws Exception {
048: init();
049: resetElemVec();
050: super .setUp();
051: }
052:
053: private void resetElemVec() {
054: if (elemVec == null) {
055: elemVec = new Vector();
056: } else {
057: elemVec.removeAllElements();
058: }
059: }
060:
061: private void init() {
062: if (elements == null) {
063: elements = new Element[7];
064: for (int i = 0; i < 7; i++) {
065: elements[i] = new Element();
066: elements[i].name = Integer.toString(i);
067: }
068: }
069: if (types == null) {
070: types = new char[] { '*', '?', '+', ',', '|', '&' };
071: }
072: }
073:
074: protected void tearDown() throws Exception {
075: super .tearDown();
076: }
077:
078: public void testContentModelElement() {
079: contentModel = new ContentModel(elements[0]);
080: Utils.checkContentModel(contentModel, elements[0], 0, null);
081:
082: contentModel = new ContentModel(null);
083: Utils.checkContentModel(contentModel, null, 0, null);
084: }
085:
086: public void testContentModel() {
087: contentModel = new ContentModel();
088: Utils.checkContentModel(contentModel, null, 0, null);
089: }
090:
091: public void testContentModelIntContentModel() {
092: contentModel1 = new ContentModel(elements[0]);
093:
094: contentModel = new ContentModel('*', contentModel1);
095: Utils.checkContentModel(contentModel, contentModel1, '*', null);
096:
097: contentModel = new ContentModel('?', contentModel1);
098: Utils.checkContentModel(contentModel, contentModel1, '?', null);
099:
100: contentModel = new ContentModel('+', contentModel1);
101: Utils.checkContentModel(contentModel, contentModel1, '+', null);
102: }
103:
104: public void testContentModelIntObjectContentModel() {
105: contentModel1 = new ContentModel(elements[0]);
106: contentModel = new ContentModel(',', elements[1], contentModel1);
107: Utils.checkContentModel(contentModel, elements[1], ',',
108: contentModel1);
109:
110: contentModel = new ContentModel('|', elements[1], contentModel1);
111: Utils.checkContentModel(contentModel, elements[1], '|',
112: contentModel1);
113:
114: contentModel = new ContentModel('&', elements[1], contentModel1);
115: Utils.checkContentModel(contentModel, elements[1], '&',
116: contentModel1);
117:
118: contentModel2 = new ContentModel(elements[1]);
119: contentModel = new ContentModel(',', contentModel2,
120: contentModel1);
121: Utils.checkContentModel(contentModel, contentModel2, ',',
122: contentModel1);
123:
124: contentModel = new ContentModel('|', contentModel2,
125: contentModel1);
126: Utils.checkContentModel(contentModel, contentModel2, '|',
127: contentModel1);
128:
129: contentModel = new ContentModel('&', contentModel2,
130: contentModel1);
131: Utils.checkContentModel(contentModel, contentModel2, '&',
132: contentModel1);
133: }
134:
135: public void testIllegalArgumentException_Object() {
136: if (SwingTestCase.isHarmony()) {
137: contentModel1 = new ContentModel(elements[0]);
138: try {
139: contentModel = new ContentModel(',', new Rectangle(),
140: contentModel1);
141: throwException("1");
142: } catch (IllegalArgumentException e) {
143: }
144:
145: try {
146: contentModel = new ContentModel(',', null,
147: contentModel1);
148: throwException("2");
149: } catch (IllegalArgumentException e) {
150: }
151:
152: try {
153: contentModel = new ContentModel('|', null,
154: contentModel1);
155: throwException("3");
156: } catch (IllegalArgumentException e) {
157: }
158:
159: try {
160: contentModel = new ContentModel('&', null,
161: contentModel1);
162: throwException("4");
163: } catch (IllegalArgumentException e) {
164: }
165:
166: try {
167: contentModel = new ContentModel(',', elements[2], null);
168: throwException("5");
169: } catch (IllegalArgumentException e) {
170: }
171:
172: try {
173: contentModel = new ContentModel('|', elements[2], null);
174: throwException("6");
175: } catch (IllegalArgumentException e) {
176: }
177:
178: try {
179: contentModel = new ContentModel('&', elements[2], null);
180: throwException("7");
181: } catch (IllegalArgumentException e) {
182: }
183:
184: try {
185: contentModel = new ContentModel('+', null);
186: throwException("8");
187: } catch (IllegalArgumentException e) {
188: }
189:
190: try {
191: contentModel = new ContentModel('*', null);
192: throwException("9");
193: } catch (IllegalArgumentException e) {
194: }
195:
196: try {
197: contentModel = new ContentModel('?', null);
198: throwException("10");
199: } catch (IllegalArgumentException e) {
200: }
201: }
202: }
203:
204: public void testIllegalArgumentException_Type() {
205: if (SwingTestCase.isHarmony()) {
206: contentModel1 = new ContentModel(elements[0]);
207: try {
208: contentModel = new ContentModel(',', contentModel1);
209: throwException("0");
210: } catch (IllegalArgumentException e) {
211: }
212: try {
213: contentModel = new ContentModel('&', contentModel1);
214: throwException("1");
215: } catch (IllegalArgumentException e) {
216: }
217: try {
218: contentModel = new ContentModel('|', contentModel1);
219: throwException("2");
220: } catch (IllegalArgumentException e) {
221: }
222:
223: try {
224: contentModel = new ContentModel('a', contentModel1);
225: throwException("3");
226: } catch (IllegalArgumentException e) {
227: }
228:
229: try {
230: contentModel = new ContentModel('+', elements[0],
231: contentModel1);
232: throwException("4");
233: } catch (IllegalArgumentException e) {
234: }
235: try {
236: contentModel = new ContentModel('*', elements[0],
237: contentModel1);
238: throwException("5");
239: } catch (IllegalArgumentException e) {
240: }
241: try {
242: contentModel = new ContentModel('?', elements[0],
243: contentModel1);
244: throwException("6");
245: } catch (IllegalArgumentException e) {
246: }
247:
248: try {
249: contentModel = new ContentModel('a', elements[0],
250: contentModel1);
251: throwException("7");
252: } catch (IllegalArgumentException e) {
253: }
254: }
255: }
256:
257: private void throwException(final String s) {
258: assertFalse("IllegalArgumentException wasn't thrown:" + s, true);
259: }
260:
261: public void testFirst() throws Exception {
262: initContentModels();
263: assertEquals(elements[1], contentModel1.first());
264: assertEquals(elements[2], contentModel2.first());
265: assertEquals(elements[3], contentModel3.first());
266: assertEquals(elements[1], contentModel4.first());
267: assertNull(contentModel5.first());
268: assertNull(contentModel6.first());
269: assertEquals(elements[1], contentModel7.first());
270: assertNull(contentModel8.first());
271: assertNull(contentModel9.first());
272: }
273:
274: public void testFirst2() throws Exception {
275: //regression for HARMONY-1350
276: DTD dtd = DTD.getDTD("tmp");
277: ContentModel model1 = new ContentModel(dtd.getElement(2));
278: ContentModel model2 = new ContentModel(dtd.getElement(3));
279: ContentModel model = new ContentModel('&', model1, model2);
280: assertNull(model.first());
281: }
282:
283: public void testToString() {
284: if (!SwingTestCase.isHarmony()) {
285: return;
286: }
287: initContentModels();
288: assertEquals("1", contentModel1.toString());
289: assertEquals("2", contentModel2.toString());
290: assertEquals("3", contentModel3.toString());
291: assertEquals("1+", contentModel4.toString());
292: assertEquals("2*", contentModel5.toString());
293: assertEquals("4|3", contentModel6.toString());
294: assertEquals("1+,2*", contentModel7.toString());
295: assertEquals("(4|3)&(1+,2*)", contentModel8.toString());
296: assertEquals("null", contentModel9.toString());
297: assertEquals("1?", contentModel10.toString());
298: assertEquals("1?,3*", contentModel11.toString());
299: assertEquals("(1?,3*)|(1?,3*)", contentModel12.toString());
300: assertEquals("(4|3),((1?,3*)|(1?,3*))", contentModel13
301: .toString());
302: assertEquals("2*&null", contentModel14.toString());
303: }
304:
305: private void initContentModels() {
306: contentModel1 = new ContentModel(elements[1]);
307: contentModel2 = new ContentModel(elements[2]);
308: contentModel3 = new ContentModel(elements[3]);
309: contentModel4 = new ContentModel('+', contentModel1);
310: contentModel5 = new ContentModel('*', contentModel2);
311: contentModel6 = new ContentModel('|', elements[4],
312: contentModel3);
313: contentModel7 = new ContentModel(',', contentModel4,
314: contentModel5);
315: contentModel8 = new ContentModel('&', contentModel6,
316: contentModel7);
317: contentModel9 = new ContentModel();
318: contentModel10 = new ContentModel('?', contentModel1);
319: contentModel11 = new ContentModel(',', new ContentModel('?',
320: contentModel1), new ContentModel('*', contentModel3));
321: contentModel12 = new ContentModel('|', contentModel11,
322: contentModel11);
323: contentModel13 = new ContentModel(',', contentModel6,
324: contentModel12);
325: contentModel14 = new ContentModel('&', contentModel5,
326: contentModel9);
327: }
328:
329: public void testFirstObject() {
330: if (!SwingTestCase.isHarmony()) {
331: return;
332: }
333: initContentModels();
334: Object rect = new Rectangle();
335: assertTrue(contentModel1.first(elements[1]));
336: assertTrue(contentModel1.first(null));
337: assertFalse(contentModel1.first(rect));
338: assertFalse(contentModel1.first(contentModel9));
339: assertTrue(contentModel1.first(contentModel1));
340: assertFalse(contentModel1.first(elements[2]));
341:
342: assertTrue(contentModel4.first(elements[1]));
343: assertTrue(contentModel4.first(null));
344: assertFalse(contentModel4.first(contentModel9));
345: assertTrue(contentModel4.first(contentModel1));
346: assertFalse(contentModel4.first(elements[2]));
347:
348: assertFalse(contentModel5.first(elements[1]));
349: assertTrue(contentModel5.first(null));
350: assertFalse(contentModel5.first(rect));
351: assertFalse(contentModel5.first(contentModel9));
352: assertFalse(contentModel5.first(contentModel1));
353: assertTrue(contentModel5.first(contentModel2));
354: assertTrue(contentModel5.first(elements[2]));
355:
356: assertFalse(contentModel6.first(elements[1]));
357: assertTrue(contentModel6.first(null));
358: assertFalse(contentModel6.first(rect));
359: assertFalse(contentModel6.first(contentModel9));
360: assertFalse(contentModel6.first(contentModel1));
361: assertFalse(contentModel6.first(contentModel2));
362: assertFalse(contentModel6.first(elements[2]));
363: assertTrue(contentModel6.first(elements[4]));
364: assertTrue(contentModel6.first(elements[3]));
365: assertTrue(contentModel6.first(contentModel3));
366: assertTrue(contentModel6.first(contentModel6));
367:
368: assertTrue(contentModel7.first(elements[1]));
369: assertTrue(contentModel7.first(null));
370: assertFalse(contentModel7.first(rect));
371: assertFalse(contentModel7.first(contentModel5));
372: assertTrue(contentModel7.first(contentModel1));
373: assertFalse(contentModel7.first(contentModel2));
374: assertFalse(contentModel7.first(elements[2]));
375: assertFalse(contentModel7.first(elements[4]));
376: assertFalse(contentModel7.first(elements[3]));
377: assertFalse(contentModel7.first(elements[5]));
378: assertFalse(contentModel7.first(contentModel3));
379:
380: assertTrue(contentModel8.first(elements[1]));
381: assertTrue(contentModel8.first(null));
382: assertFalse(contentModel8.first(rect));
383: assertFalse(contentModel8.first(contentModel5));
384: assertTrue(contentModel8.first(contentModel6));
385: assertTrue(contentModel8.first(contentModel6));
386: assertFalse(contentModel8.first(contentModel2));
387: assertFalse(contentModel8.first(elements[2]));
388: assertTrue(contentModel8.first(elements[4]));
389: assertTrue(contentModel8.first(elements[3]));
390: assertFalse(contentModel8.first(elements[5]));
391:
392: assertFalse(contentModel9.first(elements[1]));
393: assertTrue(contentModel9.first(null));
394: assertFalse(contentModel9.first(rect));
395: assertFalse(contentModel9.first(contentModel5));
396: assertFalse(contentModel9.first(contentModel6));
397:
398: assertTrue(contentModel10.first(elements[1]));
399: assertTrue(contentModel10.first(null));
400: assertFalse(contentModel10.first(rect));
401: assertFalse(contentModel10.first(contentModel5));
402: assertTrue(contentModel10.first(contentModel1));
403: assertFalse(contentModel10.first(contentModel2));
404: assertFalse(contentModel10.first(elements[2]));
405:
406: assertTrue(contentModel11.first(elements[1]));
407: assertTrue(contentModel11.first(null));
408: assertFalse(contentModel11.first(rect));
409: assertFalse(contentModel11.first(contentModel5));
410: assertTrue(contentModel11.first(contentModel1));
411: assertFalse(contentModel11.first(contentModel2));
412: assertTrue(contentModel11.first(contentModel3));
413: assertFalse(contentModel11.first(elements[2]));
414: assertFalse(contentModel11.first(elements[4]));
415: assertTrue(contentModel11.first(elements[3]));
416: assertFalse(contentModel11.first(elements[5]));
417: assertFalse(contentModel11.first(contentModel7));
418:
419: assertTrue(contentModel12.first(elements[1]));
420: assertTrue(contentModel12.first(null));
421: assertFalse(contentModel12.first(rect));
422: assertFalse(contentModel12.first(contentModel5));
423: assertTrue(contentModel12.first(contentModel1));
424: assertFalse(contentModel12.first(contentModel2));
425: assertTrue(contentModel12.first(contentModel3));
426: assertFalse(contentModel12.first(elements[2]));
427: assertFalse(contentModel12.first(elements[4]));
428: assertTrue(contentModel12.first(elements[3]));
429: assertFalse(contentModel12.first(elements[5]));
430: assertFalse(contentModel12.first(contentModel7));
431: assertTrue(contentModel12.first(contentModel11));
432: assertTrue(contentModel12.first(contentModel12));
433:
434: assertTrue(contentModel13.first(contentModel6));
435: assertTrue(contentModel13.first(elements[4]));
436: assertTrue(contentModel13.first(elements[3]));
437: assertTrue(contentModel13.first(null));
438: assertTrue(contentModel13.first(contentModel3));
439: assertFalse(contentModel13.first(elements[1]));
440: assertFalse(contentModel13.first(rect));
441: assertFalse(contentModel13.first(contentModel5));
442: assertFalse(contentModel13.first(contentModel1));
443: assertFalse(contentModel13.first(elements[2]));
444: assertFalse(contentModel13.first(elements[5]));
445: assertFalse(contentModel13.first(contentModel7));
446: assertFalse(contentModel13.first(contentModel11));
447: assertFalse(contentModel13.first(contentModel12));
448:
449: assertTrue(contentModel14.first(contentModel5));
450: assertTrue(contentModel14.first(null));
451: assertTrue(contentModel14.first(contentModel9));
452: assertTrue(contentModel14.first(elements[2]));
453: assertFalse(contentModel14.first(elements[1]));
454: assertFalse(contentModel14.first(rect));
455: assertFalse(contentModel14.first(contentModel1));
456: assertFalse(contentModel14.first(contentModel6));
457: assertFalse(contentModel14.first(contentModel3));
458: assertFalse(contentModel14.first(elements[4]));
459: assertFalse(contentModel14.first(elements[3]));
460: assertFalse(contentModel14.first(elements[5]));
461: assertFalse(contentModel14.first(contentModel11));
462: }
463:
464: private void checkElemVec(final Vector v) {
465: assertEquals(v.size(), elemVec.size());
466: for (int i = 0; i < v.size(); i++) {
467: assertEquals(v.get(i), elemVec.get(i));
468: }
469: }
470:
471: public void testGetElements() {
472: resetElemVec();
473: Vector v = new Vector();
474: initContentModels();
475:
476: contentModel1.getElements(elemVec);
477: v.add(elements[1]);
478: checkElemVec(v);
479:
480: contentModel2.getElements(elemVec);
481: v.add(elements[2]);
482: checkElemVec(v);
483:
484: contentModel3.getElements(elemVec);
485: v.add(elements[3]);
486: checkElemVec(v);
487:
488: contentModel4.getElements(elemVec);
489: v.add(elements[1]);
490: checkElemVec(v);
491:
492: contentModel5.getElements(elemVec);
493: v.add(elements[2]);
494: checkElemVec(v);
495:
496: if (!SwingTestCase.isHarmony()) {
497: return;
498: }
499:
500: contentModel6.getElements(elemVec);
501: v.add(elements[4]);
502: v.add(elements[3]);
503: checkElemVec(v);
504:
505: contentModel7.getElements(elemVec);
506: v.add(elements[1]);
507: v.add(elements[2]);
508: checkElemVec(v);
509:
510: contentModel8.getElements(elemVec);
511: v.add(elements[4]);
512: v.add(elements[3]);
513: v.add(elements[1]);
514: v.add(elements[2]);
515: checkElemVec(v);
516:
517: contentModel9.getElements(elemVec);
518: checkElemVec(v);
519: }
520:
521: public void testEmpty() {
522: //ClassCastException on RI
523: if (!SwingTestCase.isHarmony()) {
524: return;
525: }
526: initContentModels();
527: assertFalse(contentModel1.empty());
528: assertFalse(contentModel2.empty());
529: assertFalse(contentModel3.empty());
530: assertFalse(contentModel4.empty());
531: assertTrue(contentModel5.empty());
532: assertFalse(contentModel6.empty());
533: assertFalse(contentModel7.empty());
534: assertFalse(contentModel8.empty());
535: assertTrue(contentModel9.empty());
536: assertTrue(contentModel10.empty());
537: assertTrue(contentModel11.empty());
538: assertTrue(contentModel12.empty());
539: assertFalse(contentModel13.empty());
540: assertTrue(contentModel14.empty());
541: }
542:
543: public void testSerialization() {
544: contentModel1 = new ContentModel(elements[0]);
545: contentModel = new ContentModel('|', elements[1], contentModel1);
546: contentModel2 = (ContentModel) Utils
547: .doSerialization(contentModel);
548: assertEquals('|', contentModel2.type);
549: assertTrue(contentModel2.content instanceof Element);
550: assertEquals(elements[1].name,
551: ((Element) contentModel2.content).name);
552: contentModel3 = contentModel2.next;
553: assertEquals(0, contentModel3.type);
554: assertEquals("0", ((Element) contentModel3.content).name);
555: assertNull(contentModel3.next);
556: }
557: }
|