Clover Coverage Report
Coverage timestamp: Fri May 24 2013 13:47:27 UTC
Overview   Package   File
    FRAMES   NO FRAMES     
166   338   25   12.77
0   224   0.15   13
13     1.92  
1    
 
  VersionTest       Line # 26 166 25 93.3% 0.93296087
 
  (12)
 
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.base.io;
17   
18    import org.qedeq.base.io.Version;
19    import org.qedeq.base.test.QedeqTestCase;
20   
21    /**
22    * Test {@link Version}.
23    *
24    * @author Michael Meyling
25    */
 
26    public class VersionTest extends QedeqTestCase {
27   
28    private Version version1;
29   
30    private Version version2;
31   
32    private Version version3;
33   
34    private Version version4;
35   
36   
 
37  12 toggle protected void setUp() throws Exception {
38  12 super.setUp();
39  12 version1 = new Version("0.00.00");
40  12 version2 = new Version("0.01.00");
41  12 version3 = new Version("0.02.01");
42  12 version4 = new Version("1.00.00");
43    }
44   
45    /**
46    * Test constructors.
47    *
48    * @throws Exception Test failure.
49    */
 
50  1 toggle public void testConstructors() throws Exception {
51  1 final Version v1 = new Version("1.2.3");
52  1 assertEquals(1, v1.getMajor());
53  1 assertEquals(2, v1.getMinor());
54  1 assertEquals(3, v1.getPatch());
55  1 try {
56  1 new Version("");
57  0 fail("exception expected");
58    } catch (IllegalArgumentException e) {
59    // ok
60    }
61  1 try {
62  1 new Version(null);
63  0 fail("exception expected");
64    } catch (NullPointerException e) {
65    // ok
66    }
67  1 try {
68  1 new Version("1");
69  0 fail("exception expected");
70    } catch (IllegalArgumentException e) {
71    // ok
72    }
73  1 try {
74  1 new Version("1.");
75  0 fail("exception expected");
76    } catch (IllegalArgumentException e) {
77    // ok
78    }
79  1 try {
80  1 new Version("1.2");
81  0 fail("exception expected");
82    } catch (IllegalArgumentException e) {
83    // ok
84    }
85  1 try {
86  1 new Version("1.2.");
87  0 fail("exception expected");
88    } catch (IllegalArgumentException e) {
89    // ok
90    }
91  1 try {
92  1 new Version("1.2.3.");
93  0 fail("exception expected");
94    } catch (IllegalArgumentException e) {
95    // ok
96    }
97  1 try {
98  1 new Version("1.2.3.4");
99  0 fail("exception expected");
100    } catch (IllegalArgumentException e) {
101    // ok
102    }
103  1 try {
104  1 new Version("+1.2.3");
105  0 fail("exception expected");
106    } catch (IllegalArgumentException e) {
107    // ok
108    }
109  1 try {
110  1 new Version("-1.2.3");
111  0 fail("exception expected");
112    } catch (IllegalArgumentException e) {
113    // ok
114    }
115  1 try {
116  1 new Version("null");
117  0 fail("exception expected");
118    } catch (IllegalArgumentException e) {
119    // ok
120    }
121  1 new Version("1234567890.1234567890.1234567890"); // ok
122  1 try {
123  1 new Version("12345678901.12345678901.12345678901");
124  0 fail("exception expected");
125    } catch (IllegalArgumentException e) {
126    // ok
127    }
128  1 assertEquals(version1, new Version(" 0.00.00 "));
129  1 assertEquals(version2, new Version(" 0.01.00 "));
130  1 assertEquals(version3, new Version(" \t0.02. 01 "));
131  1 assertEquals(version4, new Version(" 1.00.00 "));
132    }
133   
134    /**
135    * Test getters.
136    *
137    * @throws Exception Test failure.
138    */
 
139  1 toggle public void testGetters() throws Exception {
140  1 assertEquals(0, version1.getMajor());
141  1 assertEquals(0, version1.getMinor());
142  1 assertEquals(0, version1.getPatch());
143  1 assertEquals(0, version2.getMajor());
144  1 assertEquals(1, version2.getMinor());
145  1 assertEquals(0, version2.getPatch());
146  1 assertEquals(0, version3.getMajor());
147  1 assertEquals(2, version3.getMinor());
148  1 assertEquals(1, version3.getPatch());
149  1 assertEquals(1, version4.getMajor());
150  1 assertEquals(0, version4.getMinor());
151  1 assertEquals(0, version4.getPatch());
152  1 assertEquals(123456, new Version("123456.0.0").getMajor());
153  1 assertEquals(62743, new Version("123456.62743.0").getMinor());
154  1 assertEquals(732864, new Version("123456.62743.732864").getPatch());
155    }
156   
157    /**
158    * Test compareTo.
159    *
160    * @throws Exception Test failure.
161    */
 
162  1 toggle public void testCompareTo() throws Exception {
163  1 assertEquals(0, version1.compareTo(version1));
164  1 assertEquals(0, version2.compareTo(version2));
165  1 assertEquals(0, version3.compareTo(version3));
166  1 assertEquals(0, version4.compareTo(version4));
167  1 assertEquals(-1, version1.compareTo(version2));
168  1 assertEquals(-1, version2.compareTo(version3));
169  1 assertEquals(-1, version3.compareTo(version4));
170  1 assertEquals(-1, version2.compareTo(version4));
171  1 assertEquals(-1, version1.compareTo(version3));
172  1 assertEquals(-1, version1.compareTo(version4));
173  1 assertEquals(1, version2.compareTo(version1));
174  1 assertEquals(1, version3.compareTo(version2));
175  1 assertEquals(1, version4.compareTo(version3));
176  1 assertEquals(1, version4.compareTo(version2));
177  1 assertEquals(1, version3.compareTo(version1));
178  1 assertEquals(1, version4.compareTo(version1));
179    }
180   
181    /**
182    * Test isLess.
183    *
184    * @throws Exception Test failure.
185    */
 
186  1 toggle public void testIsLess() throws Exception {
187  1 assertTrue(version1.isLess(version2));
188  1 assertTrue(version2.isLess(version3));
189  1 assertTrue(version3.isLess(version4));
190  1 assertTrue(version1.isLess(version3));
191  1 assertTrue(version1.isLess(version4));
192  1 assertTrue(version2.isLess(version3));
193  1 assertFalse(version2.isLess(version1));
194  1 assertFalse(version3.isLess(version2));
195  1 assertFalse(version4.isLess(version3));
196  1 assertFalse(version3.isLess(version1));
197  1 assertFalse(version4.isLess(version1));
198  1 assertFalse(version3.isLess(version2));
199  1 assertFalse(version1.isLess(version1));
200  1 assertFalse(version2.isLess(version2));
201  1 assertFalse(version3.isLess(version3));
202  1 assertFalse(version4.isLess(version4));
203    }
204   
205    /**
206    * Test isLess.
207    *
208    * @throws Exception Test failure.
209    */
 
210  1 toggle public void testIsBigger() throws Exception {
211  1 assertFalse(version1.isBigger(version2));
212  1 assertFalse(version2.isBigger(version3));
213  1 assertFalse(version3.isBigger(version4));
214  1 assertFalse(version1.isBigger(version3));
215  1 assertFalse(version1.isBigger(version4));
216  1 assertFalse(version2.isBigger(version3));
217  1 assertTrue(version2.isBigger(version1));
218  1 assertTrue(version3.isBigger(version2));
219  1 assertTrue(version4.isBigger(version3));
220  1 assertTrue(version3.isBigger(version1));
221  1 assertTrue(version4.isBigger(version1));
222  1 assertTrue(version3.isBigger(version2));
223  1 assertFalse(version1.isBigger(version1));
224  1 assertFalse(version2.isBigger(version2));
225  1 assertFalse(version3.isBigger(version3));
226  1 assertFalse(version4.isBigger(version4));
227    }
228   
229    /**
230    * Test toString.
231    *
232    * @throws Exception Test failure.
233    */
 
234  1 toggle public void testToString() throws Exception {
235  1 assertEquals("0.00.00", version1.toString());
236  1 assertEquals("0.01.00", version2.toString());
237  1 assertEquals("0.02.01", version3.toString());
238  1 assertEquals("1.00.00", version4.toString());
239  1 assertEquals("625434.99.71", new Version("625434.99.71").toString());
240  1 assertEquals("0.00.00", new Version("0.0.0").toString());
241  1 assertEquals("0.09.09", new Version("0.9.9").toString());
242  1 assertEquals("0.900.900", new Version("0.900.900").toString());
243    }
244   
245    /**
246    * Test equals.
247    *
248    * @throws Exception Test failure.
249    */
 
250  1 toggle public void testEquals() throws Exception {
251  1 assertEquals(version1, version1);
252  1 assertEquals(version1, new Version("0.00.00"));
253  1 assertEquals(version2, version2);
254  1 assertEquals(version2, new Version("0.01.00"));
255  1 assertEquals(version3, version3);
256  1 assertEquals(version3, new Version("0.02.01"));
257  1 assertEquals(version4, version4);
258  1 assertEquals(version4, new Version("1.00.00"));
259  1 assertFalse(version1.equals(null));
260  1 assertFalse(version1.equals(version2));
261  1 assertFalse(version2.equals(version3));
262  1 assertFalse(version3.equals(version4));
263  1 assertFalse(version4.equals(version1));
264  1 assertFalse(version3.equals(version2));
265  1 assertFalse(version1.equals(version3));
266  1 assertFalse(version3.equals(version1));
267    }
268   
269    /**
270    * Test special equals method.
271    *
272    * @throws Exception Test failure.
273    */
 
274  1 toggle public void testEquals2() throws Exception {
275  1 assertTrue(version1.equals("0.00.00"));
276  1 assertTrue(version1.equals("00000.00000.0"));
277  1 assertTrue(version1.equals("0.0.0"));
278  1 assertTrue(version2.equals("0.01.00"));
279  1 assertFalse(version2.equals("0.00.00"));
280  1 assertTrue(version3.equals("0.02.01"));
281  1 assertFalse(version3.equals("0.02.00"));
282  1 assertFalse(version3.equals("0.02.0"));
283  1 assertTrue(version4.equals("1.00.00"));
284    }
285   
286    /**
287    * Test hashCode.
288    *
289    * @throws Exception Test failure.
290    */
 
291  1 toggle public void testHashCode() throws Exception {
292  1 assertFalse(version1.hashCode() == version2.hashCode());
293  1 assertFalse(version2.hashCode() == version3.hashCode());
294  1 assertFalse(version3.hashCode() == version4.hashCode());
295  1 assertTrue((new Version("0.0.0")).hashCode() == version1.hashCode());
296    }
297   
298    /**
299    * Test less.
300    *
301    * @throws Exception Test failure.
302    */
 
303  1 toggle public void testLess() throws Exception {
304  1 assertTrue(Version.less("0.00.00", "0.00.01"));
305  1 assertTrue(Version.less("1.00.00", "1.00.01"));
306  1 assertTrue(Version.less("2.01.00", "2.01.01"));
307  1 assertFalse(Version.less("2.01.00", "2.01.00"));
308  1 assertFalse(Version.less("3.01.00", "2.01.00"));
309  1 assertFalse(Version.less("0.00.00", "0.00.00"));
310    }
311   
312    /**
313    * Test bigger.
314    *
315    * @throws Exception Test failure.
316    */
 
317  1 toggle public void testBigger() throws Exception {
318  1 assertTrue(Version.bigger("0.00.10", "0.00.01"));
319  1 assertTrue(Version.bigger("1.09.10", "0.00.01"));
320  1 assertTrue(Version.bigger("0.01.10", "0.01.1"));
321  1 assertFalse(Version.bigger("0.01.10", "0.01.11"));
322  1 assertFalse(Version.bigger("0.01.10", "0.01.10"));
323    }
324   
325    /**
326    * Test bigger.
327    *
328    * @throws Exception Test failure.
329    */
 
330  1 toggle public void testEquals3() throws Exception {
331  1 assertFalse(Version.equals("0.00.10", "0.00.01"));
332  1 assertFalse(Version.equals("1.09.10", "0.00.01"));
333  1 assertFalse(Version.equals("0.01.10", "0.01.1"));
334  1 assertFalse(Version.equals("0.01.10", "0.01.11"));
335  1 assertTrue(Version.equals("0.01.10", "0.01.10"));
336    }
337   
338    }
 
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 .