001    /*
002     * Cobertura - http://cobertura.sourceforge.net/
003     *
004     * Copyright (C) 2005 Mark Doliner <thekingant@users.sourceforge.net>
005     *
006     * Cobertura is free software; you can redistribute it and/or modify
007     * it under the terms of the GNU General Public License as published
008     * by the Free Software Foundation; either version 2 of the License,
009     * or (at your option) any later version.
010     *
011     * Cobertura is distributed in the hope that it will be useful, but
012     * WITHOUT ANY WARRANTY; without even the implied warranty of
013     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014     * General Public License for more details.
015     *
016     * You should have received a copy of the GNU General Public License
017     * along with Cobertura; if not, write to the Free Software
018     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
019     * USA
020     */
021    
022    package net.sourceforge.cobertura.reporting;
023    
024    import java.util.Iterator;
025    import java.util.Map;
026    import java.util.Set;
027    import java.util.TreeMap;
028    import java.util.TreeSet;
029    
030    import net.sourceforge.cobertura.coverage.CoverageData;
031    
032    public class CoverageReport
033    {
034    
035            private Map packages;
036    
037            public CoverageReport(Map coverageData) {
038                    packages = new TreeMap();
039    
040                    Iterator iter = coverageData.entrySet().iterator();
041                    while (iter.hasNext())
042                    {
043                            Map.Entry entry = (Map.Entry)iter.next();
044                            String classname = (String)entry.getKey();
045                            CoverageData instrumentation = (CoverageData)entry.getValue();
046                            addClass(new Clazz(classname, instrumentation));
047                    }
048            }
049    
050            public void addClass(Clazz clazz)
051            {
052                    String packageName = clazz.getPackageName();
053                    Package pkg = (Package)packages.get(packageName);
054                    if (pkg == null)
055                    {
056                            pkg = new Package(packageName);
057                            packages.put(packageName, pkg);
058                    }
059                    pkg.addClass(clazz);
060            }
061    
062            public double getBranchCoverageRate()
063            {
064                    long numberOfBranches = getNumberOfBranches();
065                    if (numberOfBranches == 0)
066                    {
067                            if (getNumberOfCoveredLines() == 0)
068                                    return 0;
069                            return 1;
070                    }
071                    return (double)getNumberOfCoveredBranches()
072                                    / (double)numberOfBranches;
073            }
074    
075            public Set getClasses()
076            {
077                    Set ret = new TreeSet();
078    
079                    Iterator iter = packages.values().iterator();
080                    while (iter.hasNext())
081                    {
082                            Package pkg = (Package)iter.next();
083                            ret.addAll(pkg.getClasses());
084                    }
085    
086                    return ret;
087            }
088    
089            public double getLineCoverageRate()
090            {
091                    long numberOfLines = getNumberOfLines();
092                    if (numberOfLines == 0)
093                    {
094                            return 1;
095                    }
096                    return (double)getNumberOfCoveredLines() / (double)numberOfLines;
097            }
098    
099            public long getNumberOfBranches()
100            {
101                    long numberOfBranches = 0;
102    
103                    Iterator iter = packages.values().iterator();
104                    while (iter.hasNext())
105                    {
106                            Package pkg = (Package)iter.next();
107                            numberOfBranches += pkg.getNumberOfBranches();
108                    }
109    
110                    return numberOfBranches;
111            }
112    
113            public int getNumberOfClasses()
114            {
115                    int numberOfClasses = 0;
116    
117                    Iterator iter = packages.values().iterator();
118                    while (iter.hasNext())
119                    {
120                            Package pkg = (Package)iter.next();
121                            numberOfClasses += pkg.getClasses().size();
122                    }
123    
124                    return numberOfClasses;
125            }
126    
127            public long getNumberOfCoveredBranches()
128            {
129                    long numberOfCoveredBranches = 0;
130    
131                    Iterator iter = packages.values().iterator();
132                    while (iter.hasNext())
133                    {
134                            Package pkg = (Package)iter.next();
135                            numberOfCoveredBranches += pkg.getNumberOfCoveredBranches();
136                    }
137    
138                    return numberOfCoveredBranches;
139            }
140    
141            public long getNumberOfCoveredLines()
142            {
143                    long numberOfCoveredLines = 0;
144    
145                    Iterator iter = packages.values().iterator();
146                    while (iter.hasNext())
147                    {
148                            Package pkg = (Package)iter.next();
149                            numberOfCoveredLines += pkg.getNumberOfCoveredLines();
150                    }
151    
152                    return numberOfCoveredLines;
153            }
154    
155            public long getNumberOfLines()
156            {
157                    long numberOfLines = 0;
158    
159                    Iterator iter = packages.values().iterator();
160                    while (iter.hasNext())
161                    {
162                            Package pkg = (Package)iter.next();
163                            numberOfLines += pkg.getNumberOfLines();
164                    }
165    
166                    return numberOfLines;
167            }
168    
169            public Set getPackages()
170            {
171                    return new TreeSet(packages.values());
172            }
173    
174            public Set getSubPackages(Package pkg)
175            {
176                    Set ret = new TreeSet();
177    
178                    Iterator iter = packages.values().iterator();
179                    while (iter.hasNext())
180                    {
181                            Package nextPkg = (Package)iter.next();
182                            if (nextPkg.getName().startsWith(pkg.getName())
183                                            && !nextPkg.getName().equals(pkg.getName()))
184                            {
185                                    ret.add(nextPkg);
186                            }
187                    }
188    
189                    return ret;
190            }
191    
192            public void removeClass(Clazz clazz)
193            {
194                    String packageName = clazz.getPackageName();
195                    Package pkg = (Package)packages.get(packageName);
196                    pkg.removeClass(clazz);
197                    if (pkg.getClasses().size() == 0)
198                    {
199                            packages.remove(packageName);
200                    }
201            }
202    
203    }