KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > mountainminds > eclemma > internal > core > analysis > LinesTest


1 /*******************************************************************************
2  * Copyright (c) 2006 Mountainminds GmbH & Co. KG
3  * This software is provided under the terms of the Eclipse Public License v1.0
4  * See http://www.eclipse.org/legal/epl-v10.html.
5  *
6  * $Id: LinesTest.java 175 2006-11-19 16:22:31Z mtnminds $
7  ******************************************************************************/
8 package com.mountainminds.eclemma.internal.core.analysis;
9
10 import com.mountainminds.eclemma.core.analysis.ILineCoverage;
11 import com.mountainminds.eclemma.internal.core.analysis.Lines;
12
13 import junit.framework.TestCase;
14
15 /**
16  * @author Marc R. Hoffmann
17  * @version $Revision: 175 $
18  */
19 public class LinesTest extends TestCase {
20
21   protected Lines lines;
22   
23   protected void setUp() throws Exception JavaDoc {
24     lines = new Lines();
25   }
26   
27   public void testContinuousExpansionRight() {
28     int start = 123;
29     int end = 2345;
30     for (int i = start; i <= end; i++) {
31       lines.addLines(new int[] {i}, false);
32       assertEquals("first line", start, lines.getFirstLine());
33       assertEquals("last line", i, lines.getLastLine());
34     }
35   }
36
37   public void testContinuousExpansionLeft() {
38     int start = 123;
39     int end = 2345;
40     for (int i = end; i >= start; i--) {
41       lines.addLines(new int[] {i}, false);
42       assertEquals("first line", i, lines.getFirstLine());
43       assertEquals("last line", end, lines.getLastLine());
44     }
45   }
46   
47   public void testStepExpansionRight() {
48     int start = 123;
49     int end = 23456;
50     for (int i = start; i <= end; i += 733) {
51       lines.addLines(new int[] {i}, false);
52       assertEquals("first line", start, lines.getFirstLine());
53       assertEquals("last line", i, lines.getLastLine());
54     }
55   }
56   
57   public void testStepExpansionLeft() {
58     int start = 123;
59     int end = 23456;
60     for (int i = end; i >= start; i -= 733) {
61       lines.addLines(new int[] {i}, false);
62       assertEquals("first line", i, lines.getFirstLine());
63       assertEquals("last line", end, lines.getLastLine());
64     }
65   }
66   
67   public void testLineCoveredCovered() {
68     lines.addLines(new int[] {3}, true);
69     lines.addLines(new int[] {3}, true);
70     assertEquals("total", 1, lines.getTotalCount());
71     assertEquals("covered", 1, lines.getCoveredCount());
72     assertEquals("line 3", ILineCoverage.FULLY_COVERED, lines.getCoverage()[lines.getOffset() + 3]);
73   }
74   
75   public void testLineCoveredUncovered() {
76     lines.addLines(new int[] {3}, true);
77     lines.addLines(new int[] {3}, false);
78     assertEquals("total", 1, lines.getTotalCount());
79     assertEquals("covered", 1, lines.getCoveredCount());
80     assertEquals("line 3", ILineCoverage.PARTLY_COVERED, lines.getCoverage()[lines.getOffset() + 3]);
81   }
82   
83   public void testLineUncoveredCovered() {
84     lines.addLines(new int[] {3}, false);
85     lines.addLines(new int[] {3}, true);
86     assertEquals("total", 1, lines.getTotalCount());
87     assertEquals("covered", 1, lines.getCoveredCount());
88     assertEquals("line 3", ILineCoverage.PARTLY_COVERED, lines.getCoverage()[lines.getOffset() + 3]);
89   }
90   
91   public void testLineUncoveredUncovered() {
92     lines.addLines(new int[] {3}, false);
93     lines.addLines(new int[] {3}, false);
94     assertEquals("total", 1, lines.getTotalCount());
95     assertEquals("covered", 0, lines.getCoveredCount());
96     assertEquals("line 3", ILineCoverage.NOT_COVERED, lines.getCoverage()[lines.getOffset() + 3]);
97   }
98   
99   public void testLineCoveredUncoveredCovered() {
100     lines.addLines(new int[] {3}, true);
101     lines.addLines(new int[] {3}, false);
102     lines.addLines(new int[] {3}, true);
103     assertEquals("total", 1, lines.getTotalCount());
104     assertEquals("covered", 1, lines.getCoveredCount());
105     assertEquals("line 3", ILineCoverage.PARTLY_COVERED, lines.getCoverage()[lines.getOffset() + 3]);
106   }
107   
108   public void testLineUncoveredCoveredUncovered() {
109     lines.addLines(new int[] {3}, false);
110     lines.addLines(new int[] {3}, true);
111     lines.addLines(new int[] {3}, false);
112     assertEquals("total", 1, lines.getTotalCount());
113     assertEquals("covered", 1, lines.getCoveredCount());
114     assertEquals("line 3", ILineCoverage.PARTLY_COVERED, lines.getCoverage()[lines.getOffset() + 3]);
115   }
116   
117   /* Line A B C Coverage
118    * 10 + +
119    * 11 + + +
120    * 12 + + + +
121    * 13 + + +
122    * 14 + +
123    */
124   public void testScenario1() {
125     lines.addLines(new int[] {10, 11, 12}, true);
126     lines.addLines(new int[] {11, 12, 13}, true);
127     lines.addLines(new int[] {12, 13, 14}, true);
128     assertEquals("total", 5, lines.getTotalCount());
129     assertEquals("covered", 5, lines.getCoveredCount());
130     byte[] c = lines.getCoverage();
131     assertEquals("line 10", ILineCoverage.FULLY_COVERED, c[lines.getOffset() + 10]);
132     assertEquals("line 11", ILineCoverage.FULLY_COVERED, c[lines.getOffset() + 11]);
133     assertEquals("line 12", ILineCoverage.FULLY_COVERED, c[lines.getOffset() + 12]);
134     assertEquals("line 13", ILineCoverage.FULLY_COVERED, c[lines.getOffset() + 13]);
135     assertEquals("line 14", ILineCoverage.FULLY_COVERED, c[lines.getOffset() + 14]);
136   }
137
138   /* Line A B C Coverage
139    * 10 + +
140    * 11 + + +
141    * 12 + + - ?
142    * 13 + - ?
143    * 14 - -
144    */
145   public void testScenario2() {
146     lines.addLines(new int[] {10, 11, 12}, true);
147     lines.addLines(new int[] {11, 12, 13}, true);
148     lines.addLines(new int[] {12, 13, 14}, false);
149     assertEquals("total", 5, lines.getTotalCount());
150     assertEquals("covered", 4, lines.getCoveredCount());
151     byte[] c = lines.getCoverage();
152     assertEquals("line 10", ILineCoverage.FULLY_COVERED, c[lines.getOffset() + 10]);
153     assertEquals("line 11", ILineCoverage.FULLY_COVERED, c[lines.getOffset() + 11]);
154     assertEquals("line 12", ILineCoverage.PARTLY_COVERED, c[lines.getOffset() + 12]);
155     assertEquals("line 13", ILineCoverage.PARTLY_COVERED, c[lines.getOffset() + 13]);
156     assertEquals("line 14", ILineCoverage.NOT_COVERED, c[lines.getOffset() + 14]);
157   }
158   
159   /* Line A B C Coverage
160    * 10 - -
161    * 11 - + ?
162    * 12 - + - ?
163    * 13 + - ?
164    * 14 - -
165    */
166   public void testScenario3() {
167     lines.addLines(new int[] {10, 11, 12}, false);
168     lines.addLines(new int[] {11, 12, 13}, true);
169     lines.addLines(new int[] {12, 13, 14}, false);
170     assertEquals("total", 5, lines.getTotalCount());
171     assertEquals("covered", 3, lines.getCoveredCount());
172     byte[] c = lines.getCoverage();
173     assertEquals("line 10", ILineCoverage.NOT_COVERED, c[lines.getOffset() + 10]);
174     assertEquals("line 11", ILineCoverage.PARTLY_COVERED, c[lines.getOffset() + 11]);
175     assertEquals("line 12", ILineCoverage.PARTLY_COVERED, c[lines.getOffset() + 12]);
176     assertEquals("line 13", ILineCoverage.PARTLY_COVERED, c[lines.getOffset() + 13]);
177     assertEquals("line 14", ILineCoverage.NOT_COVERED, c[lines.getOffset() + 14]);
178   }
179   
180   public void testIncrement() {
181     try {
182       lines.increment(2, 1);
183       fail("Must not work.");
184     } catch (UnsupportedOperationException JavaDoc ex) { }
185     
186   }
187   
188 }
189
Popular Tags