Clover Coverage Report
Coverage timestamp: Fri May 24 2013 13:47:27 UTC
Overview   Package   File
    FRAMES   NO FRAMES     
45   315   12   3.75
0   265   0.27   12
12     1  
1    
 
  Element2LatexImplTest       Line # 29 45 12 100% 1.0
 
  (10)
 
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    package org.qedeq.kernel.bo.service.control;
16   
17    import org.qedeq.base.test.QedeqTestCase;
18    import org.qedeq.kernel.bo.module.ModuleLabels;
19    import org.qedeq.kernel.bo.service.control.Element2LatexImpl;
20    import org.qedeq.kernel.se.base.list.Element;
21    import org.qedeq.kernel.se.dto.list.DefaultAtom;
22    import org.qedeq.kernel.se.dto.list.DefaultElementList;
23   
24    /**
25    * Testing {@link Element2LatexImplTest}.
26    *
27    * @author Michael Meyling
28    */
 
29    public class Element2LatexImplTest extends QedeqTestCase {
30   
31    private Element2LatexImpl transform;
32   
 
33  10 toggle protected void setUp() throws Exception {
34  10 super.setUp();
35  10 transform = new Element2LatexImpl(new ModuleLabels());
36    }
37   
 
38  10 toggle protected void tearDown() throws Exception {
39  10 super.tearDown();
40    }
41   
 
42  1 toggle public void testVar() {
43  1 final Element ele = new DefaultElementList("VAR", new Element[] {
44    new DefaultAtom("x")});
45    // System.out.println(transform.getLatex(ele));
46  1 assertEquals("x", transform.getLatex(ele));
47  1 final Element ele2 = new DefaultElementList("VAR", new Element[] {
48    new DefaultAtom("1")});
49    // System.out.println(transform.getLatex(ele2));
50  1 assertEquals("x", transform.getLatex(ele2));
51  1 final Element ele3 = new DefaultElementList("FUNVAR", new Element[] {
52    new DefaultAtom("psi"),
53    new DefaultElementList("VAR", new Element[] {
54    new DefaultAtom("x"),
55    }),
56    new DefaultElementList("VAR", new Element[] {
57    new DefaultAtom("1"),
58    }),
59    new DefaultElementList("VAR", new Element[] {
60    new DefaultAtom("y"),
61    }),
62    new DefaultElementList("VAR", new Element[] {
63    new DefaultAtom("2"),
64    }),
65    new DefaultElementList("VAR", new Element[] {
66    new DefaultAtom("z"),
67    }),
68    new DefaultElementList("VAR", new Element[] {
69    new DefaultAtom("3"),
70    }),
71    new DefaultElementList("VAR", new Element[] {
72    new DefaultAtom("u"),
73    }),
74    new DefaultElementList("VAR", new Element[] {
75    new DefaultAtom("4"),
76    }),
77    new DefaultElementList("VAR", new Element[] {
78    new DefaultAtom("v"),
79    }),
80    new DefaultElementList("VAR", new Element[] {
81    new DefaultAtom("5"),
82    }),
83    new DefaultElementList("VAR", new Element[] {
84    new DefaultAtom("w"),
85    }),
86    new DefaultElementList("VAR", new Element[] {
87    new DefaultAtom("6"),
88    }),
89    new DefaultElementList("VAR", new Element[] {
90    new DefaultAtom("7"),
91    }),
92    new DefaultElementList("VAR", new Element[] {
93    new DefaultAtom("8"),
94    })
95    });
96  1 assertEquals("psi(x, x, y, y, z, z, u, u, v, v, w, w, x_1, x_2)", transform.getLatex(ele3));
97  1 final Element ele4 = new DefaultElementList("VAR", new Element[] {
98    new DefaultAtom(" 1")});
99    // System.out.println(transform.getLatex(ele4));
100  1 assertEquals(" 1", transform.getLatex(ele4));
101    }
102   
 
103  1 toggle public void testFuncon() {
104  1 final Element ele = new DefaultElementList("FUNCON", new Element[] {
105    new DefaultAtom("RussellClass")});
106    // System.out.println(transform.getLatex(ele));
107  1 assertEquals("\\mathfrak{Ru}", transform.getLatex(ele));
108  1 final Element ele2 = new DefaultElementList("FUNCON", new Element[] {
109    new DefaultAtom("phi")});
110    // System.out.println(transform.getLatex(ele2));
111  1 assertEquals("phi_0()", transform.getLatex(ele2));
112    }
113   
 
114  1 toggle public void testFunvar() {
115  1 final Element ele = new DefaultElementList("FUNVAR", new Element[] {
116    new DefaultAtom("phi")});
117    // System.out.println(transform.getLatex(ele));
118  1 assertEquals("phi", transform.getLatex(ele));
119  1 final Element ele2 = new DefaultElementList("FUNVAR", new Element[] {
120    new DefaultAtom("phi"),
121    new DefaultElementList("VAR", new Element[] {
122    new DefaultAtom("x"),
123    })
124    });
125    // System.out.println(transform.getLatex(ele2));
126  1 assertEquals("phi(x)", transform.getLatex(ele2));
127    }
128   
 
129  1 toggle public void testPredcon() {
130  1 final Element ele = new DefaultElementList("PREDCON", new Element[] {
131    new DefaultAtom("isSet"),
132    new DefaultElementList("VAR", new Element[] {
133    new DefaultAtom("x"),
134    })
135    });
136    // System.out.println(transform.getLatex(ele));
137  1 assertEquals("\\mathfrak{M}(x)", transform.getLatex(ele));
138  1 final Element ele2 = new DefaultElementList("PREDCON", new Element[] {
139    new DefaultAtom("isSet")
140    });
141    // System.out.println(transform.getLatex(ele));
142  1 assertEquals("isSet_0()", transform.getLatex(ele2));
143  1 final Element ele3 = new DefaultElementList("PREDCON", new Element[] {
144    new DefaultAtom("isMyOwnPredcon")
145    });
146    // System.out.println(transform.getLatex(ele));
147  1 assertEquals("isMyOwnPredcon_0()", transform.getLatex(ele3));
148    }
149   
 
150  1 toggle public void testPredvar() {
151  1 final Element ele = new DefaultElementList("PREDVAR", new Element[] {
152    new DefaultAtom("alpha")});
153    // System.out.println(transform.getLatex(ele));
154  1 assertEquals("alpha", transform.getLatex(ele));
155  1 final Element ele2 = new DefaultElementList("PREDVAR", new Element[] {
156    new DefaultAtom("alpha"),
157    new DefaultElementList("VAR", new Element[] {
158    new DefaultAtom("x"),
159    })
160    });
161    // System.out.println(transform.getLatex(ele2));
162  1 assertEquals("alpha(x)", transform.getLatex(ele2));
163    }
164   
 
165  1 toggle public void testVarious1() {
166  1 Element ele = new DefaultElementList("EQUI", new Element[] {
167    new DefaultElementList("PREDCON", new Element[] {
168    new DefaultAtom("equal"),
169    new DefaultElementList("VAR", new Element[] {
170    new DefaultAtom("y"),
171    }),
172    new DefaultElementList("CLASS", new Element[] {
173    new DefaultElementList("VAR", new Element[] {
174    new DefaultAtom("x"),
175    }),
176    new DefaultElementList("PREDVAR", new Element[] {
177    new DefaultAtom("\\phi"),
178    new DefaultElementList("VAR", new Element[] {
179    new DefaultAtom("x"),
180    })
181    })
182    })
183    }),
184    new DefaultElementList("FORALL", new Element[] {
185    new DefaultElementList("VAR", new Element[] {
186    new DefaultAtom("z"),
187    }),
188    new DefaultElementList("EQUI", new Element[] {
189    new DefaultElementList("PREDCON", new Element[] {
190    new DefaultAtom("in"),
191    new DefaultElementList("VAR", new Element[] {
192    new DefaultAtom("z"),
193    }),
194    new DefaultElementList("VAR", new Element[] {
195    new DefaultAtom("y"),
196    })
197    }),
198    new DefaultElementList("PREDCON", new Element[] {
199    new DefaultAtom("in"),
200    new DefaultElementList("VAR", new Element[] {
201    new DefaultAtom("z"),
202    }),
203    new DefaultElementList("CLASS", new Element[] {
204    new DefaultElementList("VAR", new Element[] {
205    new DefaultAtom("x"),
206    }),
207    new DefaultElementList("PREDVAR", new Element[] {
208    new DefaultAtom("\\phi"),
209    new DefaultElementList("VAR", new Element[] {
210    new DefaultAtom("x"),
211    })
212    })
213    })
214    })
215    })
216    })
217    });
218    // System.out.println(transform.getLatex(ele));
219  1 assertEquals("y \\ = \\ \\{ x \\ | \\ \\phi(x) \\} \\ \\leftrightarrow\\ "
220    + "\\forall z\\ (z \\in y\\ \\leftrightarrow\\ z \\in \\{ x \\ | \\ \\phi(x) \\} )",
221    transform.getLatex(ele));
222  1 assertEquals("(y \\ = \\ \\{ x \\ | \\ \\phi(x) \\} \\ \\leftrightarrow\\ "
223    + "\\forall z\\ (z \\in y\\ \\leftrightarrow\\ z \\in \\{ x \\ | \\ \\phi(x) \\} ))",
224    transform.getLatex(ele, false));
225    }
226   
 
227  1 toggle public void testBinaryLogical() {
228  1 Element ele = new DefaultElementList("AND", new Element[] {
229    new DefaultElementList("PREDVAR", new Element[] {
230    new DefaultAtom("\\alpha"),
231    new DefaultElementList("VAR", new Element[] {
232    new DefaultAtom("x"),
233    })
234    }),
235    new DefaultElementList("PREDVAR", new Element[] {
236    new DefaultAtom("\\beta"),
237    new DefaultElementList("VAR", new Element[] {
238    new DefaultAtom("y")
239    })
240    }),
241    new DefaultElementList("IMPL", new Element[] {
242    new DefaultElementList("PREDVAR", new Element[] {
243    new DefaultAtom("\\alpha"),
244    new DefaultElementList("VAR", new Element[] {
245    new DefaultAtom("x")
246    })
247    }),
248    new DefaultElementList("PREDVAR", new Element[] {
249    new DefaultAtom("\\beta"),
250    new DefaultElementList("VAR", new Element[] {
251    new DefaultAtom("y")
252    })
253    })
254    })
255    });
256    // System.out.println(transform.getLatex(ele));
257  1 assertEquals("\\alpha(x)\\ \\land\\ \\beta(y)\\ \\land\\ (\\alpha(x)\\ \\rightarrow\\ \\beta(y))",
258    transform.getLatex(ele));
259  1 assertEquals("(\\alpha(x)\\ \\land\\ \\beta(y)\\ \\land\\ (\\alpha(x)\\ \\rightarrow\\ \\beta(y)))",
260    transform.getLatex(ele, false));
261    }
262   
 
263  1 toggle public void testVarious2() {
264  1 Element ele = new DefaultElementList("myOperator", new Element[] {
265    new DefaultAtom("Hello"),
266    new DefaultAtom("Again"),
267    new DefaultElementList("again", new Element[] {
268    new DefaultAtom("one"),
269    new DefaultAtom("two"),
270    new DefaultAtom("three")
271    })
272    });
273  1 assertEquals("myOperator(Hello, Again, again(one, two, three))", transform.getLatex(ele));
274  1 assertEquals("myOperator(Hello, Again, again(one, two, three))", transform.getLatex(ele, false));
275    }
276   
 
277  1 toggle public void testClass() {
278  1 Element ele = new DefaultElementList("CLASS", new Element[] {
279    new DefaultElementList("VAR", new Element[] {
280    new DefaultAtom("x"),
281    }),
282    new DefaultElementList("PREDVAR", new Element[] {
283    new DefaultAtom("\\beta"),
284    new DefaultElementList("VAR", new Element[] {
285    new DefaultAtom("y")
286    })
287    })
288    });
289    // System.out.println(transform.getLatex(ele));
290  1 assertEquals("\\{ x \\ | \\ \\beta(y) \\} ",
291    transform.getLatex(ele));
292  1 assertEquals("\\{ x \\ | \\ \\beta(y) \\} ",
293    transform.getLatex(ele, false));
294    }
295   
 
296  1 toggle public void testClasslist() {
297  1 Element ele = new DefaultElementList("CLASSLIST", new Element[] {
298    new DefaultElementList("VAR", new Element[] {
299    new DefaultAtom("x"),
300    }),
301    new DefaultElementList("VAR", new Element[] {
302    new DefaultAtom("y"),
303    }),
304    new DefaultElementList("VAR", new Element[] {
305    new DefaultAtom("z"),
306    })
307    });
308  1 System.out.println(transform.getLatex(ele));
309  1 assertEquals("\\{ x, \\ y, \\ z \\} ",
310    transform.getLatex(ele));
311  1 assertEquals("\\{ x, \\ y, \\ z \\} ",
312    transform.getLatex(ele, false));
313    }
314    }
315   
 
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 .