001: /*
002: * Cobertura - http://cobertura.sourceforge.net/
003: *
004: * Copyright (C) 2005 Grzegorz Lukasik
005: * Copyright (C) 2006 Jiri Mares
006: *
007: * Cobertura is free software; you can redistribute it and/or modify
008: * it under the terms of the GNU General Public License as published
009: * by the Free Software Foundation; either version 2 of the License,
010: * or (at your option) any later version.
011: *
012: * Cobertura is distributed in the hope that it will be useful, but
013: * WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015: * General Public License for more details.
016: *
017: * You should have received a copy of the GNU General Public License
018: * along with Cobertura; if not, write to the Free Software
019: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
020: * USA
021: */
022: package net.sourceforge.cobertura.merge;
023:
024: import java.util.Collection;
025: import java.util.HashSet;
026: import java.util.Iterator;
027: import java.util.Set;
028:
029: import junit.framework.TestCase;
030: import net.sourceforge.cobertura.coveragedata.ClassData;
031: import net.sourceforge.cobertura.coveragedata.LineData;
032: import net.sourceforge.cobertura.coveragedata.PackageData;
033: import net.sourceforge.cobertura.coveragedata.ProjectData;
034: import net.sourceforge.cobertura.coveragedata.SourceFileData;
035:
036: /**
037: * Tests merge feature by calling directly ProjectData.merge method.
038: */
039: public class MergeTest extends TestCase {
040: private ClassData firstClass = new ClassData("test.First");
041: private ClassData secondClass = new ClassData("test.Second");
042: private ClassData thirdClass = new ClassData("test.Third");
043: private ClassData firstClassB = new ClassData("test.First");
044: private ClassData fourthClass = new ClassData("test.me.Fourth");
045: private ClassData fifthClass = new ClassData("beautiful.Fourth");
046: private ClassData sixthClass = new ClassData("Fourth");
047: private ClassData seventhClass = new ClassData("Seventh");
048:
049: private ProjectData greenProject = new ProjectData();
050: private ProjectData redProject = new ProjectData();
051:
052: public void testMergePackages() {
053: greenProject.addClassData(firstClass);
054: greenProject.addClassData(fourthClass);
055: redProject.addClassData(fifthClass);
056: redProject.addClassData(sixthClass);
057: redProject.addClassData(seventhClass);
058:
059: greenProject.merge(redProject);
060:
061: Iterator subpackages = greenProject.getSubPackages("")
062: .iterator();
063: assertEquals("", ((PackageData) subpackages.next()).getName());
064: assertEquals("beautiful", ((PackageData) subpackages.next())
065: .getName());
066: assertEquals("test", ((PackageData) subpackages.next())
067: .getName());
068: assertEquals("test.me", ((PackageData) subpackages.next())
069: .getName());
070: assertFalse(subpackages.hasNext());
071:
072: assertEquals(5, greenProject.getClasses().size());
073: assertEquals(3, redProject.getClasses().size());
074:
075: assertNotNull(greenProject.getClassData("test.First"));
076: assertNotNull(greenProject.getClassData("test.me.Fourth"));
077: assertNotNull(greenProject.getClassData("beautiful.Fourth"));
078: assertNotNull(greenProject.getClassData("Fourth"));
079: assertNotNull(greenProject.getClassData("Seventh"));
080: assertNull(redProject.getClassData("test.First"));
081:
082: Iterator packages = greenProject.getPackages().iterator();
083:
084: PackageData first = (PackageData) packages.next();
085: assertEquals("", first.getName());
086: assertEquals(2, first.getNumberOfChildren());
087: assertNotNull(first.getChild("Fourth"));
088: assertNotNull(first.getChild("Seventh"));
089:
090: PackageData beautiful = (PackageData) packages.next();
091: assertEquals("beautiful", beautiful.getName());
092: assertEquals(1, beautiful.getNumberOfChildren());
093: assertNotNull(beautiful.getChild("Fourth"));
094:
095: PackageData test = (PackageData) packages.next();
096: assertEquals("test", test.getName());
097: assertEquals(1, test.getNumberOfChildren());
098: assertNotNull(test.getChild("First"));
099: assertNull(test.getChild("test/me/First.java"));
100: assertNull(test.getChild("Fourth.java"));
101:
102: PackageData testMe = (PackageData) packages.next();
103: assertEquals("test.me", testMe.getName());
104: assertEquals(1, testMe.getNumberOfChildren());
105: assertNull(testMe.getChild("test/First.java"));
106: assertNotNull(testMe.getChild("Fourth"));
107: assertNull(testMe.getChild("Fourth.java"));
108:
109: assertFalse(packages.hasNext());
110: }
111:
112: public void testMergeDifferentClassData() {
113: greenProject.addClassData(firstClass);
114:
115: redProject.addClassData(secondClass);
116: redProject.addClassData(thirdClass);
117:
118: greenProject.merge(redProject);
119:
120: assertEquals(1, greenProject.getNumberOfChildren());
121: assertEquals(3, greenProject.getClasses().size());
122:
123: assertNotNull(greenProject.getClassData("test.First"));
124: assertNotNull(greenProject.getClassData("test.Second"));
125: assertNotNull(greenProject.getClassData("test.Third"));
126:
127: assertNull(redProject.getClassData("test.First"));
128: assertNotNull(redProject.getClassData("test.Second"));
129: assertNotNull(redProject.getClassData("test.Third"));
130: }
131:
132: public void testMergeSimillarClassData() {
133: greenProject.addClassData(secondClass);
134: greenProject.addClassData(thirdClass);
135:
136: redProject.addClassData(firstClass);
137: redProject.addClassData(thirdClass);
138:
139: greenProject.merge(redProject);
140:
141: assertEquals(1, greenProject.getNumberOfChildren());
142: assertEquals(3, greenProject.getClasses().size());
143:
144: assertNotNull(greenProject.getClassData("test.First"));
145: assertNotNull(greenProject.getClassData("test.Second"));
146: assertNotNull(greenProject.getClassData("test.Third"));
147:
148: assertNotNull(redProject.getClassData("test.First"));
149: assertNull(redProject.getClassData("test.Second"));
150: assertNotNull(redProject.getClassData("test.Third"));
151: }
152:
153: public void testMergeDifferentLineNumbers() {
154: firstClass.addLine(2, "helloWorld", "()V");
155: firstClass.addLine(3, "helloWorld", "()V");
156: greenProject.addClassData(firstClass);
157:
158: firstClassB.addLine(1, "helloWorld", "()V");
159: firstClassB.addLine(5, "helloWorld", "()V");
160: redProject.addClassData(firstClassB);
161:
162: greenProject.merge(redProject);
163:
164: ClassData cd = greenProject.getClassData("test.First");
165: assertNotNull(cd);
166: assertEquals(4, cd.getNumberOfValidLines());
167: assertEquals(2, redProject.getClassData("test.First")
168: .getNumberOfValidLines());
169:
170: Iterator lines = cd.getLines().iterator();
171: LineData line1 = (LineData) lines.next();
172: assertEquals(1, line1.getLineNumber());
173: LineData line2 = (LineData) lines.next();
174: assertEquals(2, line2.getLineNumber());
175: LineData line3 = (LineData) lines.next();
176: assertEquals(3, line3.getLineNumber());
177: LineData line5 = (LineData) lines.next();
178: assertEquals(5, line5.getLineNumber());
179: assertFalse(lines.hasNext());
180: }
181:
182: public void testMergeSimillarLineNumbers() {
183: firstClass.addLine(2, "helloWorld", "()V");
184: firstClass.touch(2);
185: firstClass.touch(2);
186: firstClass.addLine(3, "helloWorld", "()V");
187: greenProject.addClassData(firstClass);
188:
189: firstClassB.addLine(2, "helloWorld", "()V");
190: firstClassB.touch(2);
191: firstClassB.touch(2);
192: firstClassB.touch(2);
193: firstClassB.addLine(3, "helloWorld", "()V");
194: firstClassB.touch(3);
195: firstClassB.addLine(7, "helloWorld", "()V");
196: redProject.addClassData(firstClassB);
197:
198: greenProject.merge(redProject);
199:
200: ClassData cd = greenProject.getClassData("test.First");
201: assertNotNull(cd);
202: assertEquals(3, cd.getNumberOfValidLines());
203: assertEquals(3, redProject.getClassData("test.First")
204: .getNumberOfValidLines());
205:
206: Iterator lines = cd.getLines().iterator();
207: LineData line2 = (LineData) lines.next();
208: assertEquals(2, line2.getLineNumber());
209: assertEquals(5, line2.getHits());
210: LineData line3 = (LineData) lines.next();
211: assertEquals(3, line3.getLineNumber());
212: assertEquals(1, line3.getHits());
213: LineData line7 = (LineData) lines.next();
214: assertEquals(7, line7.getLineNumber());
215: assertEquals(0, line7.getHits());
216: assertFalse(lines.hasNext());
217: }
218:
219: public void testMergeBranches() {
220: firstClass.addLine(1, "helloWorld", "()V");
221: firstClass.addLineJump(1, 0);
222: firstClass.addLine(2, "helloWorld", "()V");
223: firstClass.addLineJump(2, 0);
224: firstClass.addLineJump(2, 1);
225: firstClass.addLine(3, "helloWorld", "()V");
226: firstClass.addLine(4, "helloWorld", "()V");
227: firstClass.addLineSwitch(4, 0, 0, 2);
228: firstClass.addLine(5, "helloWorld", "()V");
229: firstClass.addLine(8, "helloWorld", "()V");
230: greenProject.addClassData(firstClass);
231:
232: firstClassB.addLine(1, "helloWorld", "()V");
233: firstClassB.addLineJump(1, 0);
234: firstClassB.addLine(2, "helloWorld", "()V");
235: firstClassB.addLine(3, "helloWorld", "()V");
236: firstClassB.addLineSwitch(3, 0, 2, 4);
237: firstClassB.addLine(6, "helloWorld", "()V");
238: firstClassB.addLineJump(6, 0);
239: firstClassB.addLine(7, "helloWorld", "()V");
240: firstClassB.addLine(8, "helloWorld", "()V");
241: redProject.addClassData(firstClassB);
242:
243: greenProject.merge(redProject);
244:
245: ClassData cd = greenProject.getClassData("test.First");
246:
247: Iterator lines = cd.getLines().iterator();
248:
249: LineData line1 = (LineData) lines.next();
250: assertTrue(line1.hasBranch());
251: LineData line2 = (LineData) lines.next();
252: assertTrue(line2.hasBranch());
253: LineData line3 = (LineData) lines.next();
254: assertTrue(line3.hasBranch());
255: LineData line4 = (LineData) lines.next();
256: assertTrue(line4.hasBranch());
257: LineData line5 = (LineData) lines.next();
258: assertFalse(line5.hasBranch());
259: LineData line6 = (LineData) lines.next();
260: assertTrue(line6.hasBranch());
261: LineData line7 = (LineData) lines.next();
262: assertFalse(line7.hasBranch());
263: LineData line8 = (LineData) lines.next();
264: assertFalse(line8.hasBranch());
265: assertFalse(lines.hasNext());
266: }
267:
268: public void testMergeSourceFiles() {
269: greenProject.addClassData(secondClass);
270: greenProject.addClassData(fourthClass);
271:
272: redProject.addClassData(firstClass);
273: redProject.addClassData(fifthClass);
274: redProject.addClassData(seventhClass);
275:
276: greenProject.merge(redProject);
277:
278: Collection sources = greenProject.getSourceFiles();
279: assertEquals(5, sources.size());
280:
281: Set sourceNames = new HashSet();
282: Iterator it = sources.iterator();
283: while (it.hasNext())
284: sourceNames.add(((SourceFileData) it.next()).getName());
285:
286: assertTrue(sourceNames.contains("test/First.java"));
287: assertTrue(sourceNames.contains("test/Second.java"));
288: assertTrue(sourceNames.contains("test/me/Fourth.java"));
289: assertTrue(sourceNames.contains("beautiful/Fourth.java"));
290: assertTrue(sourceNames.contains("Seventh.java"));
291: }
292: }
|