Clover Coverage Report
Coverage timestamp: Fri May 24 2013 13:47:27 UTC
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../../img/srcFileCovDistChart10.png 0% of files have more coverage
225   741   170   1.86
84   562   0.76   121
121     1.4  
1    
 
  QedeqVisitorTester       Line # 89 225 170 95.6% 0.95581394
 
  (1)
 
1    /* This file is part of the project "Hilbert II" - http://www.qedeq.org
2    *
3    * Copyright 2000-2013, Michael Meyling <mime@qedeq.org>.
4    *
5    * "Hilbert II" is free software; you can redistribute
6    * it and/or modify it under the terms of the GNU General Public
7    * License as published by the Free Software Foundation; either
8    * version 2 of the License, or (at your option) any later version.
9    *
10    * This program is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13    * GNU General Public License for more details.
14    */
15   
16    package org.qedeq.kernel.se.visitor;
17   
18    import java.io.ByteArrayOutputStream;
19    import java.io.UnsupportedEncodingException;
20    import java.util.Stack;
21    import java.util.Vector;
22   
23    import org.qedeq.base.io.TextOutput;
24    import org.qedeq.base.utility.StringUtility;
25    import org.qedeq.kernel.se.base.list.Atom;
26    import org.qedeq.kernel.se.base.list.ElementList;
27    import org.qedeq.kernel.se.base.module.Add;
28    import org.qedeq.kernel.se.base.module.Author;
29    import org.qedeq.kernel.se.base.module.AuthorList;
30    import org.qedeq.kernel.se.base.module.Axiom;
31    import org.qedeq.kernel.se.base.module.ChangedRule;
32    import org.qedeq.kernel.se.base.module.ChangedRuleList;
33    import org.qedeq.kernel.se.base.module.Chapter;
34    import org.qedeq.kernel.se.base.module.ChapterList;
35    import org.qedeq.kernel.se.base.module.Conclusion;
36    import org.qedeq.kernel.se.base.module.ConditionalProof;
37    import org.qedeq.kernel.se.base.module.Existential;
38    import org.qedeq.kernel.se.base.module.FormalProof;
39    import org.qedeq.kernel.se.base.module.FormalProofLine;
40    import org.qedeq.kernel.se.base.module.FormalProofLineList;
41    import org.qedeq.kernel.se.base.module.FormalProofList;
42    import org.qedeq.kernel.se.base.module.Formula;
43    import org.qedeq.kernel.se.base.module.FunctionDefinition;
44    import org.qedeq.kernel.se.base.module.Header;
45    import org.qedeq.kernel.se.base.module.Hypothesis;
46    import org.qedeq.kernel.se.base.module.Import;
47    import org.qedeq.kernel.se.base.module.ImportList;
48    import org.qedeq.kernel.se.base.module.InitialFunctionDefinition;
49    import org.qedeq.kernel.se.base.module.InitialPredicateDefinition;
50    import org.qedeq.kernel.se.base.module.Latex;
51    import org.qedeq.kernel.se.base.module.LatexList;
52    import org.qedeq.kernel.se.base.module.LinkList;
53    import org.qedeq.kernel.se.base.module.LiteratureItem;
54    import org.qedeq.kernel.se.base.module.LiteratureItemList;
55    import org.qedeq.kernel.se.base.module.Location;
56    import org.qedeq.kernel.se.base.module.LocationList;
57    import org.qedeq.kernel.se.base.module.ModusPonens;
58    import org.qedeq.kernel.se.base.module.Node;
59    import org.qedeq.kernel.se.base.module.PredicateDefinition;
60    import org.qedeq.kernel.se.base.module.Proof;
61    import org.qedeq.kernel.se.base.module.ProofList;
62    import org.qedeq.kernel.se.base.module.Proposition;
63    import org.qedeq.kernel.se.base.module.Qedeq;
64    import org.qedeq.kernel.se.base.module.Reason;
65    import org.qedeq.kernel.se.base.module.Rename;
66    import org.qedeq.kernel.se.base.module.Rule;
67    import org.qedeq.kernel.se.base.module.Section;
68    import org.qedeq.kernel.se.base.module.SectionList;
69    import org.qedeq.kernel.se.base.module.Specification;
70    import org.qedeq.kernel.se.base.module.Subsection;
71    import org.qedeq.kernel.se.base.module.SubsectionList;
72    import org.qedeq.kernel.se.base.module.SubsectionType;
73    import org.qedeq.kernel.se.base.module.SubstFree;
74    import org.qedeq.kernel.se.base.module.SubstFunc;
75    import org.qedeq.kernel.se.base.module.SubstPred;
76    import org.qedeq.kernel.se.base.module.Term;
77    import org.qedeq.kernel.se.base.module.Universal;
78    import org.qedeq.kernel.se.base.module.UsedByList;
79    import org.qedeq.kernel.se.common.ModuleDataException;
80   
81    /**
82    * Test visitor concept for {@link org.qedeq.kernel.visitor.QedeqVisitor}.
83    * This class doesn't test much existing code directly, but checks that the
84    * {@link QedeqNotNullTraverser} works correctly for
85    * the list part.
86    *
87    * @author Michael Meyling
88    */
 
89    public class QedeqVisitorTester implements QedeqVisitor {
90   
91    private ByteArrayOutputStream out = new ByteArrayOutputStream();
92   
93    private Vector counter = new Vector();
94   
95    private TextOutput text;
96   
97    // private final TextOutput text = new TextOutput("local", new PrintStream(System.out));
98   
99    private final Stack commaStack = new Stack();
100   
101    private final Stack getterStack = new Stack();
102   
103    private final Stack objectStack = new Stack();
104   
105    private QedeqTraverser traverser;
106   
 
107  1 toggle public QedeqVisitorTester(final QedeqTraverser traverser) {
108  1 this.traverser = traverser;
109  1 init();
110    }
111   
 
112  1 toggle public void init() {
113  1 out.reset();
114  1 if (text != null) {
115  0 text.close();
116    }
117  1 commaStack.clear();
118  1 objectStack.clear();
119  1 counter.clear();
120  1 getterStack.clear();
121  1 out = new ByteArrayOutputStream();
122  1 text = new TextOutput("local", out, "UTF-8");
123    }
124   
 
125  0 toggle public String getOutput() {
126  0 try {
127  0 return out.toString("UTF-8");
128    } catch (UnsupportedEncodingException e) {
129  0 throw new RuntimeException(e);
130    }
131    }
132   
 
133  19 toggle public void visitEnter(Atom atom) {
134  19 enter(atom);
135    }
136   
 
137  19 toggle public void visitLeave(Atom atom) {
138  19 leave(atom);
139    }
140   
 
141  19 toggle public void visitEnter(ElementList list) {
142  19 enter(list);
143    }
144   
 
145  19 toggle public void visitLeave(ElementList list) {
146  19 leave(list);
147    }
148   
 
149  2 toggle public void visitEnter(Author author) {
150  2 enter(author);
151    }
152   
 
153  3 toggle public void visitEnter(AuthorList authorList) {
154  3 enter(authorList);
155    }
156   
 
157  6 toggle public void visitEnter(Axiom axiom) {
158  6 enter(axiom);
159    }
160   
 
161  126 toggle public void visitEnter(Chapter chapter) {
162  126 enter(chapter);
163    }
164   
 
165  127 toggle public void visitEnter(ChapterList chapterList) {
166  127 enter(chapterList);
167    }
168   
 
169  23 toggle public void visitEnter(Formula formula) {
170  23 enter(formula);
171    }
172   
 
173  5 toggle public void visitEnter(InitialFunctionDefinition functionDefinition) {
174  5 enter(functionDefinition);
175    }
176   
 
177  6 toggle public void visitEnter(FunctionDefinition functionDefinition) {
178  6 enter(functionDefinition);
179    }
180   
 
181  20 toggle public void visitEnter(Header header) {
182  20 enter(header);
183    }
184   
 
185  4 toggle public void visitEnter(Import imp) {
186  4 enter(imp);
187    }
188   
 
189  5 toggle public void visitEnter(ImportList importList) {
190  5 enter(importList);
191    }
192   
 
193  24 toggle public void visitEnter(Latex latex) {
194  24 enter(latex);
195    }
196   
 
197  46 toggle public void visitEnter(LatexList latexList) {
198  46 enter(latexList);
199    }
200   
 
201  1 toggle public void visitEnter(LinkList linkList) {
202  1 enter(linkList);
203    }
204   
 
205  3 toggle public void visitEnter(LiteratureItem literatureItem) {
206  3 enter(literatureItem);
207    }
208   
 
209  4 toggle public void visitEnter(LiteratureItemList literatureItemList) {
210  4 enter(literatureItemList);
211    }
212   
 
213  3 toggle public void visitEnter(Location location) {
214  3 enter(location);
215    }
216   
 
217  6 toggle public void visitEnter(LocationList locationList) {
218  6 enter(locationList);
219    }
220   
 
221  107 toggle public void visitEnter(Node node) {
222  107 enter(node);
223    }
224   
 
225  5 toggle public void visitEnter(InitialPredicateDefinition predicateDefinition) {
226  5 enter(predicateDefinition);
227    }
228   
 
229  6 toggle public void visitEnter(PredicateDefinition predicateDefinition) {
230  6 enter(predicateDefinition);
231    }
232   
 
233  47 toggle public void visitEnter(FormalProof proof) {
234  47 enter(proof);
235    }
236   
 
237  48 toggle public void visitEnter(FormalProofList proofList) {
238  48 enter(proofList);
239    }
240   
 
241  32 toggle public void visitEnter(FormalProofLine proofLine) {
242  32 enter(proofLine);
243    }
244   
 
245  28 toggle public void visitEnter(Reason reason) {
246  28 enter(reason);
247    }
248   
 
249  1 toggle public void visitEnter(ModusPonens reason) {
250  1 enter(reason);
251    }
252   
 
253  1 toggle public void visitEnter(Add reason) {
254  1 enter(reason);
255    }
256   
 
257  5 toggle public void visitEnter(Rename reason) {
258  5 enter(reason);
259    }
260   
 
261  5 toggle public void visitEnter(SubstFree reason) {
262  5 enter(reason);
263    }
264   
 
265  5 toggle public void visitEnter(SubstFunc reason) {
266  5 enter(reason);
267    }
268   
 
269  5 toggle public void visitEnter(SubstPred reason) {
270  5 enter(reason);
271    }
272   
 
273  3 toggle public void visitEnter(Existential reason) {
274  3 enter(reason);
275    }
276   
 
277  3 toggle public void visitEnter(Universal reason) {
278  3 enter(reason);
279    }
280   
 
281  9 toggle public void visitEnter(ConditionalProof reason) {
282  9 enter(reason);
283    }
284   
 
285  4 toggle public void visitEnter(Hypothesis hypothesis) {
286  4 enter(hypothesis);
287    }
288   
 
289  4 toggle public void visitEnter(Conclusion conclusion) {
290  4 enter(conclusion);
291    }
292   
 
293  42 toggle public void visitEnter(FormalProofLineList proofLineList) {
294  42 enter(proofLineList);
295    }
296   
 
297  6 toggle public void visitEnter(Proof proof) {
298  6 enter(proof);
299    }
300   
 
301  8 toggle public void visitEnter(ProofList proofList) {
302  8 enter(proofList);
303    }
304   
 
305  58 toggle public void visitEnter(Proposition proposition) {
306  58 enter(proposition);
307    }
308   
 
309  152 toggle public void visitEnter(Qedeq qedeq) {
310  152 enter(qedeq);
311    }
312   
 
313  12 toggle public void visitEnter(Rule rule) {
314  12 enter(rule);
315    }
316   
 
317  4 toggle public void visitEnter(ChangedRuleList list) {
318  4 enter(list);
319    }
320   
 
321  3 toggle public void visitEnter(ChangedRule rule) {
322  3 enter(rule);
323    }
324   
 
325  119 toggle public void visitEnter(Section section) {
326  119 enter(section);
327    }
328   
 
329  120 toggle public void visitEnter(SectionList sectionList) {
330  120 enter(sectionList);
331    }
332   
 
333  9 toggle public void visitEnter(Specification specification) {
334  9 enter(specification);
335    }
336   
 
337  5 toggle public void visitEnter(Subsection subsection) {
338  5 enter(subsection);
339    }
340   
 
341  113 toggle public void visitEnter(SubsectionList subsectionList) {
342  113 enter(subsectionList);
343    }
344   
 
345  0 toggle public void visitEnter(SubsectionType subsectionType) {
346  0 enter(subsectionType);
347    }
348   
 
349  4 toggle public void visitEnter(Term term) {
350  4 enter(term);
351    }
352   
 
353  4 toggle public void visitEnter(UsedByList usedByList) {
354  4 enter(usedByList);
355    }
356   
 
357  2 toggle public void visitLeave(Author author) throws ModuleDataException {
358  2 leave(author);
359    }
360   
 
361  3 toggle public void visitLeave(AuthorList authorList) {
362  3 leave(authorList);
363    }
364   
 
365  6 toggle public void visitLeave(Axiom axiom) {
366  6 leave(axiom);
367    }
368   
 
369  126 toggle public void visitLeave(Chapter chapter) {
370  126 leave(chapter);
371    }
372   
 
373  127 toggle public void visitLeave(ChapterList chapterList) {
374  127 leave(chapterList);
375    }
376   
 
377  23 toggle public void visitLeave(Formula formula) {
378  23 leave(formula);
379    }
380   
 
381  5 toggle public void visitLeave(InitialFunctionDefinition functionDefinition) {
382  5 leave(functionDefinition);
383    }
384   
 
385  6 toggle public void visitLeave(FunctionDefinition functionDefinition) {
386  6 leave(functionDefinition);
387    }
388   
 
389  20 toggle public void visitLeave(Header header) {
390  20 leave(header);
391    }
392   
 
393  4 toggle public void visitLeave(Import imp) {
394  4 leave(imp);
395    }
396   
 
397  5 toggle public void visitLeave(ImportList importList) {
398  5 leave(importList);
399    }
400   
 
401  24 toggle public void visitLeave(Latex latex) {
402  24 leave(latex);
403    }
404   
 
405  46 toggle public void visitLeave(LatexList latexList) {
406  46 leave(latexList);
407    }
408   
 
409  1 toggle public void visitLeave(LinkList linkList) {
410  1 leave(linkList);
411    }
412   
 
413  3 toggle public void visitLeave(LiteratureItem literatureItem) {
414  3 leave(literatureItem);
415    }
416   
 
417  4 toggle public void visitLeave(LiteratureItemList literatureItemList) {
418  4 leave(literatureItemList);
419    }
420   
 
421  3 toggle public void visitLeave(Location location) {
422  3 leave(location);
423    }
424   
 
425  6 toggle public void visitLeave(LocationList locationList) {
426  6 leave(locationList);
427    }
428   
 
429  107 toggle public void visitLeave(Node node) {
430  107 leave(node);
431    }
432   
 
433  5 toggle public void visitLeave(InitialPredicateDefinition predicateDefinition) {
434  5 leave(predicateDefinition);
435    }
436   
 
437  6 toggle public void visitLeave(PredicateDefinition predicateDefinition) {
438  6 leave(predicateDefinition);
439    }
440   
 
441  48 toggle public void visitLeave(FormalProofList proofList) {
442  48 leave(proofList);
443    }
444   
 
445  47 toggle public void visitLeave(FormalProof proof) {
446  47 leave(proof);
447    }
448   
 
449  32 toggle public void visitLeave(FormalProofLine proofLine) {
450  32 leave(proofLine);
451    }
452   
 
453  28 toggle public void visitLeave(Reason reason) {
454  28 leave(reason);
455    }
456   
 
457  42 toggle public void visitLeave(FormalProofLineList proofLineList) {
458  42 leave(proofLineList);
459    }
460   
 
461  1 toggle public void visitLeave(ModusPonens reason) {
462  1 leave(reason);
463    }
464   
 
465  1 toggle public void visitLeave(Add reason) {
466  1 leave(reason);
467    }
468   
 
469  5 toggle public void visitLeave(Rename reason) {
470  5 leave(reason);
471    }
472   
 
473  5 toggle public void visitLeave(SubstFree reason) {
474  5 leave(reason);
475    }
476   
 
477  5 toggle public void visitLeave(SubstFunc reason) {
478  5 leave(reason);
479    }
480   
 
481  5 toggle public void visitLeave(SubstPred reason) {
482  5 leave(reason);
483    }
484   
 
485  3 toggle public void visitLeave(Existential reason) {
486  3 leave(reason);
487    }
488   
 
489  3 toggle public void visitLeave(Universal reason) {
490  3 leave(reason);
491    }
492   
 
493  9 toggle public void visitLeave(ConditionalProof reason) {
494  9 leave(reason);
495    }
496   
 
497  4 toggle public void visitLeave(Hypothesis hypothesis) {
498  4 leave(hypothesis);
499    }
500   
 
501  4 toggle public void visitLeave(Conclusion conclusion) {
502  4 leave(conclusion);
503    }
504   
 
505  6 toggle public void visitLeave(Proof proof) {
506  6 leave(proof);
507    }
508   
 
509  8 toggle public void visitLeave(ProofList proofList) {
510  8 leave(proofList);
511    }
512   
 
513  58 toggle public void visitLeave(Proposition proposition) {
514  58 leave(proposition);
515    }
516   
 
517  152 toggle public void visitLeave(Qedeq qedeq) {
518  152 leave(qedeq);
519    }
520   
 
521  12 toggle public void visitLeave(Rule rule) {
522  12 leave(rule);
523    }
524   
 
525  4 toggle public void visitLeave(ChangedRuleList list) {
526  4 leave(list);
527    }
528   
 
529  3 toggle public void visitLeave(ChangedRule rule) {
530  3 leave(rule);
531    }
532   
 
533  119 toggle public void visitLeave(Section section) {
534  119 leave(section);
535    }
536   
 
537  120 toggle public void visitLeave(SectionList sectionList) {
538  120 leave(sectionList);
539    }
540   
 
541  9 toggle public void visitLeave(Specification specification) {
542  9 leave(specification);
543    }
544   
 
545  5 toggle public void visitLeave(Subsection subsection) {
546  5 leave(subsection);
547    }
548   
 
549  113 toggle public void visitLeave(SubsectionList subsectionList) {
550  113 leave(subsectionList);
551    }
552   
 
553  0 toggle public void visitLeave(SubsectionType subsectionType) {
554  0 leave(subsectionType);
555    }
556   
 
557  4 toggle public void visitLeave(Term term) {
558  4 leave(term);
559    }
560   
 
561  4 toggle public void visitLeave(UsedByList usedByList) {
562  4 leave(usedByList);
563    }
564   
 
565  1476 toggle private int getCounter(final int level) {
566  1476 int value = 0;
567  1476 if (level < counter.size()) {
568  984 Object obj = counter.get(level);
569  984 if (obj != null) {
570  984 value = ((Integer) obj).intValue();
571    }
572    }
573  1476 return value;
574    }
575   
 
576  531 toggle private void setCounter(final int level, final int value) {
577  1141 while (level >= counter.size()) {
578  610 counter.add(new Integer(0));
579    }
580  531 counter.set(level, new Integer(value));
581    }
582   
 
583  984 toggle private void increaseCounter(final int level) {
584  1476 while (level >= counter.size()) {
585  492 counter.add(new Integer(0));
586    }
587  984 counter.set(level, new Integer(1 + getCounter(level)));
588    }
589   
 
590  550 toggle private void deleteCounter(final int level) {
591  550 counter.setSize(level);
592    }
593   
 
594  2858 toggle public String getContext() {
595  2858 String result = "";
596  17220 for (int i = 1; i < getterStack.size(); i++) {
597  14362 if (i > 1) {
598  11808 result += ".";
599    }
600  14362 result += getterStack.get(i);
601    }
602  2858 return result;
603    }
604   
 
605  1429 toggle protected void enter(final Object obj) {
606  1429 if (obj == null) {
607  0 return;
608    }
609  1429 String name = StringUtility.getClassName(obj.getClass());
610    // System.out.println(name);
611  1429 if (name.endsWith("Vo")) {
612  1391 name = name.substring(0, name.length() - 2);
613  38 } else if (name.equals("DefaultAtom")) {
614  19 name = "Atom";
615  19 } else if (name.equals("DefaultElementList")) {
616  19 name = "ElementList";
617    }
618  1429 String lastName = "";
619  1429 if (getLevel() > 0) {
620  1277 lastName = objectStack.lastElement().toString();
621    }
622  1429 String getter = "get" + name + "()";
623  1429 if (name.equals("Atom")) {
624  19 getter = "getElement().getAtom()";
625  1410 } else if (name.equals("ElementList")) {
626  19 getter = "getElement().getList()";
627    }
628    // System.out.println("lastName=" + lastName);
629    // System.out.println("getter=" + getter);
630  1429 if (!getter.startsWith("getElement()") && name.endsWith("List")) {
631  531 setCounter(getLevel() + 1, 0);
632  531 if ("LatexList".equals(name)) {
633    // we have to guess the correct context :-(
634    // System.out.println("name=" + name);
635  46 getter = StringUtility.getLastDotString(traverser.getCurrentContext().getLocationWithinModule());
636    // System.out.println("getter=" + getter);
637    }
638   
639  898 } else if (lastName.endsWith("List")) {
640    // if (lastName.equals(name + "List")) {
641    // if (!(name + "List").equals(lastName)) {
642    // System.out.println(">>>>>>>>>>>>>>>>>>>>>>> " + name + " " + obj.getClass().getName());
643    // }
644  492 getter = "get(" + getCounter(getLevel() + 1) + ")";
645  492 if (name.equals("Subsection")) {
646  5 getter += ".getSubsection()";
647  492 } if (name.equals("Node")) {
648  107 getter += ".getNode()";
649    }
650  492 increaseCounter(getLevel() + 1);
651  406 } else if (lastName.equals("Author")) {
652  1 if (name.equals("Latex")) {
653  1 getter = "getName()";
654    }
655  405 } else if (lastName.equals("FormalProofLine") && obj instanceof Reason) {
656  28 getter = "getReason()";
657  377 } else if (getter.startsWith("getElement()")) {
658    // System.out.println("getElement() found");
659  38 if (lastName.equals("InitialPredicateDefinition")) {
660    // System.out.println("getPredCon() found");
661  2 getter = "getPredCon()." + StringUtility.getLastDotString(getter);
662  36 } else if (lastName.equals("InitialFunctionDefinition")) {
663  2 getter = "getFunCon()." + StringUtility.getLastDotString(getter);
664  34 } else if (lastName.equals("SubstFree")) {
665  2 getter = "getSubjectVariable()." + StringUtility.getLastDotString(getter);
666  32 } else if (lastName.equals("SubstPred")) {
667  2 getter = "getPredicateVariable()." + StringUtility.getLastDotString(getter);
668  30 } else if (lastName.equals("Rename")) {
669    // we have a 50 to 50 chance so we get it from the correct(?) context
670    // getter = "getPredicateVariable()." + StringUtility.getLastDotString(getter);
671  4 getter = StringUtility.getLastTwoDotStrings(traverser.getCurrentContext()
672    .getLocationWithinModule());
673  26 } else if (lastName.equals("Existential")) {
674  2 getter = "getSubjectVariable()." + StringUtility.getLastDotString(getter);
675  24 } else if (lastName.equals("Universal")) {
676  2 getter = "getSubjectVariable()." + StringUtility.getLastDotString(getter);
677  22 } else if (lastName.equals("SubstFunc")) {
678  2 getter = "getFunctionVariable()." + StringUtility.getLastDotString(getter);
679    }
680  339 } else if (lastName.equals("SubstFree") && name.equals("Term")) {
681  2 getter = "getSubstituteTerm()";
682  337 } else if (lastName.equals("SubstFunc") && name.equals("Term")) {
683  2 getter = "getSubstituteTerm()";
684  335 } else if (lastName.equals("SubstPred") && name.equals("Formula")) {
685  2 getter = "getSubstituteFormula()";
686    // TODO 20130131 m31: this shows a broken design!!!
687  333 } else if (name.equals("Proposition")) {
688  58 getter = "getNodeType()." + getter;
689  275 } else if (name.equals("Rule")) {
690  12 getter = "getNodeType()." + getter;
691  263 } else if (name.endsWith("Definition")) {
692  22 getter = "getNodeType()." + getter;
693  241 } else if (name.endsWith("Axiom")) {
694  6 getter = "getNodeType()." + getter;
695    }
696    // System.out.println(name);
697  1429 objectStack.push(name);
698  1429 getterStack.push(getter);
699  1429 text.println("<" + name + ">");
700  1429 text.pushLevel();
701  1429 checkEnter();
702    }
703   
 
704  1429 toggle protected void leave(final Object obj) {
705  1429 if (obj == null) {
706  0 return;
707    }
708  1429 checkLeave();
709  1429 String name = StringUtility.getClassName(obj.getClass());
710  1429 if (name.endsWith("Vo")) {
711  1391 name = name.substring(0, name.length() - 2);
712    }
713  1429 if (name.endsWith("List")) {
714  550 deleteCounter(getLevel());
715    } else {
716  879 if (getterStack.size() > 0 && getterStack.lastElement().toString().startsWith("get(")) {
717  492 increaseCounter(getLevel());
718    }
719    }
720  1429 objectStack.pop();
721  1429 getterStack.pop();
722  1429 text.popLevel();
723  1429 text.println("</" + StringUtility.getClassName(obj.getClass()) + ">");
724    }
725   
 
726  4138 toggle public int getLevel() {
727  4138 return objectStack.size();
728    }
729   
 
730  0 toggle protected void checkEnter() {
731    // System.out.println(">" + getContext());
732    // for (int i = 0; i < objectStack.size(); i++) {
733    // System.out.print(objectStack.get(i) + " ");
734    // }
735    // System.out.println();
736    }
737   
 
738  0 toggle protected void checkLeave() {
739    // System.out.println("<" + getContext());
740    }
741    }
 
CloverReport generated by Clover Code Coverage v3.1.10
Fri May 24 2013 13:47:32 UTC.		   Clover: Open Source License registered to qedeq.org .