From fcb14df5eea8b0d977c8d8bd5827dfda94c62fb9 Mon Sep 17 00:00:00 2001 From: Anton Monakov Date: Thu, 17 Jun 2021 19:36:30 +0300 Subject: [PATCH] Proofread Java inspection descriptions GitOrigin-RevId: 523631ea00f4645c5046c1716d06e141576298db --- .../AnonymousInnerClassMayBeStatic.html | 15 ++++++---- .../ClassIndependentOfModule.html | 14 ++++----- .../ClassOnlyUsedInOneModule.html | 16 +++++----- .../ExpectedExceptionNeverThrown.html | 7 ++--- .../IgnoredJUnitTest.html | 13 +++++++-- .../JUnit5Converter.html | 11 ++++--- .../LogStatementGuardedByLogCondition.html | 27 ++++++++++------- .../LoggerInitializedWithForeignClass.html | 15 ++++++---- .../NonStaticFinalLogger.html | 22 +++++++------- .../ReturnOfInnerClass.html | 16 ++++++---- .../StaticCollection.html | 14 ++++++--- .../StringBufferField.html | 10 +++---- .../StringConcatenationArgumentToLogCall.html | 17 +++++++---- .../src/inspectionDescriptions/SystemGC.html | 7 ++--- .../TestMethodInProductCode.html | 5 ++-- .../TestMethodWithoutAssertion.html | 29 +++++++++++-------- .../ZeroLengthArrayInitialization.html | 15 ++++++---- 17 files changed, 146 insertions(+), 107 deletions(-) diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/AnonymousInnerClassMayBeStatic.html b/plugins/InspectionGadgets/src/inspectionDescriptions/AnonymousInnerClassMayBeStatic.html index 8290ff64922f..bd789623ab03 100644 --- a/plugins/InspectionGadgets/src/inspectionDescriptions/AnonymousInnerClassMayBeStatic.html +++ b/plugins/InspectionGadgets/src/inspectionDescriptions/AnonymousInnerClassMayBeStatic.html @@ -1,13 +1,15 @@ -Reports any anonymous classes which may safely be replaced with a static inner classes. +Reports the anonymous classes that may be safely replaced with static inner classes. An anonymous class may be a static inner class if it doesn't explicitly reference its enclosing instance or local classes from its surrounding method.

A static inner class does not keep an implicit reference to its enclosing instance. -This prevents a common cause of memory leaks and uses less memory per instance of the class. +This prevents a common cause of memory leaks and uses less memory per class instance.

Example:

The quick-fix extracts the anonymous class into a named static inner class.

Example:

+  
   void sample(){
     Thread thread = new Thread(new Runnable() {
       @Override
@@ -15,9 +17,11 @@ This prevents a common cause of memory leaks and uses less memory per instance o
       }
     });
   }
+

The quick-fix extracts anonymous class into a named static inner class:

After the quick-fix is applied:

+  
   void sample(){
     Thread thread = new Thread(new Task());
   }
@@ -27,9 +31,8 @@ This prevents a common cause of memory leaks and uses less memory per instance o
     public void run() {
     }
   }
+

- \ No newline at end of file diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/ClassIndependentOfModule.html b/plugins/InspectionGadgets/src/inspectionDescriptions/ClassIndependentOfModule.html index c03d8cd8f618..d936bbcc8c2d 100644 --- a/plugins/InspectionGadgets/src/inspectionDescriptions/ClassIndependentOfModule.html +++ b/plugins/InspectionGadgets/src/inspectionDescriptions/ClassIndependentOfModule.html @@ -1,16 +1,16 @@ -Reports any class which: +Reports the classes that:

doesn't depend on any other class in its module
is not a dependency for any other class in its module
do not depend on any other class in their module
are not a dependency for any other class in their module

-Such classes are an indication of ad-hoc or incoherent modularisation strategies, -and may often profitably be moved. +

Such classes are an indication of ad-hoc or incoherent modularisation strategies, + and may often profitably be moved.

- Because this inspection requires global code analysis it is only available for Analyze|Inspect Code or - Analyze|Run Inspection by Name and it will not report in the editor. + Since this inspection requires global code analysis, it is only available for Analyze | Inspect Code or + Analyze | Run Inspection by Name and will not report in the editor.

\ No newline at end of file diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/ClassOnlyUsedInOneModule.html b/plugins/InspectionGadgets/src/inspectionDescriptions/ClassOnlyUsedInOneModule.html index 293cd398b7f7..2c54c4a4c13e 100644 --- a/plugins/InspectionGadgets/src/inspectionDescriptions/ClassOnlyUsedInOneModule.html +++ b/plugins/InspectionGadgets/src/inspectionDescriptions/ClassOnlyUsedInOneModule.html @@ -1,18 +1,16 @@ -Reports any class which: +Reports the classes that:

doesn't depend on any other class in its module
depends on classes from another module
is a dependency only for classes from this other module
do not depend on any other class in their module
depend on classes from a different module
are a dependency only for classes from this other module

-Such a class could be moved into the module on which it depends. +

Such classes could be moved into the module on which they depend.

\ No newline at end of file diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/ExpectedExceptionNeverThrown.html b/plugins/InspectionGadgets/src/inspectionDescriptions/ExpectedExceptionNeverThrown.html index 2c77d6445036..812a6d00925d 100644 --- a/plugins/InspectionGadgets/src/inspectionDescriptions/ExpectedExceptionNeverThrown.html +++ b/plugins/InspectionGadgets/src/inspectionDescriptions/ExpectedExceptionNeverThrown.html @@ -1,9 +1,8 @@ -Reports checked exceptions expected by a JUnit 4 test method, -which are never thrown inside the method body. -Such test methods can never succeed. -

For example:

+Reports the checked exceptions expected by a JUnit 4 test method that are never thrown inside the method body. +Such test methods will never succeed. +

Example:


   @Test(expected = CloneNotSupportedException.class)
   public void testIt() {
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/IgnoredJUnitTest.html b/plugins/InspectionGadgets/src/inspectionDescriptions/IgnoredJUnitTest.html
index 54e74c876b6a..c221784eaac9 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/IgnoredJUnitTest.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/IgnoredJUnitTest.html
@@ -1,8 +1,8 @@
 
 
 Reports usages of JUnit 4's @Ignore or JUnit 5's @Disabled annotations.
-Test annotated with these annotations for a long time, especially without a specified reason, are a code smell.
-For example:
+The tests annotated with these annotations for a long time, especially without a specified reason, are a code smell.
+Example:
 
   @Ignore
   public class UrgentTest {
@@ -15,6 +15,13 @@ Test annotated with these annotations for a long time, especially without a spec
 
 
 
-Use the check box below to only report when no reason is specified as the annotation's value attribute.
+  Configure the inspection:
+
+
+  
+    Use the Only report annotations without reason option to only report the cases when no reason is specified as the annotation's
+    value attribute.
+  
+
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/JUnit5Converter.html b/plugins/InspectionGadgets/src/inspectionDescriptions/JUnit5Converter.html
index b2155e0d5431..e29bea194ffb 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/JUnit5Converter.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/JUnit5Converter.html
@@ -1,8 +1,8 @@
 
 
-Reports JUnit 4 tests which can be automatically migrated to JUnit 5.
-Though default runners are automatically convertable, custom runners, method- and field- rules are not and require manual changes.
-Example:
+Reports the JUnit 4 tests that can be automatically migrated to JUnit 5.
+While default runners are automatically convertible, custom runners, method- and field- rules are not and require manual changes.
+Example:
 
   import org.junit.Assert;
   import org.junit.Test;
@@ -29,8 +29,7 @@ Though default runners are automatically convertable, custom runners, method- an
   }
 
 
-This inspection requires that the JUnit 5 library is available on the classpath, and JDK 1.8 or higher is configured for the project.
-
-  New in 2017.1
+
This inspection requires that the JUnit 5 library is available in the classpath, and JDK 1.8 or later is configured for the project.
+
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/LogStatementGuardedByLogCondition.html b/plugins/InspectionGadgets/src/inspectionDescriptions/LogStatementGuardedByLogCondition.html
index c7265422a361..9fa11ba80b97 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/LogStatementGuardedByLogCondition.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/LogStatementGuardedByLogCondition.html
@@ -1,12 +1,12 @@
 
 
-Reports logging calls with non-constant arguments which are not surrounded by a guard condition.
+Reports the logging calls with non-constant arguments that are not surrounded by a guard condition.
 The evaluation of the arguments of a logging call can be expensive.
-Surrounding a logging call with a guard clause prevents that cost, when the logging
+Surrounding a logging call with a guard clause prevents that cost when logging
 is disabled for the level used by the logging statement. This is especially useful for the
 least serious level (trace, debug, finest) of logging calls, because those are
 most often disabled in a production environment.
-For example:
+Example:
 
   public class Principal {
     void bad(Object object) {
@@ -25,12 +25,19 @@ most often disabled in a production environment.
 
 
 
-Use the text field below to specify the logger class name used.
-

-Use the table to specify the logging methods this inspection should warn on, with the corresponding
-log condition text.
-

-Use the checkbox below to let this inspection flag all unguarded log calls, not only those with non-constant arguments.
-

+  Configure the inspection:
+
+
+  
+      Use the Logger class name field to specify the logger class name used.
+  
+  
+    
+      Use the table to specify the logging methods this inspection should warn on, with the corresponding log condition text.
+  
+  
+      Use the Flag all unguarded logging calls option to have the inspection flag all unguarded log calls, not only those with non-constant arguments.
+  
+
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/LoggerInitializedWithForeignClass.html b/plugins/InspectionGadgets/src/inspectionDescriptions/LoggerInitializedWithForeignClass.html
index 27d61bdca435..5d0f721abf8a 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/LoggerInitializedWithForeignClass.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/LoggerInitializedWithForeignClass.html
@@ -1,8 +1,10 @@
 
 
-Reports Logger instances which are initialized with a class literal from a different class than the Logger
-is contained in. This can easily happen when copy-pasting some contents from another class and
+Reports the Logger instances that are initialized with a class literal from a different class than the Logger
+is contained in. This can easily happen when copy-pasting some code from another class and
 may result in logging events under an unexpected category and cause filters to be applied incorrectly.
+A quick-fix is provided to replace the foreign class literal with one from the surrounding class.
+Example:
 
   public class Paramount {
     protected static final Logger LOG = Logger.getLogger(Critical.class);
@@ -10,7 +12,7 @@ may result in logging events under an unexpected category and cause filters to b
     // ... other fields and methods
   }
 
-A quick fix is provided to replace the foreign class literal with one from the surrounding class:
+After the quick-fix is applied:
 
   public class Paramount {
     protected static final Logger LOG = Logger.getLogger(Paramount.class);
@@ -20,7 +22,10 @@ may result in logging events under an unexpected category and cause filters to b
 
 
 
-Use the table below to specify the logger factory classes and logger factory methods recognized by this inspection.
-

+  Configure the inspection:
+
+
+  Use the table to specify the logger factory classes and logger factory methods recognized by this inspection.
+
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/NonStaticFinalLogger.html b/plugins/InspectionGadgets/src/inspectionDescriptions/NonStaticFinalLogger.html
index 07aad3293ad7..98f770fd77c5 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/NonStaticFinalLogger.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/NonStaticFinalLogger.html
@@ -1,16 +1,17 @@
 
 
-Reports logger fields on classes which are not declared static and final.
-Ensuring that every classes logger is effectively constant and bound to that class
+Reports the logger fields on classes that are not declared static and final.
+Ensuring that every class logger is effectively constant and bound to that class
 simplifies the task of providing a unified logging implementation for an application. Interfaces,
-enumerations, annotations and inner classes are not reported by this inspection.
-For example:
+enumerations, annotations, and inner classes are not reported by this inspection.
+A quick-fix is provided to change the logger modifiers to static final.
+Example:
 
   public class Significant {
     private Logger LOG = Logger.getLogger(Critical.class);
   }
 
-A quick fix is provided to change the logger modifiers to static final:
+After the quick-fix is applied:
 
   public class Significant {
     private static final Logger LOG = Logger.getLogger(Critical.class);
@@ -18,10 +19,11 @@ enumerations, annotations and inner classes are not reported by this inspection.
 
 
 
-Use the table below to specify logger class names.
-Fields which have a type equal to one of the class names specified and which are not static
-and final, will be reported by this inspection.
-

-
+  Configure the inspection:
+
+
+  Use the Logger class name table to specify logger class names. The inspection will report the fields that are not static and final and are of the type equal to one of the specified class names.
+  
+
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/ReturnOfInnerClass.html b/plugins/InspectionGadgets/src/inspectionDescriptions/ReturnOfInnerClass.html
index f0718d3d8339..269b8c48a8e6 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/ReturnOfInnerClass.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/ReturnOfInnerClass.html
@@ -1,12 +1,16 @@
 
 
-Reports return statements in case when they return an instance of an anonymous, local or inner class.
-Such instances keep an implicit reference to the outer instance which can prevent the outer instance from being garbage collected.
-Any caller of a method which returns such an instance might cause a memory leak by holding on to the instance returned.
+Reports the return statements that return an instance of an anonymous, local, or inner class.
+Such instances keep an implicit reference to the outer instance, which can prevent the outer instance from being garbage-collected.
+Any caller of a method returning such an instance might cause a memory leak by holding on to the instance returned.
 
 
-Use the checkbox below to ignore returns from protected or package-private methods.
-Returns from private methods are always ignored.
-

+  Configure the inspection:
+
+
+  Use the Ignore returns from non-public methods option to ignore returns from protected or package-private methods.
+    Returns from private methods are always ignored.
+  
+
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/StaticCollection.html b/plugins/InspectionGadgets/src/inspectionDescriptions/StaticCollection.html
index 611f5c607bc6..944c3ba65302 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/StaticCollection.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/StaticCollection.html
@@ -1,18 +1,24 @@
 
 
-Reports static fields of a Collection type. While it's
-not necessarily a problem, static collections are often causes of memory leaks, and are
+Reports the static fields of the Collection type. While it's
+not necessarily a problem, static collections often cause memory leaks and are
 therefore prohibited by some coding standards.
-Example: 
+Example:
 +  
   public class Example {
     static List<String> list = new ArrayList<>();
 
     ...
   }
+  
 
 
 
-Use the checkbox below to ignore fields with java.util.WeakHashMap type.
+  Configure the inspection:
+
+
+  Use the Ignore weak static collections or maps option to ignore the fields of the java.util.WeakHashMap type.
+
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/StringBufferField.html b/plugins/InspectionGadgets/src/inspectionDescriptions/StringBufferField.html
index 48feb71111d6..9652c45f3f59 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/StringBufferField.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/StringBufferField.html
@@ -1,17 +1,17 @@
 
 
-Reports fields with type java.lang.StringBuffer or java.lang.StringBuilder.
-Fields with these types can grow without a limit and are often the cause of memory leaks.
-Example:
+Reports the fields of the java.lang.StringBuffer or java.lang.StringBuilder types.
+Such fields can grow without limit and are often the cause of memory leaks.
+Example:
 +  
 public class Example {
   StringBuilder builder = new StringBuilder();
 
   ...
 }
+  
 
 
-
-
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/StringConcatenationArgumentToLogCall.html b/plugins/InspectionGadgets/src/inspectionDescriptions/StringConcatenationArgumentToLogCall.html
index d986d92c451d..1dacdf2a67e9 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/StringConcatenationArgumentToLogCall.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/StringConcatenationArgumentToLogCall.html
@@ -1,9 +1,9 @@
 
 
-Reports non-constant string concatenations used as arguments to SLF4J and Log4j 2 logging methods.
-Non-constant concatenations will be evaluated at runtime even when the logging message is not logged; this can negatively impact performance.
+Reports the non-constant string concatenations that are used as arguments to SLF4J and Log4j 2 logging methods.
+Non-constant concatenations are evaluated at runtime even when the logging message is not logged; this can negatively impact performance.
 It is recommended to use a parameterized log message instead, which will not be evaluated when logging is disabled.
-
For example:
+Example:
 
   public class Vital {
     private static final Logger LOG = LoggerFactory.getLogger(Vital.class);
@@ -14,7 +14,7 @@ It is recommended to use a parameterized log message instead, which will not be
     }
   }
 
-After the quick fix is applied, the result looks like this:
+After the quick-fix is applied:
 
   public class Vital {
     private static final Logger LOG = LoggerFactory.getLogger(Vital.class);
@@ -27,7 +27,12 @@ It is recommended to use a parameterized log message instead, which will not be
 
 
 
-Use the combobox below to ignore certain higher logging levels.
-Higher logging levels may be enabled even in production, and the arguments will always be evaluated.
+  Configure the inspection:
+
+
+  
+    Use the Warn on list to ignore certain higher logging levels. Higher logging levels may be enabled even in production, and the arguments will always be evaluated.
+  
+
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/SystemGC.html b/plugins/InspectionGadgets/src/inspectionDescriptions/SystemGC.html
index b6b220ec2c4c..ebe3bd4c9d60 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/SystemGC.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/SystemGC.html
@@ -1,10 +1,7 @@
 
 
-Reports any call of System.gc() or Runtime.gc().
-While occasionally useful in testing, explicitly triggering garbage collection via System.gc() is almost always
-a bad idea in production code, and can result in serious performance problems.
+Reports the System.gc() or Runtime.gc() calls.
+While occasionally useful in testing, explicitly triggering garbage collection via System.gc() is almost never recommended in production code and can result in serious performance issues.
 
-
-
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/TestMethodInProductCode.html b/plugins/InspectionGadgets/src/inspectionDescriptions/TestMethodInProductCode.html
index 71730350a4bb..05775259aaf7 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/TestMethodInProductCode.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/TestMethodInProductCode.html
@@ -1,8 +1,7 @@
 
 
-Reports methods annotated with the JUnit 4 or JUnit 5 @Test annotation in production source trees.
-This most likely indicates programmer error, and can result in test code being shipped
-into production.
+Reports the methods annotated with the JUnit 4 or JUnit 5 @Test annotation that are located in production source trees.
+This most likely indicates a programmer error and can result in test code being shipped into production.
 
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/TestMethodWithoutAssertion.html b/plugins/InspectionGadgets/src/inspectionDescriptions/TestMethodWithoutAssertion.html
index 27c3cd158ec0..398994e44ef8 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/TestMethodWithoutAssertion.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/TestMethodWithoutAssertion.html
@@ -1,8 +1,7 @@
 
 
-Reports test methods that do not contain
-any assertions. Such methods may indicate either incomplete or weak test cases.
-
For example:
+Reports the test methods that do not contain any assertions. Such methods may indicate either incomplete or weak test cases.
+Example:
 
   public class ExtensiveTest {
 
@@ -14,15 +13,21 @@ any assertions. Such methods may indicate either incomplete or weak test cases.
 
 
 
-Use the table below to specify which combinations of fully qualified class name and method name regular expression
-qualify as assertions.
-Class names also match subclasses.
-

-Use the first checkbox below to specify if Java assert statements, using the assert keyword, should be considered an assertion.
-

-Use the second checkbox to ignore test methods which declare exceptions.
-This can be useful when you have tests that will throw an exception on failure and thus don't need any assertions.
-

+  Configure the inspection:
+
+
+  
+      Use the table to specify the combinations of fully qualified class name and method name regular expression
+      that should qualify as assertions. Class names also match subclasses.
+  
+  
+      Use the 'assert' keyword is considered an assertion option to specify if the Java assert statements using the assert keyword should be considered an assertion.
+  
+  
+      Use the Ignore test methods which declare exceptions option to ignore the test methods that declare exceptions.
+      This can be useful when you have tests that will throw an exception on failure and thus don't need any assertions.
+  
+
 
 
 
\ No newline at end of file
diff --git a/plugins/InspectionGadgets/src/inspectionDescriptions/ZeroLengthArrayInitialization.html b/plugins/InspectionGadgets/src/inspectionDescriptions/ZeroLengthArrayInitialization.html
index 61701a157897..a2f36a7c730e 100644
--- a/plugins/InspectionGadgets/src/inspectionDescriptions/ZeroLengthArrayInitialization.html
+++ b/plugins/InspectionGadgets/src/inspectionDescriptions/ZeroLengthArrayInitialization.html
@@ -1,12 +1,15 @@
 
 
-Reports on allocations of arrays with known lengths of zero. Since array lengths in
-Java are non-modifiable, it is almost always possible to share zero-length arrays, rather than repeatedly
-allocating new zero-length arrays. Such sharing may provide useful optimizations in program runtime or
-footprint. Note that this inspection does not report zero-length arrays allocated as static final fields,
-as it is assumed that those arrays are being used to implement array sharing.
-
+Reports allocations of arrays with known lengths of zero.
+
+  Since array lengths in Java are non-modifiable, it is almost always possible to share zero-length arrays, rather than repeatedly
+  allocate new ones. Such sharing may provide useful optimizations in the program runtime or footprint.
+
 
+  Note that the inspection does not report zero-length arrays allocated as static final fields,
+  since those arrays are assumed to be used for implementing array sharing.
+
+
 
 
 
\ No newline at end of file
-- 
2.23.3