| Element Type | Name | Package | Documentable Members | Undocumented | Documented | Documented Percent | 19 |
|---|---|---|---|---|---|---|
| Classes/Interfaces/Enums | 9 | 1 | 8 | 88.89% | 24 |||
| Interface | Interface2 | com.manoelcampos.sample2 | 22 | 7 | 15 | 68.18% | 27 |
| Fields | 2 | 1 | 1 | 50.00% | 30 |||
| Method | method1 | 7 | 3 | 4 | 57.14% | 33 ||
| Params | 2 | 1 | 1 | 50.00% | 36 |||
| Exceptions | 3 | 1 | 2 | 66.67% | 39 |||
| Method | method2 | 6 | 3 | 3 | 50.00% | 42 ||
| Params | 1 | 1 | 0 | 0.00% | 45 |||
| Exceptions | 3 | 1 | 2 | 66.67% | 48 |||
| Method | method3 | 6 | 3 | 3 | 50.00% | 51 ||
| Params | 1 | 1 | 0 | 0.00% | 54 |||
| Exceptions | 3 | 1 | 2 | 66.67% | 57 |||
| Interface | Interface1 | com.manoelcampos.sample2 | 49 | 15 | 34 | 69.39% | 60 |
| Fields | 1 | 0 | 1 | 100.00% | 63 |||
| Method | square | 3 | 0 | 3 | 100.00% | 66 ||
| Params | 1 | 0 | 1 | 100.00% | 69 |||
| Method | sum | 2 | 1 | 1 | 50.00% | 72 ||
| Method | equation | 5 | 3 | 2 | 40.00% | 75 ||
| Params | 1 | 1 | 0 | 0.00% | 78 |||
| Exceptions | 2 | 1 | 1 | 50.00% | 81 |||
| Method | divide | 5 | 3 | 2 | 40.00% | 84 ||
| Params | 2 | 2 | 0 | 0.00% | 87 |||
| Exceptions | 1 | 0 | 1 | 100.00% | 90 |||
| Method | equation | 7 | 5 | 2 | 28.57% | 93 ||
| Params | 2 | 2 | 0 | 0.00% | 96 |||
| Exceptions | 3 | 2 | 1 | 33.33% | 99 |||
| Method | someMethod1 | 7 | 3 | 4 | 57.14% | 102 ||
| Params | 2 | 1 | 1 | 50.00% | 105 |||
| Exceptions | 3 | 1 | 2 | 66.67% | 108 |||
| Method | someMethod2 | 6 | 3 | 3 | 50.00% | 111 ||
| Params | 1 | 1 | 0 | 0.00% | 114 |||
| Exceptions | 3 | 1 | 2 | 66.67% | 117 |||
| Method | someMethod3 | 6 | 3 | 3 | 50.00% | 120 ||
| Params | 1 | 1 | 0 | 0.00% | 123 |||
| Exceptions | 3 | 1 | 2 | 66.67% | 126 |||
| Method | someMethod4 | 6 | 3 | 3 | 50.00% | 129 ||
| Params | 1 | 1 | 0 | 0.00% | 132 |||
| Exceptions | 3 | 1 | 2 | 66.67% | 135 |||
| Class | SubClass1 | com.manoelcampos.sample1 | 8 | 2 | 6 | 75.00% | 138 |
| Constructor | SubClass1 | 1 | 1 | 0 | 0.00% | 141 ||
| Method | getField1 | 2 | 0 | 2 | 100.00% | 144 ||
| Method | getField2 | 2 | 1 | 1 | 50.00% | 147 ||
| Method | getField3 | 2 | 1 | 1 | 50.00% | 150 ||
| Class | Class2 | com.manoelcampos.sample1 | 2 | 1 | 1 | 50.00% | 153 |
| Constructor | Class2 | 1 | 1 | 0 | 0.00% | 156 ||
| Class | UndocumentedClass1 | com.manoelcampos.sample1 | 8 | 3 | 5 | 62.50% | 159 |
| Fields | 1 | 1 | 0 | 0.00% | 162 |||
| Constructor | UndocumentedClass1 | 1 | 1 | 0 | 0.00% | 165 ||
| Method | getField1 | 2 | 0 | 2 | 100.00% | 168 ||
| Method | setField1 | 3 | 0 | 3 | 100.00% | 171 ||
| Params | 1 | 1 | 0 | 0.00% | 174 |||
| Class | Class1 | com.manoelcampos.sample1 | 22 | 5 | 17 | 77.27% | 177 |
| Fields | 3 | 2 | 1 | 33.33% | 180 |||
| Constructor | Class1 | 1 | 1 | 0 | 0.00% | 183 ||
| Constructor | Class1 | 3 | 1 | 2 | 66.67% | 186 ||
| Params | 1 | 1 | 0 | 0.00% | 189 |||
| Exceptions | 1 | 0 | 1 | 100.00% | 192 |||
| Constructor | Class1 | 4 | 1 | 3 | 75.00% | 195 ||
| Params | 3 | 1 | 2 | 66.67% | 198 |||
| Method | getField1 | 2 | 1 | 1 | 50.00% | 201 ||
| Method | setField1 | 4 | 4 | 0 | 0.00% | 204 ||
| Params | 1 | 1 | 0 | 0.00% | 207 |||
| Exceptions | 1 | 1 | 0 | 0.00% | 210 |||
| Method | getField2 | 2 | 0 | 2 | 100.00% | 213 ||
| Method | getField3 | 2 | 0 | 2 | 100.00% | 216 ||
| Enum | Class1.Continent | com.manoelcampos.sample1 | 12 | 9 | 3 | 25.00% | 219 |
| Constructor | Continent | 1 | 1 | 0 | 0.00% | 222 ||
| Method | values | 2 | 2 | 0 | 0.00% | 225 ||
| Method | valueOf | 3 | 3 | 0 | 0.00% | 228 ||
| Params | 1 | 1 | 0 | 0.00% | 231 |||
| Class | Class1.InnerClass1 | com.manoelcampos.sample1 | 4 | 1 | 3 | 75.00% | 234 |
| Constructor | InnerClass1 | 1 | 1 | 0 | 0.00% | 237 ||
| Method | getValue | 2 | 1 | 1 | 50.00% | 240 ||
| Class | SubClass2 | com.manoelcampos.sample1 | 2 | 1 | 1 | 50.00% | 243 |
| Constructor | SubClass2 | 1 | 1 | 0 | 0.00% | 246 ||
| Packages | 2 | 1 | 1 | 50.00% | 249 |||
| Package | com.manoelcampos.sample2 | true | 100.00% | 253 ||||
| Package | com.manoelcampos.sample1 | false | 0.00% | 257 ||||
| Project Documentation Coverage | 69.44% | 259 |
References: 35 | *
WARNING: This method is not useful to check if a {@code @param}, {@code @return} or {@code @throws} tag 43 | * for a method is documented or not.
44 | * 45 | * @param javadoc the complete JavaDoc for an element. 46 | * @return 47 | */ 48 | public static boolean isElementDocumented(final String javadoc) { 49 | /* 50 | * Try to get the text before the first @. This text represents 51 | * the documentation for the element (such as a method). 52 | * The first @ represents the beginning of the first tag (such as a @param tag). 53 | */ 54 | final Matcher matcher = Pattern.compile("^([^@]+)").matcher(javadoc); 55 | return matcher.find() && isNotStringEmpty(matcher.group(0)); 56 | 57 | } 58 | 59 | public static boolean isNotStringEmpty(final String str) { 60 | return !isStringEmpty(str); 61 | } 62 | 63 | public static boolean isStringEmpty(final String str) { 64 | return str == null || str.trim().isEmpty(); 65 | } 66 | 67 | /** 68 | * Adds a trailing slash at the end of a path if it doesn't have one yet. 69 | * The trailing slash type is system-dependent and will be accordingly selected. 70 | * 71 | * @param path the path to include a trailing slash 72 | * @return the path with a trailing slash if there wasn't one and the path is not empty, 73 | * the original path otherwise 74 | */ 75 | public static String includeTrailingDirSeparator(final String path) { 76 | if (path.trim().isEmpty()) { 77 | return path; 78 | } 79 | 80 | if (path.charAt(path.length() - 1) != File.separatorChar) { 81 | return path + File.separator; 82 | } 83 | 84 | return path; 85 | } 86 | 87 | /** 88 | * Computes the percentage that a partial value corresponds to a given total. 89 | * 90 | * @param partialValue the partial value to compute the percentage related to the total value 91 | * @param totalValue the total the partial value corresponds to 92 | * @return the percentage (in scale from 0 to 100) the partial value represents from the total 93 | */ 94 | public static double computePercentage(final double partialValue, final double totalValue){ 95 | if(totalValue == 0){ 96 | return 0; 97 | } 98 | 99 | return (partialValue/totalValue) * 100.0; 100 | 101 | } 102 | 103 | /** 104 | * Computes the mean value from an array. 105 | * 106 | * @param values the values to compute the mean from 107 | * @return the computed mean 108 | */ 109 | public static double mean(final double... values){ 110 | if(values == null){ 111 | return 0; 112 | } 113 | 114 | return mean(Arrays.stream(values)); 115 | } 116 | 117 | /** 118 | * Computes the mean value from a Stream of values. 119 | * 120 | * @param stream the Stream of values to compute the mean from 121 | * @return the computed mean 122 | */ 123 | private static double mean(final DoubleStream stream) { 124 | return stream.average().orElse(0); 125 | } 126 | 127 | /** 128 | * Converts a boolean to its corresponding int 129 | * 130 | * @param bool the boolean value to convert 131 | * @return 1 whether the bool is equal to true; 0 otherwise 132 | */ 133 | public static int boolToInt(final boolean bool) { 134 | return bool ? 1 : 0; 135 | } 136 | 137 | /** 138 | * Gets the extension of a file. 139 | * 140 | * @param fileName the name of the file 141 | * @return the file extension, including the dot, or an empty string 142 | * if there isn't a extension 143 | */ 144 | public static String getFileExtension(final String fileName) { 145 | final int i = fileName.lastIndexOf('.'); 146 | return i > 0 ? fileName.substring(i) : ""; 147 | } 148 | } 149 | -------------------------------------------------------------------------------- /src/main/java/com/manoelcampos/javadoc/coverage/exporter/AbstractDataExporter.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2017-2017 Manoel Campos da Silva Filho 3 | * 4 | * Licensed under the General Public License Version 3 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * https://www.gnu.org/licenses/gpl-3.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package com.manoelcampos.javadoc.coverage.exporter; 17 | 18 | import com.manoelcampos.javadoc.coverage.CoverageDoclet; 19 | import com.manoelcampos.javadoc.coverage.Utils; 20 | import com.manoelcampos.javadoc.coverage.stats.JavaDocsStats; 21 | 22 | import java.io.File; 23 | import java.io.FileNotFoundException; 24 | import java.io.PrintWriter; 25 | 26 | /** 27 | * Abstract class to implement JavaDoc Coverage reports in different formats. 28 | * Each sub-class should implement a specific format such as HTML, CSV, JSON, etc. 29 | * 30 | * @author Manoel Campos da Silva Filho 31 | * @since 1.0.0 32 | */ 33 | public abstract class AbstractDataExporter implements DataExporter { 34 | private final JavaDocsStats stats; 35 | private final PrintWriter writer; 36 | private File file; 37 | private final CoverageDoclet doclet; 38 | private final String reportFileName; 39 | 40 | /** 41 | * Instantiates a DataExporter object to generate JavaDoc coverage report. 42 | * 43 | * @param doclet the {@link CoverageDoclet} which computes teh JavaDoc coverage statistics. 44 | * @param fileExtension the extension to the report file. If empty, the report will be printed to the standard output. 45 | */ 46 | protected AbstractDataExporter(final CoverageDoclet doclet, final String fileExtension) { 47 | this.doclet = doclet; 48 | 49 | if (Utils.isStringEmpty(fileExtension)) { 50 | writer = new PrintWriter(System.out); 51 | this.reportFileName = ""; 52 | } else { 53 | this.reportFileName = generateReportFileName(fileExtension); 54 | try { 55 | this.writer = doclet.getWriter(file); 56 | } catch (FileNotFoundException e) { 57 | throw new RuntimeException(e); 58 | } 59 | } 60 | 61 | this.stats = new JavaDocsStats(doclet.getRootDoc()); 62 | } 63 | 64 | /** 65 | * Instantiates a DataExporter object that generates JavaDoc coverage report to the standard output. 66 | * 67 | * @param doclet the {@link CoverageDoclet} which computes teh JavaDoc coverage statistics. 68 | */ 69 | protected AbstractDataExporter(final CoverageDoclet doclet) { 70 | this(doclet, ""); 71 | } 72 | 73 | private String generateReportFileName(final String fileExtension) { 74 | String fileName = getFileNameFromCommandLine(); 75 | fileName = fileName + fileExtensionToAdd(fileName, fileExtension); 76 | this.file = doclet.getOutputFile(fileName); 77 | return fileName; 78 | } 79 | 80 | /** 81 | * Gets the JavaDoc Coverage Report file name from command line options 82 | * or the default name if no option is given. 83 | * 84 | * @return 85 | * @see CoverageDoclet#OUTPUT_NAME_OPTION 86 | */ 87 | private String getFileNameFromCommandLine() { 88 | final String[] outputNameOption = doclet.getOptionValues(CoverageDoclet.OUTPUT_NAME_OPTION); 89 | return outputNameOption.length > 1 ? outputNameOption[1] : DEFAULT_OUTPUT_NAME; 90 | } 91 | 92 | /** 93 | * Gets the extension to add to a given file if it doesn't have one. 94 | * 95 | * @param fileName the file name to try getting and extension to add 96 | * @param defaultFileExtension the default file extension to return if the file doesn't have one 97 | * @return the file extension to add to the file it it doesn't have one or an empty string 98 | * if it already has. 99 | */ 100 | private String fileExtensionToAdd(final String fileName, final String defaultFileExtension) { 101 | return Utils.getFileExtension(fileName).isEmpty() ? 102 | getFileExtensionStartingWithDot(defaultFileExtension) : ""; 103 | } 104 | 105 | /** 106 | * Adds a dot to the beginning of a file extension if it doesn't have one. 107 | * 108 | * @param fileExtension the file extension 109 | * @return the validated file extension 110 | */ 111 | private String getFileExtensionStartingWithDot(String fileExtension) { 112 | return fileExtension.startsWith(".") ? fileExtension : "." + fileExtension; 113 | } 114 | 115 | @Override 116 | public String getReportFileName() { 117 | return this.reportFileName; 118 | } 119 | 120 | @Override 121 | public boolean build() { 122 | try { 123 | header(); 124 | exportClassesDocStats(); 125 | exportPackagesDocStats(); 126 | exportProjectDocumentationCoverageSummary(); 127 | footer(); 128 | afterBuild(); 129 | getWriter().flush(); 130 | return true; 131 | } finally { 132 | getWriter().close(); 133 | } 134 | } 135 | 136 | protected PrintWriter getWriter() { 137 | return writer; 138 | } 139 | 140 | protected JavaDocsStats getStats() { 141 | return stats; 142 | } 143 | 144 | public File getFile() { 145 | return file; 146 | } 147 | 148 | protected abstract void exportProjectDocumentationCoverageSummary(); 149 | 150 | protected abstract void header(); 151 | 152 | protected abstract void footer(); 153 | 154 | protected abstract void afterBuild(); 155 | 156 | protected abstract void exportPackagesDocStats(); 157 | 158 | protected abstract void exportClassesDocStats(); 159 | } 160 | -------------------------------------------------------------------------------- /src/main/java/com/manoelcampos/javadoc/coverage/exporter/ConsoleExporter.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2017-2017 Manoel Campos da Silva Filho 3 | * 4 | * Licensed under the General Public License Version 3 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * https://www.gnu.org/licenses/gpl-3.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package com.manoelcampos.javadoc.coverage.exporter; 17 | 18 | import com.manoelcampos.javadoc.coverage.CoverageDoclet; 19 | import com.manoelcampos.javadoc.coverage.Utils; 20 | import com.manoelcampos.javadoc.coverage.stats.*; 21 | import com.sun.javadoc.PackageDoc; 22 | 23 | import java.io.PrintWriter; 24 | import java.util.List; 25 | 26 | /** 27 | * Prints the JavaDoc coverage report to the console (standard output). 28 | * 29 | * @author Manoel Campos da Silva Filho 30 | * @since 1.0.0 31 | */ 32 | public class ConsoleExporter extends AbstractDataExporter { 33 | 34 | public ConsoleExporter(final CoverageDoclet doclet) { 35 | super(doclet); 36 | } 37 | 38 | @Override 39 | protected void header() {/**/} 40 | 41 | @Override 42 | protected void footer() {/**/} 43 | 44 | @Override 45 | public void afterBuild() {/**/} 46 | 47 | @Override 48 | protected void exportProjectDocumentationCoverageSummary() { 49 | getWriter().printf("Project Documentation Coverage: %.2f%%\n\n", getStats().getDocumentedMembersPercent()); 50 | } 51 | 52 | @Override 53 | protected void exportPackagesDocStats() { 54 | final PackagesDocStats packagesDocStats = getStats().getPackagesDocStats(); 55 | exportPkgsOrClassesDocStats(packagesDocStats); 56 | packagesDocStats.getPackagesDoc().forEach(this::exportPackageDocStats); 57 | getWriter().println(); 58 | } 59 | 60 | private void exportPkgsOrClassesDocStats(MembersDocStats packagesDocStats) { 61 | getWriter().printf("%-26s: \t%11d Undocumented: %6d Documented: %6d (%.2f%%)\n", 62 | packagesDocStats.getType(), packagesDocStats.getMembersNumber(), packagesDocStats.getUndocumentedMembers(), 63 | packagesDocStats.getDocumentedMembers(), packagesDocStats.getDocumentedMembersPercent()); 64 | } 65 | 66 | /** 67 | * Exports the statistics about JavaDoc coverage of a given package. 68 | * @param doc the object containing the JavaDoc coverage data 69 | * 70 | */ 71 | private void exportPackageDocStats(final PackageDoc doc) { 72 | getWriter().printf("\tPackage %s. Documented: %s\n", doc.name(), Utils.isNotStringEmpty(doc.commentText())); 73 | } 74 | 75 | @Override 76 | protected void exportClassesDocStats() { 77 | final ClassesDocStats classesDocStats = getStats().getClassesDocStats(); 78 | exportPkgsOrClassesDocStats(classesDocStats); 79 | 80 | for (final ClassDocStats classStats : getStats().getClassesDocStats().getClassesList()) { 81 | exportClassDocStats(classStats); 82 | } 83 | getWriter().println(); 84 | } 85 | 86 | /** 87 | * Exports the statistics about JavaDoc coverage of a given class. 88 | * @param classStats the object containing the JavaDoc coverage data 89 | * 90 | */ 91 | private void exportClassDocStats(final ClassDocStats classStats) { 92 | getWriter().printf("\t%s: %s Package: %s Documented: %s (%.2f%%)\n", 93 | classStats.getType(), classStats.getName(), classStats.getPackageName(), 94 | classStats.isDocumented(), classStats.getDocumentedMembersPercent()); 95 | 96 | exportMembersDocStats(getWriter(), classStats.getFieldsStats()); 97 | exportMethodsDocStats(getWriter(), classStats.getConstructorsStats()); 98 | exportMethodsDocStats(getWriter(), classStats.getMethodsStats()); 99 | exportMembersDocStats(getWriter(), classStats.getEnumsStats()); 100 | getWriter().flush(); 101 | } 102 | 103 | private void exportMethodsDocStats(final PrintWriter writer, final List| Element Type | Name | Package | Documentable Members | Undocumented | Documented | Documented Percent | "); 63 | getWriter().println("
|---|
It's the main class to store JavaDocs statistics for any kind of 26 | * documentable element into a Java source file. 27 | * It includes the computed statistics for an entire Java project 28 | * parsed by the JavaDoc Tool.
29 | * 30 | * @author Manoel Campos da Silva Filho 31 | * @since 1.0.0 32 | */ 33 | public class JavaDocsStats implements DocStats { 34 | /** 35 | * Stores the root of the program structure information. 36 | */ 37 | private final RootDoc rootDoc; 38 | 39 | private final PackagesDocStats packagesDocStats; 40 | private final ClassesDocStats classesDocStats; 41 | 42 | /** 43 | * Instantiates an object to compute JavaDoc coverage statistics for all Java files 44 | * received by the JavaDoc tool. 45 | * 46 | * @param rootDoc root element which enables reading JavaDoc documentation 47 | */ 48 | public JavaDocsStats(final RootDoc rootDoc) { 49 | this.rootDoc = rootDoc; 50 | this.classesDocStats = new ClassesDocStats(rootDoc.classes()); 51 | this.packagesDocStats = computePackagesDocsStats(); 52 | } 53 | 54 | /** 55 | * Computes JavaDoc coverage statistics for detected packages. 56 | * 57 | * @return packages' JavaDoc coverage statistics 58 | */ 59 | private PackagesDocStats computePackagesDocsStats() { 60 | final PackagesDocStats stats = new PackagesDocStats(); 61 | for (final ClassDoc doc : rootDoc.classes()) { 62 | stats.addPackageDoc(doc.containingPackage()); 63 | } 64 | 65 | return stats; 66 | } 67 | 68 | /** 69 | * Gets the object containing JavaDoc coverage statistics for detected packages. 70 | * 71 | * @return packages' JavaDoc coverage statistics 72 | * @see #computePackagesDocsStats() 73 | */ 74 | public PackagesDocStats getPackagesDocStats() { 75 | return packagesDocStats; 76 | } 77 | 78 | /** 79 | * Gets the object containing JavaDoc coverage statistics for detected classes. 80 | * 81 | * @return classes' JavaDoc coverage statistics 82 | */ 83 | public ClassesDocStats getClassesDocStats() { return classesDocStats; } 84 | 85 | @Override 86 | public String getType() { 87 | return "Project JavaDoc Statistics"; 88 | } 89 | 90 | @Override 91 | public long getDocumentedMembers() { 92 | return packagesDocStats.getDocumentedMembers() + classesDocStats.getDocumentedMembers(); 93 | } 94 | 95 | @Override 96 | public double getDocumentedMembersPercent() { 97 | return Utils.mean(packagesDocStats.getDocumentedMembersPercent(), classesDocStats.getDocumentedMembersPercent()); 98 | } 99 | 100 | @Override 101 | public long getMembersNumber() { 102 | return classesDocStats.getMembersNumber() + packagesDocStats.getMembersNumber(); 103 | } 104 | } 105 | -------------------------------------------------------------------------------- /src/main/java/com/manoelcampos/javadoc/coverage/stats/MembersDocStats.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2017-2017 Manoel Campos da Silva Filho 3 | * 4 | * Licensed under the General Public License Version 3 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * https://www.gnu.org/licenses/gpl-3.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package com.manoelcampos.javadoc.coverage.stats; 17 | 18 | /** 19 | * An abstract class to compute JavaDocs coverage statistics for a list of members 20 | * belonging to another object, which is called the owner. 21 | * 22 | *In the case the owner of the members is: 23 | *
55 | * There may be documented exceptions which aren't declared.
56 | * Usually, undeclared exceptions are unchecked exceptions,
57 | * which aren't required to be declared.
58 | * Due to such conditions, the number of existing exceptions will be those:
59 | * declared but not documented + documented but not declared + documented and declared.
60 | *
Unchecked exceptions can be in this situation, since they are not required to be declared. 75 | * If a checked exception is documented but not declared, usually the IDEs report an issue 76 | * that the developer should fix. 77 | *
78 | * 79 | * @return 80 | */ 81 | private long getDocumentedButNotDeclaredExceptionsNumber() { 82 | return 83 | getDocumentedTagStream() 84 | .filter(tag -> getDeclaredExceptionsStream().noneMatch(ex -> isExceptionEqualsToJavaDocTag(ex, tag))) 85 | .count(); 86 | } 87 | 88 | /** 89 | * Gets the number of exceptions which are declared but not documented in the JavaDoc. 90 | * @return 91 | */ 92 | private long getDeclaredButNotDocumentedExceptionsNumber() { 93 | return getDeclaredExceptionsStream() 94 | .filter(ex -> getDocumentedTagStream().noneMatch(tag -> isExceptionEqualsToJavaDocTag(ex, tag))) 95 | .count(); 96 | } 97 | 98 | /** 99 | * Gets the number of exceptions which are both declared and documented in the JavaDoc. 100 | * @return 101 | */ 102 | private long getDeclaredAndDocumentedExceptionsNumber() { 103 | return getDeclaredExceptionsStream() 104 | .filter(ex -> getDocumentedTagStream().anyMatch(tag -> isExceptionEqualsToJavaDocTag(ex, tag))) 105 | .count(); 106 | } 107 | 108 | /** 109 | * Gets a Stream of thrown exceptions declared in the method's signature. 110 | * 111 | * @return 112 | */ 113 | private Stream