From 77520949518242ba3bfa08cdb3eb1deefcc10f9f Mon Sep 17 00:00:00 2001 From: Jeremy Landis Date: Fri, 31 May 2024 12:46:12 -0400 Subject: [PATCH] [ci] Sort imports now that 'edu' known by impsort --- .../src/test/java/integrationTests/CoverageTest.java | 6 +++--- main/src/main/java/mockit/Deencapsulation.java | 6 +++--- main/src/main/java/mockit/Expectations.java | 6 +++--- main/src/main/java/mockit/Invocation.java | 6 +++--- main/src/main/java/mockit/Invocations.java | 6 +++--- main/src/main/java/mockit/MockUp.java | 6 +++--- main/src/main/java/mockit/Verifications.java | 6 +++--- main/src/main/java/mockit/asm/AnnotatedReader.java | 6 +++--- main/src/main/java/mockit/asm/BaseWriter.java | 6 +++--- main/src/main/java/mockit/asm/SignatureWriter.java | 4 ++-- .../main/java/mockit/asm/annotations/AnnotationReader.java | 6 +++--- .../main/java/mockit/asm/annotations/AnnotationVisitor.java | 6 +++--- .../java/mockit/asm/classes/BootstrapMethodsWriter.java | 4 ++-- main/src/main/java/mockit/asm/classes/ClassReader.java | 6 +++--- main/src/main/java/mockit/asm/classes/ClassVisitor.java | 6 +++--- main/src/main/java/mockit/asm/classes/ClassWriter.java | 6 +++--- .../main/java/mockit/asm/classes/ConstantPoolCopying.java | 6 +++--- .../main/java/mockit/asm/classes/InnerClassesWriter.java | 6 +++--- main/src/main/java/mockit/asm/classes/InterfaceWriter.java | 4 ++-- main/src/main/java/mockit/asm/classes/NestHostWriter.java | 4 ++-- .../src/main/java/mockit/asm/classes/NestMembersWriter.java | 4 ++-- main/src/main/java/mockit/asm/classes/SourceFileWriter.java | 4 ++-- .../main/java/mockit/asm/classes/WrappingClassVisitor.java | 6 +++--- .../main/java/mockit/asm/constantPool/AttributeWriter.java | 4 ++-- .../java/mockit/asm/constantPool/BootstrapMethodItem.java | 4 ++-- .../main/java/mockit/asm/constantPool/ClassMemberItem.java | 4 ++-- .../mockit/asm/constantPool/ConstantPoolGeneration.java | 6 +++--- main/src/main/java/mockit/asm/constantPool/DoubleItem.java | 4 ++-- main/src/main/java/mockit/asm/constantPool/DynamicItem.java | 4 ++-- main/src/main/java/mockit/asm/constantPool/FloatItem.java | 4 ++-- main/src/main/java/mockit/asm/constantPool/IntItem.java | 4 ++-- .../src/main/java/mockit/asm/constantPool/IntValueItem.java | 4 ++-- main/src/main/java/mockit/asm/constantPool/Item.java | 6 +++--- main/src/main/java/mockit/asm/constantPool/LongItem.java | 4 ++-- .../main/java/mockit/asm/constantPool/LongValueItem.java | 4 ++-- .../java/mockit/asm/constantPool/MergedTypeTableItem.java | 4 ++-- .../main/java/mockit/asm/constantPool/MethodHandleItem.java | 4 ++-- main/src/main/java/mockit/asm/constantPool/ModuleItem.java | 4 ++-- .../main/java/mockit/asm/constantPool/NameAndTypeItem.java | 4 ++-- .../java/mockit/asm/constantPool/NormalTypeTableItem.java | 4 ++-- main/src/main/java/mockit/asm/constantPool/PackageItem.java | 4 ++-- main/src/main/java/mockit/asm/constantPool/StringItem.java | 4 ++-- .../main/java/mockit/asm/constantPool/TypeOrMemberItem.java | 4 ++-- .../main/java/mockit/asm/constantPool/TypeTableItem.java | 4 ++-- .../mockit/asm/constantPool/UninitializedTypeTableItem.java | 4 ++-- main/src/main/java/mockit/asm/controlFlow/CFGAnalysis.java | 6 +++--- main/src/main/java/mockit/asm/controlFlow/Frame.java | 6 +++--- main/src/main/java/mockit/asm/controlFlow/Label.java | 6 +++--- .../java/mockit/asm/controlFlow/StackMapTableWriter.java | 4 ++-- .../java/mockit/asm/exceptionHandling/ExceptionHandler.java | 6 +++--- .../mockit/asm/exceptionHandling/ExceptionHandling.java | 6 +++--- main/src/main/java/mockit/asm/fields/FieldReader.java | 6 +++--- main/src/main/java/mockit/asm/fields/FieldVisitor.java | 6 +++--- .../main/java/mockit/asm/metadata/ClassMetadataReader.java | 6 +++--- .../main/java/mockit/asm/metadata/ObjectWithAttributes.java | 6 +++--- main/src/main/java/mockit/asm/methods/ExceptionsWriter.java | 4 ++-- .../main/java/mockit/asm/methods/LineNumberTableWriter.java | 6 +++--- .../java/mockit/asm/methods/LocalVariableTableWriter.java | 6 +++--- main/src/main/java/mockit/asm/methods/MethodReader.java | 6 +++--- main/src/main/java/mockit/asm/methods/MethodVisitor.java | 6 +++--- main/src/main/java/mockit/asm/methods/MethodWriter.java | 6 +++--- .../main/java/mockit/asm/methods/WrappingMethodVisitor.java | 6 +++--- main/src/main/java/mockit/asm/types/ArrayType.java | 4 ++-- main/src/main/java/mockit/asm/types/JavaType.java | 4 ++-- main/src/main/java/mockit/asm/types/MethodType.java | 4 ++-- main/src/main/java/mockit/asm/types/ObjectType.java | 4 ++-- main/src/main/java/mockit/asm/types/PrimitiveType.java | 6 +++--- main/src/main/java/mockit/asm/types/ReferenceType.java | 4 ++-- main/src/main/java/mockit/asm/util/ByteVector.java | 4 ++-- main/src/main/java/mockit/asm/util/BytecodeReader.java | 6 +++--- main/src/main/java/mockit/asm/util/MethodHandle.java | 4 ++-- main/src/main/java/mockit/coverage/AccretionFile.java | 4 ++-- main/src/main/java/mockit/coverage/CallPoint.java | 6 +++--- main/src/main/java/mockit/coverage/CodeCoverage.java | 6 +++--- main/src/main/java/mockit/coverage/Configuration.java | 4 ++-- main/src/main/java/mockit/coverage/CoverageCheck.java | 6 +++--- main/src/main/java/mockit/coverage/CoveragePercentage.java | 4 ++-- main/src/main/java/mockit/coverage/DataFileMerging.java | 4 ++-- main/src/main/java/mockit/coverage/OutputFileGenerator.java | 6 +++--- main/src/main/java/mockit/coverage/TestRun.java | 4 ++-- main/src/main/java/mockit/coverage/XmlFile.java | 4 ++-- main/src/main/java/mockit/coverage/data/CoverageData.java | 6 +++--- .../main/java/mockit/coverage/data/FileCoverageData.java | 6 +++--- main/src/main/java/mockit/coverage/dataItems/FieldData.java | 6 +++--- .../java/mockit/coverage/dataItems/InstanceFieldData.java | 4 ++-- .../java/mockit/coverage/dataItems/PerFileDataCoverage.java | 6 +++--- .../java/mockit/coverage/dataItems/StaticFieldData.java | 4 ++-- .../main/java/mockit/coverage/lines/BranchCoverageData.java | 4 ++-- .../main/java/mockit/coverage/lines/LineCoverageData.java | 6 +++--- .../main/java/mockit/coverage/lines/LineSegmentData.java | 6 +++--- .../java/mockit/coverage/lines/PerFileLineCoverage.java | 6 +++--- .../main/java/mockit/coverage/modification/CFGTracking.java | 4 ++-- .../mockit/coverage/modification/ClassModification.java | 6 +++--- .../java/mockit/coverage/modification/ClassSelection.java | 6 +++--- .../java/mockit/coverage/modification/ClassesNotLoaded.java | 4 ++-- .../java/mockit/coverage/modification/CoverageModifier.java | 6 +++--- .../java/mockit/coverage/modification/MethodModifier.java | 6 +++--- .../main/java/mockit/coverage/reporting/CoverageReport.java | 6 +++--- .../java/mockit/coverage/reporting/ListOfCallPoints.java | 6 +++--- .../src/main/java/mockit/coverage/reporting/OutputFile.java | 4 ++-- .../main/java/mockit/coverage/reporting/SourceFiles.java | 4 ++-- .../main/java/mockit/coverage/reporting/StaticFiles.java | 4 ++-- .../coverage/reporting/dataCoverage/DataCoverageOutput.java | 6 +++--- .../reporting/lineCoverage/LineCoverageFormatter.java | 6 +++--- .../coverage/reporting/lineCoverage/LineCoverageOutput.java | 4 ++-- .../reporting/lineCoverage/LineSegmentsFormatter.java | 6 +++--- .../java/mockit/coverage/reporting/packages/IndexPage.java | 6 +++--- .../reporting/packages/ListWithFilesAndPercentages.java | 6 +++--- .../coverage/reporting/packages/PackageCoverageReport.java | 6 +++--- .../java/mockit/coverage/reporting/parsing/FileParser.java | 6 +++--- .../java/mockit/coverage/reporting/parsing/LineElement.java | 6 +++--- .../java/mockit/coverage/reporting/parsing/LineParser.java | 6 +++--- .../coverage/reporting/sourceFiles/FileCoverageReport.java | 6 +++--- .../mockit/coverage/reporting/sourceFiles/InputFile.java | 6 +++--- .../coverage/reporting/sourceFiles/NeutralOutput.java | 6 +++--- .../java/mockit/coverage/testRedundancy/JUnitListener.java | 4 ++-- .../java/mockit/coverage/testRedundancy/TestCoverage.java | 6 +++--- .../main/java/mockit/integration/TestRunnerDecorator.java | 6 +++--- .../java/mockit/integration/junit4/FakeFrameworkMethod.java | 6 +++--- .../java/mockit/integration/junit4/FakeRunNotifier.java | 4 ++-- .../integration/junit4/JUnit4TestRunnerDecorator.java | 6 +++--- .../java/mockit/integration/junit5/JMockitExtension.java | 6 +++--- .../java/mockit/integration/springframework/BeanLookup.java | 6 +++--- .../mockit/integration/springframework/FakeBeanFactory.java | 6 +++--- .../springframework/TestWebApplicationContext.java | 6 +++--- .../mockit/integration/testng/TestNGRunnerDecorator.java | 6 +++--- main/src/main/java/mockit/internal/BaseClassModifier.java | 6 +++--- main/src/main/java/mockit/internal/BaseInvocation.java | 6 +++--- main/src/main/java/mockit/internal/ClassFile.java | 6 +++--- main/src/main/java/mockit/internal/ClassLoadingBridge.java | 6 +++--- .../mockit/internal/capturing/CaptureOfImplementations.java | 6 +++--- .../java/mockit/internal/capturing/CaptureTransformer.java | 6 +++--- .../main/java/mockit/internal/capturing/CapturedType.java | 6 +++--- .../internal/classGeneration/BaseSubclassGenerator.java | 6 +++--- .../mockit/internal/classGeneration/ConcreteSubclass.java | 6 +++--- .../internal/classGeneration/ImplementationClass.java | 6 +++--- .../mockit/internal/classGeneration/MockedTypeInfo.java | 4 ++-- .../mockit/internal/expectations/ActiveInvocations.java | 6 +++--- .../mockit/internal/expectations/BaseVerificationPhase.java | 6 +++--- .../mockit/internal/expectations/EquivalentInstances.java | 6 +++--- .../java/mockit/internal/expectations/ExecutionMode.java | 4 ++-- .../main/java/mockit/internal/expectations/Expectation.java | 6 +++--- .../mockit/internal/expectations/FullVerificationPhase.java | 6 +++--- .../mockit/internal/expectations/InstanceBasedMatching.java | 4 ++-- .../java/mockit/internal/expectations/MockingFilters.java | 4 ++-- .../internal/expectations/OrderedVerificationPhase.java | 6 +++--- .../internal/expectations/PartiallyMockedInstances.java | 4 ++-- main/src/main/java/mockit/internal/expectations/Phase.java | 4 ++-- .../mockit/internal/expectations/PhasedExecutionState.java | 6 +++--- .../internal/expectations/RecordAndReplayExecution.java | 6 +++--- .../main/java/mockit/internal/expectations/RecordPhase.java | 6 +++--- .../main/java/mockit/internal/expectations/ReplayPhase.java | 6 +++--- .../internal/expectations/SequenceOfReturnValues.java | 6 +++--- .../java/mockit/internal/expectations/TestOnlyPhase.java | 6 +++--- .../internal/expectations/UnorderedVerificationPhase.java | 6 +++--- .../mockit/internal/expectations/VerifiedExpectation.java | 6 +++--- .../expectations/argumentMatching/ArgumentMismatch.java | 6 +++--- .../expectations/argumentMatching/CaptureMatcher.java | 4 ++-- .../expectations/argumentMatching/ClassMatcher.java | 6 +++--- .../expectations/argumentMatching/EqualityMatcher.java | 4 ++-- .../expectations/argumentMatching/HamcrestAdapter.java | 6 +++--- .../argumentMatching/LenientEqualityMatcher.java | 4 ++-- .../expectations/argumentMatching/PatternMatcher.java | 4 ++-- .../expectations/argumentMatching/ReflectiveMatcher.java | 6 +++--- .../expectations/invocation/ArgumentValuesAndMatchers.java | 6 +++--- .../invocation/ArgumentValuesAndMatchersWithVarargs.java | 6 +++--- .../invocation/ArgumentValuesAndMatchersWithoutVarargs.java | 4 ++-- .../expectations/invocation/DelegateInvocation.java | 6 +++--- .../internal/expectations/invocation/DelegatedResult.java | 6 +++--- .../internal/expectations/invocation/ExpectationError.java | 4 ++-- .../expectations/invocation/ExpectedInvocation.java | 6 +++--- .../expectations/invocation/InvocationArguments.java | 6 +++--- .../expectations/invocation/InvocationConstraints.java | 6 +++--- .../internal/expectations/invocation/InvocationResult.java | 4 ++-- .../internal/expectations/invocation/InvocationResults.java | 6 +++--- .../expectations/invocation/MultiValuedConversion.java | 6 +++--- .../expectations/invocation/ReturnTypeConversion.java | 6 +++--- .../internal/expectations/mocking/BaseTypeRedefinition.java | 6 +++--- .../expectations/mocking/CaptureOfNewInstances.java | 6 +++--- .../mocking/CaptureOfNewInstancesForFields.java | 4 ++-- .../expectations/mocking/CascadingTypeRedefinition.java | 4 ++-- .../expectations/mocking/FieldTypeRedefinition.java | 4 ++-- .../expectations/mocking/FieldTypeRedefinitions.java | 4 ++-- .../internal/expectations/mocking/InstanceFactory.java | 6 +++--- .../mocking/InterfaceImplementationGenerator.java | 6 +++--- .../mockit/internal/expectations/mocking/MockedBridge.java | 6 +++--- .../internal/expectations/mocking/MockedClassModifier.java | 6 +++--- .../mockit/internal/expectations/mocking/MockedType.java | 6 +++--- .../expectations/mocking/ParameterTypeRedefinitions.java | 6 +++--- .../internal/expectations/mocking/PartialMocking.java | 4 ++-- .../expectations/mocking/SubclassGenerationModifier.java | 6 +++--- .../internal/expectations/mocking/TypeRedefinition.java | 6 +++--- .../internal/expectations/mocking/TypeRedefinitions.java | 6 +++--- .../mockit/internal/expectations/state/CascadingTypes.java | 6 +++--- .../mockit/internal/expectations/state/ExecutingTest.java | 6 +++--- .../internal/expectations/state/MockedTypeCascade.java | 6 +++--- .../expectations/transformation/ArgumentCapturing.java | 6 +++--- .../expectations/transformation/ArgumentMatching.java | 4 ++-- .../internal/expectations/transformation/Capture.java | 6 +++--- .../transformation/ExpectationsTransformer.java | 6 +++--- .../transformation/InvocationBlockModifier.java | 6 +++--- .../internal/faking/CaptureOfFakedImplementations.java | 6 +++--- main/src/main/java/mockit/internal/faking/FakeBridge.java | 6 +++--- .../main/java/mockit/internal/faking/FakeClassSetup.java | 6 +++--- main/src/main/java/mockit/internal/faking/FakeClasses.java | 6 +++--- .../main/java/mockit/internal/faking/FakeInvocation.java | 6 +++--- .../main/java/mockit/internal/faking/FakeMethodBridge.java | 6 +++--- .../java/mockit/internal/faking/FakeMethodCollector.java | 4 ++-- main/src/main/java/mockit/internal/faking/FakeMethods.java | 6 +++--- main/src/main/java/mockit/internal/faking/FakeState.java | 6 +++--- main/src/main/java/mockit/internal/faking/FakeStates.java | 6 +++--- .../java/mockit/internal/faking/FakedClassModifier.java | 6 +++--- .../mockit/internal/faking/FakedImplementationClass.java | 6 +++--- .../main/java/mockit/internal/injection/BeanExporter.java | 6 +++--- .../main/java/mockit/internal/injection/InjectionPoint.java | 6 +++--- .../java/mockit/internal/injection/InjectionProvider.java | 6 +++--- .../java/mockit/internal/injection/InjectionProviders.java | 6 +++--- .../main/java/mockit/internal/injection/InjectionState.java | 6 +++--- main/src/main/java/mockit/internal/injection/Injector.java | 6 +++--- .../java/mockit/internal/injection/InterfaceResolution.java | 6 +++--- .../java/mockit/internal/injection/LifecycleMethods.java | 6 +++--- .../java/mockit/internal/injection/MultiValuedProvider.java | 6 +++--- .../main/java/mockit/internal/injection/TestedClass.java | 6 +++--- .../internal/injection/TestedClassInstantiations.java | 4 ++-- .../main/java/mockit/internal/injection/TestedField.java | 6 +++--- .../main/java/mockit/internal/injection/TestedObject.java | 6 +++--- .../mockit/internal/injection/TestedObjectCreation.java | 6 +++--- .../java/mockit/internal/injection/TestedParameter.java | 6 +++--- .../java/mockit/internal/injection/TestedParameters.java | 6 +++--- .../injection/constructor/ConstructorInjection.java | 6 +++--- .../injection/constructor/ConstructorParameter.java | 6 +++--- .../internal/injection/constructor/ConstructorSearch.java | 6 +++--- .../mockit/internal/injection/field/FieldInjection.java | 6 +++--- .../java/mockit/internal/injection/field/FieldToInject.java | 4 ++-- .../java/mockit/internal/injection/full/FullInjection.java | 6 +++--- .../mockit/internal/injection/full/JPADependencies.java | 6 +++--- .../mockit/internal/injection/full/ServletDependencies.java | 4 ++-- .../java/mockit/internal/injection/full/TestDataSource.java | 6 +++--- .../mockit/internal/reflection/AnnotationReflection.java | 6 +++--- .../mockit/internal/reflection/ConstructorReflection.java | 6 +++--- .../main/java/mockit/internal/reflection/EmptyProxy.java | 6 +++--- .../java/mockit/internal/reflection/FieldReflection.java | 6 +++--- .../mockit/internal/reflection/GenericTypeReflection.java | 6 +++--- .../java/mockit/internal/reflection/MethodReflection.java | 6 +++--- .../mockit/internal/reflection/MockInvocationHandler.java | 6 +++--- .../mockit/internal/reflection/ParameterReflection.java | 4 ++-- .../mockit/internal/reflection/RealMethodOrConstructor.java | 6 +++--- .../mockit/internal/startup/ClassLoadingBridgeFields.java | 6 +++--- .../java/mockit/internal/startup/JMockitInitialization.java | 4 ++-- main/src/main/java/mockit/internal/startup/Startup.java | 6 +++--- .../main/java/mockit/internal/state/CachedClassfiles.java | 6 +++--- main/src/main/java/mockit/internal/state/MockFixture.java | 6 +++--- .../src/main/java/mockit/internal/state/ParameterNames.java | 6 +++--- main/src/main/java/mockit/internal/state/SavePoint.java | 4 ++-- main/src/main/java/mockit/internal/state/TestRun.java | 6 +++--- main/src/main/java/mockit/internal/util/AutoBoxing.java | 6 +++--- main/src/main/java/mockit/internal/util/ClassLoad.java | 6 +++--- main/src/main/java/mockit/internal/util/DefaultValues.java | 6 +++--- .../main/java/mockit/internal/util/GeneratedClasses.java | 4 ++-- .../src/main/java/mockit/internal/util/MethodFormatter.java | 6 +++--- .../java/mockit/internal/util/ParameterNameExtractor.java | 4 ++-- main/src/main/java/mockit/internal/util/StackTrace.java | 4 ++-- main/src/main/java/mockit/internal/util/TestMethod.java | 6 +++--- main/src/main/java/mockit/internal/util/TypeConversion.java | 6 +++--- .../java/mockit/internal/util/TypeConversionBytecode.java | 4 ++-- main/src/main/java/mockit/internal/util/TypeDescriptor.java | 4 ++-- main/src/main/java/mockit/internal/util/Utilities.java | 6 +++--- main/src/test/java/mockit/FakingBaseTypesTest.java | 4 ++-- main/src/test/java/mockit/MockedAnnotationsTest.java | 4 ++-- .../src/test/java/mockit/MockedClassWithSuperClassTest.java | 4 ++-- main/src/test/java/mockit/NaturalOrderingTest.java | 4 ++-- .../jmockit/loginExample/domain/userLogin/LoginService.java | 5 +++-- samples/petclinic/src/main/java/petclinic/owners/Owner.java | 5 +++-- .../src/main/java/petclinic/owners/OwnerMaintenance.java | 5 +++-- .../src/main/java/petclinic/owners/OwnerScreen.java | 4 ++-- .../src/main/java/petclinic/pets/PetMaintenance.java | 5 +++-- .../petclinic/src/main/java/petclinic/pets/PetScreen.java | 5 +++-- .../petclinic/src/main/java/petclinic/util/Database.java | 6 +++--- .../src/main/java/petclinic/vets/VetMaintenance.java | 3 ++- .../petclinic/src/main/java/petclinic/vets/VetScreen.java | 4 ++-- .../src/main/java/petclinic/visits/VisitMaintenance.java | 5 +++-- .../src/main/java/petclinic/visits/VisitScreen.java | 3 ++- .../petclinic/src/test/java/petclinic/owners/OwnerData.java | 1 + samples/petclinic/src/test/java/petclinic/pets/PetData.java | 5 +++-- samples/petclinic/src/test/java/petclinic/vets/VetData.java | 1 + .../petclinic/src/test/java/petclinic/visits/VisitData.java | 3 ++- 286 files changed, 762 insertions(+), 750 deletions(-) diff --git a/coverageTests/src/test/java/integrationTests/CoverageTest.java b/coverageTests/src/test/java/integrationTests/CoverageTest.java index bed9e5d50..04ab441a3 100644 --- a/coverageTests/src/test/java/integrationTests/CoverageTest.java +++ b/coverageTests/src/test/java/integrationTests/CoverageTest.java @@ -8,6 +8,9 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Field; import java.util.List; import java.util.Map; @@ -25,9 +28,6 @@ import org.checkerframework.checker.index.qual.NonNegative; import org.junit.jupiter.api.BeforeEach; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - @SuppressWarnings("JUnitTestCaseWithNoTests") public class CoverageTest { @Nullable diff --git a/main/src/main/java/mockit/Deencapsulation.java b/main/src/main/java/mockit/Deencapsulation.java index 504eed1f9..4e9dfee5b 100644 --- a/main/src/main/java/mockit/Deencapsulation.java +++ b/main/src/main/java/mockit/Deencapsulation.java @@ -4,13 +4,13 @@ */ package mockit; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.reflection.FieldReflection; import mockit.internal.reflection.MethodReflection; import mockit.internal.util.ClassLoad; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Provides utility methods that enable access to ("de-encapsulate") otherwise non-accessible fields. * diff --git a/main/src/main/java/mockit/Expectations.java b/main/src/main/java/mockit/Expectations.java index 8b5b31891..83e3bf20a 100644 --- a/main/src/main/java/mockit/Expectations.java +++ b/main/src/main/java/mockit/Expectations.java @@ -4,6 +4,9 @@ */ package mockit; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.Collections; import java.util.Iterator; import java.util.List; @@ -12,9 +15,6 @@ import mockit.internal.expectations.RecordAndReplayExecution; import mockit.internal.expectations.RecordPhase; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Used to record expectations on {@linkplain Mocked mocked} types and their instances. *

diff --git a/main/src/main/java/mockit/Invocation.java b/main/src/main/java/mockit/Invocation.java index 8190c536f..658f9a639 100644 --- a/main/src/main/java/mockit/Invocation.java +++ b/main/src/main/java/mockit/Invocation.java @@ -4,15 +4,15 @@ */ package mockit; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Member; import mockit.internal.BaseInvocation; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A context object representing the current invocation to a mocked or faked method/constructor, to be passed as the * first parameter of the corresponding delegate/fake method implementation. diff --git a/main/src/main/java/mockit/Invocations.java b/main/src/main/java/mockit/Invocations.java index 897fb7833..e8da51ed2 100644 --- a/main/src/main/java/mockit/Invocations.java +++ b/main/src/main/java/mockit/Invocations.java @@ -4,6 +4,9 @@ */ package mockit; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.List; @@ -33,9 +36,6 @@ import org.checkerframework.checker.index.qual.NonNegative; import org.hamcrest.Matcher; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Provides common API for use inside {@linkplain Expectations expectation} and {@linkplain Verifications verification} * blocks. diff --git a/main/src/main/java/mockit/MockUp.java b/main/src/main/java/mockit/MockUp.java index 5511ccf9d..4fef914d5 100644 --- a/main/src/main/java/mockit/MockUp.java +++ b/main/src/main/java/mockit/MockUp.java @@ -8,6 +8,9 @@ import static mockit.internal.util.GeneratedClasses.isGeneratedImplementationClassName; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.ParameterizedType; import java.lang.reflect.Proxy; import java.lang.reflect.Type; @@ -23,9 +26,6 @@ import mockit.internal.startup.Startup; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A base class used in the creation of a fake for an external type, which is usually a class from * some library or component used from the internal codebase of the system under test (SUT). Such fake classes diff --git a/main/src/main/java/mockit/Verifications.java b/main/src/main/java/mockit/Verifications.java index 746ca51ff..53265e680 100644 --- a/main/src/main/java/mockit/Verifications.java +++ b/main/src/main/java/mockit/Verifications.java @@ -4,6 +4,9 @@ */ package mockit; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import mockit.internal.expectations.BaseVerificationPhase; @@ -11,9 +14,6 @@ import mockit.internal.expectations.argumentMatching.AlwaysTrueMatcher; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Used to verify a set of expectations on available {@linkplain Mocked mocked} types and/or instances, against * the invocations which actually occurred during the test. As such, these verifications can only appear after diff --git a/main/src/main/java/mockit/asm/AnnotatedReader.java b/main/src/main/java/mockit/asm/AnnotatedReader.java index b32bfcca0..5812cdca4 100644 --- a/main/src/main/java/mockit/asm/AnnotatedReader.java +++ b/main/src/main/java/mockit/asm/AnnotatedReader.java @@ -1,5 +1,8 @@ package mockit.asm; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.annotations.AnnotationReader; import mockit.asm.annotations.AnnotationVisitor; import mockit.asm.jvmConstants.Access; @@ -7,9 +10,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A bytecode reader for reading common elements (signature, annotations) of a class, field, or method. */ diff --git a/main/src/main/java/mockit/asm/BaseWriter.java b/main/src/main/java/mockit/asm/BaseWriter.java index 6962dff23..f79796aa5 100644 --- a/main/src/main/java/mockit/asm/BaseWriter.java +++ b/main/src/main/java/mockit/asm/BaseWriter.java @@ -1,5 +1,8 @@ package mockit.asm; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import mockit.asm.annotations.AnnotationVisitor; @@ -9,9 +12,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public class BaseWriter { /** * The dynamically generated constant pool of the class being built/modified. diff --git a/main/src/main/java/mockit/asm/SignatureWriter.java b/main/src/main/java/mockit/asm/SignatureWriter.java index 43231aee5..ebb87ef35 100644 --- a/main/src/main/java/mockit/asm/SignatureWriter.java +++ b/main/src/main/java/mockit/asm/SignatureWriter.java @@ -1,13 +1,13 @@ package mockit.asm; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class SignatureWriter extends AttributeWriter { @NonNegative private final int signatureIndex; diff --git a/main/src/main/java/mockit/asm/annotations/AnnotationReader.java b/main/src/main/java/mockit/asm/annotations/AnnotationReader.java index 36953ba0e..35cc2f0e4 100644 --- a/main/src/main/java/mockit/asm/annotations/AnnotationReader.java +++ b/main/src/main/java/mockit/asm/annotations/AnnotationReader.java @@ -1,5 +1,8 @@ package mockit.asm.annotations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import mockit.asm.types.JavaType; @@ -8,9 +11,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class AnnotationReader extends BytecodeReader { public AnnotationReader(@NonNull BytecodeReader br) { super(br); diff --git a/main/src/main/java/mockit/asm/annotations/AnnotationVisitor.java b/main/src/main/java/mockit/asm/annotations/AnnotationVisitor.java index 6075fd01f..f04c41df6 100644 --- a/main/src/main/java/mockit/asm/annotations/AnnotationVisitor.java +++ b/main/src/main/java/mockit/asm/annotations/AnnotationVisitor.java @@ -1,5 +1,8 @@ package mockit.asm.annotations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import mockit.asm.constantPool.ConstantPoolGeneration; @@ -9,9 +12,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A visitor to visit a Java annotation, in the following order: (visit | visitEnum | * visitAnnotation | visitArray)* visitEnd. diff --git a/main/src/main/java/mockit/asm/classes/BootstrapMethodsWriter.java b/main/src/main/java/mockit/asm/classes/BootstrapMethodsWriter.java index 1ed5f5ab4..406693957 100644 --- a/main/src/main/java/mockit/asm/classes/BootstrapMethodsWriter.java +++ b/main/src/main/java/mockit/asm/classes/BootstrapMethodsWriter.java @@ -2,6 +2,8 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.INVOKE_DYNAMIC; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.BootstrapMethodItem; import mockit.asm.constantPool.ConstantPoolGeneration; @@ -13,8 +15,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Generates the "BootstrapMethods" attribute in a class file being written by a {@link ClassWriter}. */ diff --git a/main/src/main/java/mockit/asm/classes/ClassReader.java b/main/src/main/java/mockit/asm/classes/ClassReader.java index aabfeaf52..cfe6440fe 100644 --- a/main/src/main/java/mockit/asm/classes/ClassReader.java +++ b/main/src/main/java/mockit/asm/classes/ClassReader.java @@ -1,5 +1,8 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.AnnotatedReader; import mockit.asm.fields.FieldReader; import mockit.asm.jvmConstants.Access; @@ -8,9 +11,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A Java class parser to make a {@link ClassVisitor} visit an existing class. *

diff --git a/main/src/main/java/mockit/asm/classes/ClassVisitor.java b/main/src/main/java/mockit/asm/classes/ClassVisitor.java index c141d5bbc..54005ffaf 100644 --- a/main/src/main/java/mockit/asm/classes/ClassVisitor.java +++ b/main/src/main/java/mockit/asm/classes/ClassVisitor.java @@ -1,5 +1,8 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.BaseWriter; import mockit.asm.fields.FieldVisitor; import mockit.asm.jvmConstants.Access; @@ -7,9 +10,6 @@ import mockit.asm.methods.MethodVisitor; import mockit.asm.types.JavaType; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A visitor to visit a Java class, in the following order:
* visit (visitAnnotation)* (visitInnerClass | visitField | diff --git a/main/src/main/java/mockit/asm/classes/ClassWriter.java b/main/src/main/java/mockit/asm/classes/ClassWriter.java index 72d3e7e1b..8481e72e0 100644 --- a/main/src/main/java/mockit/asm/classes/ClassWriter.java +++ b/main/src/main/java/mockit/asm/classes/ClassWriter.java @@ -1,5 +1,8 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; @@ -17,9 +20,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A {@link ClassVisitor} that generates classes in bytecode form, that is, a byte array conforming to the * Java class file format. diff --git a/main/src/main/java/mockit/asm/classes/ConstantPoolCopying.java b/main/src/main/java/mockit/asm/classes/ConstantPoolCopying.java index 07d171e75..aaa0914fd 100644 --- a/main/src/main/java/mockit/asm/classes/ConstantPoolCopying.java +++ b/main/src/main/java/mockit/asm/classes/ConstantPoolCopying.java @@ -18,6 +18,9 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.STRING; import static mockit.asm.jvmConstants.ConstantPoolTypes.UTF8; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.constantPool.ClassMemberItem; import mockit.asm.constantPool.DoubleItem; import mockit.asm.constantPool.DynamicItem; @@ -34,9 +37,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Copies the constant pool data from a {@link ClassReader} into a {@link ClassWriter}. */ diff --git a/main/src/main/java/mockit/asm/classes/InnerClassesWriter.java b/main/src/main/java/mockit/asm/classes/InnerClassesWriter.java index 5990828f5..390705292 100644 --- a/main/src/main/java/mockit/asm/classes/InnerClassesWriter.java +++ b/main/src/main/java/mockit/asm/classes/InnerClassesWriter.java @@ -1,14 +1,14 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class InnerClassesWriter extends AttributeWriter { @NonNull private final ByteVector innerClasses; diff --git a/main/src/main/java/mockit/asm/classes/InterfaceWriter.java b/main/src/main/java/mockit/asm/classes/InterfaceWriter.java index 6843629d7..49203dcdb 100644 --- a/main/src/main/java/mockit/asm/classes/InterfaceWriter.java +++ b/main/src/main/java/mockit/asm/classes/InterfaceWriter.java @@ -1,11 +1,11 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.util.ByteVector; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Writes out the interfaces implemented or extended by the class or interface being written. */ diff --git a/main/src/main/java/mockit/asm/classes/NestHostWriter.java b/main/src/main/java/mockit/asm/classes/NestHostWriter.java index 5adfbbaa0..6a0058fe6 100644 --- a/main/src/main/java/mockit/asm/classes/NestHostWriter.java +++ b/main/src/main/java/mockit/asm/classes/NestHostWriter.java @@ -1,13 +1,13 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - final class NestHostWriter extends AttributeWriter { @NonNegative private final int hostClassNameIndex; diff --git a/main/src/main/java/mockit/asm/classes/NestMembersWriter.java b/main/src/main/java/mockit/asm/classes/NestMembersWriter.java index e45e2d761..b9de4877b 100644 --- a/main/src/main/java/mockit/asm/classes/NestMembersWriter.java +++ b/main/src/main/java/mockit/asm/classes/NestMembersWriter.java @@ -1,13 +1,13 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - final class NestMembersWriter extends AttributeWriter { @NonNegative private final int[] memberClassNameIndices; diff --git a/main/src/main/java/mockit/asm/classes/SourceFileWriter.java b/main/src/main/java/mockit/asm/classes/SourceFileWriter.java index 0ac0aa58a..5bcc3966c 100644 --- a/main/src/main/java/mockit/asm/classes/SourceFileWriter.java +++ b/main/src/main/java/mockit/asm/classes/SourceFileWriter.java @@ -1,13 +1,13 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Writes out into the constant pool the item index containing the name of the source file from which the class was * compiled. diff --git a/main/src/main/java/mockit/asm/classes/WrappingClassVisitor.java b/main/src/main/java/mockit/asm/classes/WrappingClassVisitor.java index e6ee9208d..0d5409ea2 100644 --- a/main/src/main/java/mockit/asm/classes/WrappingClassVisitor.java +++ b/main/src/main/java/mockit/asm/classes/WrappingClassVisitor.java @@ -1,12 +1,12 @@ package mockit.asm.classes; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.annotations.AnnotationVisitor; import mockit.asm.fields.FieldVisitor; import mockit.asm.methods.MethodVisitor; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Same as {@link ClassVisitor}, except it always wraps a {@link ClassWriter}. */ diff --git a/main/src/main/java/mockit/asm/constantPool/AttributeWriter.java b/main/src/main/java/mockit/asm/constantPool/AttributeWriter.java index e3c370bfd..85362f1be 100644 --- a/main/src/main/java/mockit/asm/constantPool/AttributeWriter.java +++ b/main/src/main/java/mockit/asm/constantPool/AttributeWriter.java @@ -1,11 +1,11 @@ package mockit.asm.constantPool; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - public abstract class AttributeWriter { @NonNull protected final ConstantPoolGeneration cp; diff --git a/main/src/main/java/mockit/asm/constantPool/BootstrapMethodItem.java b/main/src/main/java/mockit/asm/constantPool/BootstrapMethodItem.java index 0d1bef604..fd3307009 100644 --- a/main/src/main/java/mockit/asm/constantPool/BootstrapMethodItem.java +++ b/main/src/main/java/mockit/asm/constantPool/BootstrapMethodItem.java @@ -2,10 +2,10 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.BSM; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class BootstrapMethodItem extends Item { @NonNegative final int position; diff --git a/main/src/main/java/mockit/asm/constantPool/ClassMemberItem.java b/main/src/main/java/mockit/asm/constantPool/ClassMemberItem.java index 3db444198..6d4944b1d 100644 --- a/main/src/main/java/mockit/asm/constantPool/ClassMemberItem.java +++ b/main/src/main/java/mockit/asm/constantPool/ClassMemberItem.java @@ -1,9 +1,9 @@ package mockit.asm.constantPool; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class ClassMemberItem extends TypeOrMemberItem { @NonNull String owner; diff --git a/main/src/main/java/mockit/asm/constantPool/ConstantPoolGeneration.java b/main/src/main/java/mockit/asm/constantPool/ConstantPoolGeneration.java index 0061e93c0..659408aad 100644 --- a/main/src/main/java/mockit/asm/constantPool/ConstantPoolGeneration.java +++ b/main/src/main/java/mockit/asm/constantPool/ConstantPoolGeneration.java @@ -15,6 +15,9 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.UTF8; import static mockit.internal.util.ClassLoad.OBJECT; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.jvmConstants.ConstantPoolTypes; import mockit.asm.types.JavaType; import mockit.asm.types.MethodType; @@ -26,9 +29,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Allows the constant pool for a classfile to be created from scratch, when that classfile itself is being generated or * modified from an existing class file. diff --git a/main/src/main/java/mockit/asm/constantPool/DoubleItem.java b/main/src/main/java/mockit/asm/constantPool/DoubleItem.java index b3268493c..7c1b36ad2 100644 --- a/main/src/main/java/mockit/asm/constantPool/DoubleItem.java +++ b/main/src/main/java/mockit/asm/constantPool/DoubleItem.java @@ -2,10 +2,10 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.DOUBLE; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class DoubleItem extends LongValueItem { public DoubleItem(@NonNegative int index) { super(index); diff --git a/main/src/main/java/mockit/asm/constantPool/DynamicItem.java b/main/src/main/java/mockit/asm/constantPool/DynamicItem.java index f09fc3401..cb1699f19 100644 --- a/main/src/main/java/mockit/asm/constantPool/DynamicItem.java +++ b/main/src/main/java/mockit/asm/constantPool/DynamicItem.java @@ -1,11 +1,11 @@ package mockit.asm.constantPool; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.jvmConstants.ConstantPoolTypes; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class DynamicItem extends TypeOrMemberItem { @NonNegative int bsmIndex; diff --git a/main/src/main/java/mockit/asm/constantPool/FloatItem.java b/main/src/main/java/mockit/asm/constantPool/FloatItem.java index ebcb7e89a..6c9170648 100644 --- a/main/src/main/java/mockit/asm/constantPool/FloatItem.java +++ b/main/src/main/java/mockit/asm/constantPool/FloatItem.java @@ -2,10 +2,10 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.FLOAT; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class FloatItem extends IntValueItem { public FloatItem(@NonNegative int index) { super(index); diff --git a/main/src/main/java/mockit/asm/constantPool/IntItem.java b/main/src/main/java/mockit/asm/constantPool/IntItem.java index 4395653c8..90e246982 100644 --- a/main/src/main/java/mockit/asm/constantPool/IntItem.java +++ b/main/src/main/java/mockit/asm/constantPool/IntItem.java @@ -2,10 +2,10 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.INTEGER; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class IntItem extends IntValueItem { public IntItem(@NonNegative int index) { super(index); diff --git a/main/src/main/java/mockit/asm/constantPool/IntValueItem.java b/main/src/main/java/mockit/asm/constantPool/IntValueItem.java index a4f77c532..5097407cf 100644 --- a/main/src/main/java/mockit/asm/constantPool/IntValueItem.java +++ b/main/src/main/java/mockit/asm/constantPool/IntValueItem.java @@ -1,9 +1,9 @@ package mockit.asm.constantPool; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + class IntValueItem extends Item { /** * Value of this item, for an integer item. diff --git a/main/src/main/java/mockit/asm/constantPool/Item.java b/main/src/main/java/mockit/asm/constantPool/Item.java index e17f1221b..11d3e1bc8 100644 --- a/main/src/main/java/mockit/asm/constantPool/Item.java +++ b/main/src/main/java/mockit/asm/constantPool/Item.java @@ -1,12 +1,12 @@ package mockit.asm.constantPool; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.jvmConstants.ConstantPoolTypes; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A constant pool item of a given {@linkplain ConstantPoolTypes type}. */ diff --git a/main/src/main/java/mockit/asm/constantPool/LongItem.java b/main/src/main/java/mockit/asm/constantPool/LongItem.java index 1d888979a..33bd0e5ae 100644 --- a/main/src/main/java/mockit/asm/constantPool/LongItem.java +++ b/main/src/main/java/mockit/asm/constantPool/LongItem.java @@ -2,10 +2,10 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.LONG; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class LongItem extends LongValueItem { public LongItem(@NonNegative int index) { super(index); diff --git a/main/src/main/java/mockit/asm/constantPool/LongValueItem.java b/main/src/main/java/mockit/asm/constantPool/LongValueItem.java index 45a98383b..4bca4e4c8 100644 --- a/main/src/main/java/mockit/asm/constantPool/LongValueItem.java +++ b/main/src/main/java/mockit/asm/constantPool/LongValueItem.java @@ -1,9 +1,9 @@ package mockit.asm.constantPool; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public class LongValueItem extends Item { /** * Value of this item, for a long item. diff --git a/main/src/main/java/mockit/asm/constantPool/MergedTypeTableItem.java b/main/src/main/java/mockit/asm/constantPool/MergedTypeTableItem.java index 7872e2408..a5416afca 100644 --- a/main/src/main/java/mockit/asm/constantPool/MergedTypeTableItem.java +++ b/main/src/main/java/mockit/asm/constantPool/MergedTypeTableItem.java @@ -2,10 +2,10 @@ import static mockit.asm.constantPool.TypeTableItem.SpecialType.MERGED; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + final class MergedTypeTableItem extends TypeTableItem { private int type1; private int type2; diff --git a/main/src/main/java/mockit/asm/constantPool/MethodHandleItem.java b/main/src/main/java/mockit/asm/constantPool/MethodHandleItem.java index f43ed7582..00c044eb6 100644 --- a/main/src/main/java/mockit/asm/constantPool/MethodHandleItem.java +++ b/main/src/main/java/mockit/asm/constantPool/MethodHandleItem.java @@ -2,12 +2,12 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.HANDLE_BASE; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.util.MethodHandle; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class MethodHandleItem extends Item { private MethodHandle methodHandle; diff --git a/main/src/main/java/mockit/asm/constantPool/ModuleItem.java b/main/src/main/java/mockit/asm/constantPool/ModuleItem.java index 541bc0f93..f9aa6d9d1 100644 --- a/main/src/main/java/mockit/asm/constantPool/ModuleItem.java +++ b/main/src/main/java/mockit/asm/constantPool/ModuleItem.java @@ -1,9 +1,9 @@ package mockit.asm.constantPool; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class ModuleItem extends Item { @NonNull @SuppressWarnings("NullableProblems") diff --git a/main/src/main/java/mockit/asm/constantPool/NameAndTypeItem.java b/main/src/main/java/mockit/asm/constantPool/NameAndTypeItem.java index d9ddf561d..ef7b49862 100644 --- a/main/src/main/java/mockit/asm/constantPool/NameAndTypeItem.java +++ b/main/src/main/java/mockit/asm/constantPool/NameAndTypeItem.java @@ -2,10 +2,10 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.NAME_TYPE; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class NameAndTypeItem extends TypeOrMemberItem { public NameAndTypeItem(@NonNegative int index) { super(index); diff --git a/main/src/main/java/mockit/asm/constantPool/NormalTypeTableItem.java b/main/src/main/java/mockit/asm/constantPool/NormalTypeTableItem.java index e53464269..d7745b752 100644 --- a/main/src/main/java/mockit/asm/constantPool/NormalTypeTableItem.java +++ b/main/src/main/java/mockit/asm/constantPool/NormalTypeTableItem.java @@ -2,10 +2,10 @@ import static mockit.asm.constantPool.TypeTableItem.SpecialType.NORMAL; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + final class NormalTypeTableItem extends TypeTableItem { NormalTypeTableItem() { type = NORMAL; diff --git a/main/src/main/java/mockit/asm/constantPool/PackageItem.java b/main/src/main/java/mockit/asm/constantPool/PackageItem.java index 1dcd9bc0a..cff73ec88 100644 --- a/main/src/main/java/mockit/asm/constantPool/PackageItem.java +++ b/main/src/main/java/mockit/asm/constantPool/PackageItem.java @@ -1,9 +1,9 @@ package mockit.asm.constantPool; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class PackageItem extends Item { @NonNull @SuppressWarnings("NullableProblems") diff --git a/main/src/main/java/mockit/asm/constantPool/StringItem.java b/main/src/main/java/mockit/asm/constantPool/StringItem.java index cf148070f..1a12730aa 100644 --- a/main/src/main/java/mockit/asm/constantPool/StringItem.java +++ b/main/src/main/java/mockit/asm/constantPool/StringItem.java @@ -1,9 +1,9 @@ package mockit.asm.constantPool; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class StringItem extends Item { @NonNull @SuppressWarnings("NullableProblems") diff --git a/main/src/main/java/mockit/asm/constantPool/TypeOrMemberItem.java b/main/src/main/java/mockit/asm/constantPool/TypeOrMemberItem.java index 47ec18a11..d82e838aa 100644 --- a/main/src/main/java/mockit/asm/constantPool/TypeOrMemberItem.java +++ b/main/src/main/java/mockit/asm/constantPool/TypeOrMemberItem.java @@ -1,11 +1,11 @@ package mockit.asm.constantPool; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.types.JavaType; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - public class TypeOrMemberItem extends Item { @NonNull String name; diff --git a/main/src/main/java/mockit/asm/constantPool/TypeTableItem.java b/main/src/main/java/mockit/asm/constantPool/TypeTableItem.java index 4873c873b..1a20f1445 100644 --- a/main/src/main/java/mockit/asm/constantPool/TypeTableItem.java +++ b/main/src/main/java/mockit/asm/constantPool/TypeTableItem.java @@ -1,9 +1,9 @@ package mockit.asm.constantPool; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + abstract class TypeTableItem extends Item { /** * Defines constants for {@link #NORMAL normal}, {@link #UNINIT uninitialized}, and {@link #MERGED merged} special diff --git a/main/src/main/java/mockit/asm/constantPool/UninitializedTypeTableItem.java b/main/src/main/java/mockit/asm/constantPool/UninitializedTypeTableItem.java index 6b826fa6d..e04950425 100644 --- a/main/src/main/java/mockit/asm/constantPool/UninitializedTypeTableItem.java +++ b/main/src/main/java/mockit/asm/constantPool/UninitializedTypeTableItem.java @@ -2,10 +2,10 @@ import static mockit.asm.constantPool.TypeTableItem.SpecialType.UNINIT; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class UninitializedTypeTableItem extends TypeTableItem { @NonNegative int offset; diff --git a/main/src/main/java/mockit/asm/controlFlow/CFGAnalysis.java b/main/src/main/java/mockit/asm/controlFlow/CFGAnalysis.java index 17e8c0797..db80ee03f 100644 --- a/main/src/main/java/mockit/asm/controlFlow/CFGAnalysis.java +++ b/main/src/main/java/mockit/asm/controlFlow/CFGAnalysis.java @@ -13,6 +13,9 @@ import static mockit.asm.jvmConstants.Opcodes.PUTSTATIC; import static mockit.asm.jvmConstants.Opcodes.RETURN; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.constantPool.Item; import mockit.asm.constantPool.LongValueItem; @@ -23,9 +26,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * The control flow graph analysis algorithm, used to compute the maximum stack size for a method or constructor. *

diff --git a/main/src/main/java/mockit/asm/controlFlow/Frame.java b/main/src/main/java/mockit/asm/controlFlow/Frame.java index dbbaacffd..004e5525f 100644 --- a/main/src/main/java/mockit/asm/controlFlow/Frame.java +++ b/main/src/main/java/mockit/asm/controlFlow/Frame.java @@ -26,6 +26,9 @@ import static mockit.asm.controlFlow.FrameTypeMask.VALUE; import static mockit.asm.jvmConstants.Opcodes.*; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.constantPool.DynamicItem; import mockit.asm.constantPool.Item; @@ -40,9 +43,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Information about the input and output stack map frames of a basic block. *

diff --git a/main/src/main/java/mockit/asm/controlFlow/Label.java b/main/src/main/java/mockit/asm/controlFlow/Label.java index 3ab09d023..ff443f1e5 100644 --- a/main/src/main/java/mockit/asm/controlFlow/Label.java +++ b/main/src/main/java/mockit/asm/controlFlow/Label.java @@ -1,12 +1,12 @@ package mockit.asm.controlFlow; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A label represents a position in the bytecode of a method. Labels are used for jump, goto, and switch instructions, * and for try catch blocks. A label designates the instruction that is just after. Note however that there can diff --git a/main/src/main/java/mockit/asm/controlFlow/StackMapTableWriter.java b/main/src/main/java/mockit/asm/controlFlow/StackMapTableWriter.java index 804f083e4..387021b6d 100644 --- a/main/src/main/java/mockit/asm/controlFlow/StackMapTableWriter.java +++ b/main/src/main/java/mockit/asm/controlFlow/StackMapTableWriter.java @@ -8,6 +8,8 @@ import static mockit.asm.controlFlow.StackMapTableWriter.LocalsAndStackItemsDiff.SAME_LOCALS_1_STACK_ITEM_FRAME; import static mockit.asm.controlFlow.StackMapTableWriter.LocalsAndStackItemsDiff.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.constantPool.UninitializedTypeTableItem; @@ -17,8 +19,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Writes the "StackMapTable" method attribute (or "StackMap" for classfiles older than Java 6). */ diff --git a/main/src/main/java/mockit/asm/exceptionHandling/ExceptionHandler.java b/main/src/main/java/mockit/asm/exceptionHandling/ExceptionHandler.java index 0eedd2ba6..4a2b49390 100644 --- a/main/src/main/java/mockit/asm/exceptionHandling/ExceptionHandler.java +++ b/main/src/main/java/mockit/asm/exceptionHandling/ExceptionHandler.java @@ -1,13 +1,13 @@ package mockit.asm.exceptionHandling; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.controlFlow.Label; import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Information about an exception handler block. */ diff --git a/main/src/main/java/mockit/asm/exceptionHandling/ExceptionHandling.java b/main/src/main/java/mockit/asm/exceptionHandling/ExceptionHandling.java index c0dbb70e6..c7229393e 100644 --- a/main/src/main/java/mockit/asm/exceptionHandling/ExceptionHandling.java +++ b/main/src/main/java/mockit/asm/exceptionHandling/ExceptionHandling.java @@ -1,5 +1,8 @@ package mockit.asm.exceptionHandling; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; @@ -11,9 +14,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ExceptionHandling { @NonNull private final List handlers; diff --git a/main/src/main/java/mockit/asm/fields/FieldReader.java b/main/src/main/java/mockit/asm/fields/FieldReader.java index bd9fbb419..051781cf8 100644 --- a/main/src/main/java/mockit/asm/fields/FieldReader.java +++ b/main/src/main/java/mockit/asm/fields/FieldReader.java @@ -1,14 +1,14 @@ package mockit.asm.fields; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.AnnotatedReader; import mockit.asm.classes.ClassReader; import mockit.asm.classes.ClassVisitor; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class FieldReader extends AnnotatedReader { @NonNull private final ClassVisitor cv; diff --git a/main/src/main/java/mockit/asm/fields/FieldVisitor.java b/main/src/main/java/mockit/asm/fields/FieldVisitor.java index 90b2a1f45..97dabd653 100644 --- a/main/src/main/java/mockit/asm/fields/FieldVisitor.java +++ b/main/src/main/java/mockit/asm/fields/FieldVisitor.java @@ -1,5 +1,8 @@ package mockit.asm.fields; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.BaseWriter; import mockit.asm.SignatureWriter; import mockit.asm.classes.ClassWriter; @@ -9,9 +12,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A visitor to visit a Java field, in the following order: ({@link #visitAnnotation})* {@link #visitEnd}. */ diff --git a/main/src/main/java/mockit/asm/metadata/ClassMetadataReader.java b/main/src/main/java/mockit/asm/metadata/ClassMetadataReader.java index 605371f17..8ca51f670 100644 --- a/main/src/main/java/mockit/asm/metadata/ClassMetadataReader.java +++ b/main/src/main/java/mockit/asm/metadata/ClassMetadataReader.java @@ -4,6 +4,9 @@ */ package mockit.asm.metadata; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Collections; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ClassMetadataReader extends ObjectWithAttributes { private static final Charset UTF8 = Charset.forName("UTF-8"); private static final ConstantPoolTag[] CONSTANT_POOL_TAGS = ConstantPoolTag.values(); diff --git a/main/src/main/java/mockit/asm/metadata/ObjectWithAttributes.java b/main/src/main/java/mockit/asm/metadata/ObjectWithAttributes.java index d466a375d..7de47f823 100644 --- a/main/src/main/java/mockit/asm/metadata/ObjectWithAttributes.java +++ b/main/src/main/java/mockit/asm/metadata/ObjectWithAttributes.java @@ -1,12 +1,12 @@ package mockit.asm.metadata; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import mockit.asm.metadata.ClassMetadataReader.AnnotationInfo; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - class ObjectWithAttributes { @Nullable public List annotations; diff --git a/main/src/main/java/mockit/asm/methods/ExceptionsWriter.java b/main/src/main/java/mockit/asm/methods/ExceptionsWriter.java index 8f7a56a98..7af7f6e0f 100644 --- a/main/src/main/java/mockit/asm/methods/ExceptionsWriter.java +++ b/main/src/main/java/mockit/asm/methods/ExceptionsWriter.java @@ -1,13 +1,13 @@ package mockit.asm.methods; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.util.ByteVector; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Stores the exceptions that can be thrown by a method/constructor, and writes it to the "Exceptions" attribute. For * each thrown exception, stores the index of the constant pool item containing the internal name of the thrown diff --git a/main/src/main/java/mockit/asm/methods/LineNumberTableWriter.java b/main/src/main/java/mockit/asm/methods/LineNumberTableWriter.java index b5a40251c..e7341b491 100644 --- a/main/src/main/java/mockit/asm/methods/LineNumberTableWriter.java +++ b/main/src/main/java/mockit/asm/methods/LineNumberTableWriter.java @@ -1,5 +1,8 @@ package mockit.asm.methods; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.controlFlow.Label; @@ -7,9 +10,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Writes the bytecode for the "LineNumberTable" method code attribute. */ diff --git a/main/src/main/java/mockit/asm/methods/LocalVariableTableWriter.java b/main/src/main/java/mockit/asm/methods/LocalVariableTableWriter.java index 6c69f6940..9aee1501b 100644 --- a/main/src/main/java/mockit/asm/methods/LocalVariableTableWriter.java +++ b/main/src/main/java/mockit/asm/methods/LocalVariableTableWriter.java @@ -1,5 +1,8 @@ package mockit.asm.methods; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.constantPool.AttributeWriter; import mockit.asm.constantPool.ConstantPoolGeneration; import mockit.asm.controlFlow.Label; @@ -7,9 +10,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Writes the bytecode for the "LocalVariableTable" and "LocalVariableTypeTable" method code attributes. */ diff --git a/main/src/main/java/mockit/asm/methods/MethodReader.java b/main/src/main/java/mockit/asm/methods/MethodReader.java index 10c82fe56..81305eb6d 100644 --- a/main/src/main/java/mockit/asm/methods/MethodReader.java +++ b/main/src/main/java/mockit/asm/methods/MethodReader.java @@ -26,6 +26,9 @@ import static mockit.asm.jvmConstants.Opcodes.ISTORE; import static mockit.asm.jvmConstants.Opcodes.ISTORE_0; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.AnnotatedReader; import mockit.asm.annotations.AnnotationVisitor; import mockit.asm.classes.ClassReader; @@ -37,9 +40,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - @SuppressWarnings("OverlyComplexClass") public final class MethodReader extends AnnotatedReader { @NonNull diff --git a/main/src/main/java/mockit/asm/methods/MethodVisitor.java b/main/src/main/java/mockit/asm/methods/MethodVisitor.java index 0d97008ad..5225bbc49 100644 --- a/main/src/main/java/mockit/asm/methods/MethodVisitor.java +++ b/main/src/main/java/mockit/asm/methods/MethodVisitor.java @@ -1,5 +1,8 @@ package mockit.asm.methods; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.BaseWriter; import mockit.asm.annotations.AnnotationVisitor; import mockit.asm.constantPool.ConstantPoolGeneration; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A visitor to visit a Java method, in the following order:
* ({@link #visitAnnotation})* ({@link #visitParameterAnnotation})* [(visitXInsn | diff --git a/main/src/main/java/mockit/asm/methods/MethodWriter.java b/main/src/main/java/mockit/asm/methods/MethodWriter.java index e86ad658b..68ee512a4 100644 --- a/main/src/main/java/mockit/asm/methods/MethodWriter.java +++ b/main/src/main/java/mockit/asm/methods/MethodWriter.java @@ -20,6 +20,9 @@ import static mockit.asm.jvmConstants.Opcodes.TABLESWITCH; import static mockit.asm.jvmConstants.Opcodes.WIDE; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.SignatureWriter; import mockit.asm.annotations.AnnotationVisitor; import mockit.asm.classes.ClassWriter; @@ -41,9 +44,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A {@link MethodVisitor} that generates methods in bytecode form. Each visit method of this class appends the bytecode * corresponding to the visited instruction to a byte vector, in the order these methods are called. diff --git a/main/src/main/java/mockit/asm/methods/WrappingMethodVisitor.java b/main/src/main/java/mockit/asm/methods/WrappingMethodVisitor.java index 07494c302..a0e058ba4 100644 --- a/main/src/main/java/mockit/asm/methods/WrappingMethodVisitor.java +++ b/main/src/main/java/mockit/asm/methods/WrappingMethodVisitor.java @@ -1,14 +1,14 @@ package mockit.asm.methods; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.annotations.AnnotationVisitor; import mockit.asm.controlFlow.Label; import mockit.asm.util.MethodHandle; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Same as {@link MethodVisitor}, except it always wraps a {@link MethodWriter}. */ diff --git a/main/src/main/java/mockit/asm/types/ArrayType.java b/main/src/main/java/mockit/asm/types/ArrayType.java index 7c19240da..4e1ea2c26 100644 --- a/main/src/main/java/mockit/asm/types/ArrayType.java +++ b/main/src/main/java/mockit/asm/types/ArrayType.java @@ -1,9 +1,9 @@ package mockit.asm.types; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class ArrayType extends ReferenceType { @NonNull public static ArrayType create(@NonNull String typeDesc) { diff --git a/main/src/main/java/mockit/asm/types/JavaType.java b/main/src/main/java/mockit/asm/types/JavaType.java index 1ec635798..54a93537a 100644 --- a/main/src/main/java/mockit/asm/types/JavaType.java +++ b/main/src/main/java/mockit/asm/types/JavaType.java @@ -1,12 +1,12 @@ package mockit.asm.types; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.reflect.Constructor; import java.lang.reflect.Method; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * A Java field or method type. This class can be used to make it easier to manipulate type and method descriptors. */ diff --git a/main/src/main/java/mockit/asm/types/MethodType.java b/main/src/main/java/mockit/asm/types/MethodType.java index abccf4ad9..a3191fd08 100644 --- a/main/src/main/java/mockit/asm/types/MethodType.java +++ b/main/src/main/java/mockit/asm/types/MethodType.java @@ -1,9 +1,9 @@ package mockit.asm.types; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class MethodType extends ReferenceType { /** * Returns the Java type corresponding to the given method descriptor. diff --git a/main/src/main/java/mockit/asm/types/ObjectType.java b/main/src/main/java/mockit/asm/types/ObjectType.java index 780f249ca..f68ddecd0 100644 --- a/main/src/main/java/mockit/asm/types/ObjectType.java +++ b/main/src/main/java/mockit/asm/types/ObjectType.java @@ -1,9 +1,9 @@ package mockit.asm.types; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class ObjectType extends ReferenceType { @NonNull public static ObjectType create(@NonNull String internalName) { diff --git a/main/src/main/java/mockit/asm/types/PrimitiveType.java b/main/src/main/java/mockit/asm/types/PrimitiveType.java index f451c08be..362607c86 100644 --- a/main/src/main/java/mockit/asm/types/PrimitiveType.java +++ b/main/src/main/java/mockit/asm/types/PrimitiveType.java @@ -11,13 +11,13 @@ import static mockit.asm.jvmConstants.Opcodes.LCONST_0; import static mockit.asm.jvmConstants.Opcodes.LLOAD; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.jvmConstants.ArrayElementType; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class PrimitiveType extends JavaType { private static final Class[] TYPES = { void.class, boolean.class, char.class, byte.class, short.class, int.class, float.class, long.class, double.class }; diff --git a/main/src/main/java/mockit/asm/types/ReferenceType.java b/main/src/main/java/mockit/asm/types/ReferenceType.java index db61c96ed..796f825c5 100644 --- a/main/src/main/java/mockit/asm/types/ReferenceType.java +++ b/main/src/main/java/mockit/asm/types/ReferenceType.java @@ -3,10 +3,10 @@ import static mockit.asm.jvmConstants.Opcodes.ACONST_NULL; import static mockit.asm.jvmConstants.Opcodes.ALOAD; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public abstract class ReferenceType extends JavaType { /** * The internal name of this Java reference type. diff --git a/main/src/main/java/mockit/asm/util/ByteVector.java b/main/src/main/java/mockit/asm/util/ByteVector.java index 6951fe800..54c04dc3d 100644 --- a/main/src/main/java/mockit/asm/util/ByteVector.java +++ b/main/src/main/java/mockit/asm/util/ByteVector.java @@ -1,9 +1,9 @@ package mockit.asm.util; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + /** * A dynamically extensible vector of bytes. This class is roughly equivalent to a DataOutputStream on top of a * ByteArrayOutputStream, but is more efficient. diff --git a/main/src/main/java/mockit/asm/util/BytecodeReader.java b/main/src/main/java/mockit/asm/util/BytecodeReader.java index a86ebb154..ee19d2f5d 100644 --- a/main/src/main/java/mockit/asm/util/BytecodeReader.java +++ b/main/src/main/java/mockit/asm/util/BytecodeReader.java @@ -18,6 +18,9 @@ import static mockit.asm.jvmConstants.ConstantPoolTypes.STRING; import static mockit.asm.jvmConstants.ConstantPoolTypes.UTF8; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.constantPool.DynamicItem; import mockit.asm.jvmConstants.ConstantPoolTypes; import mockit.asm.types.JavaType; @@ -26,9 +29,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public class BytecodeReader { /** * The class to be parsed. The content of this array must not be modified. diff --git a/main/src/main/java/mockit/asm/util/MethodHandle.java b/main/src/main/java/mockit/asm/util/MethodHandle.java index 0282eee15..18a249fd2 100644 --- a/main/src/main/java/mockit/asm/util/MethodHandle.java +++ b/main/src/main/java/mockit/asm/util/MethodHandle.java @@ -1,9 +1,9 @@ package mockit.asm.util; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + /** * A reference to a method. */ diff --git a/main/src/main/java/mockit/coverage/AccretionFile.java b/main/src/main/java/mockit/coverage/AccretionFile.java index c979f8d6b..508405131 100644 --- a/main/src/main/java/mockit/coverage/AccretionFile.java +++ b/main/src/main/java/mockit/coverage/AccretionFile.java @@ -4,13 +4,13 @@ */ package mockit.coverage; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.File; import java.io.IOException; import mockit.coverage.data.CoverageData; -import edu.umd.cs.findbugs.annotations.NonNull; - final class AccretionFile { @NonNull private final File outputFile; diff --git a/main/src/main/java/mockit/coverage/CallPoint.java b/main/src/main/java/mockit/coverage/CallPoint.java index 76f0a8dfb..cb38709b9 100644 --- a/main/src/main/java/mockit/coverage/CallPoint.java +++ b/main/src/main/java/mockit/coverage/CallPoint.java @@ -6,6 +6,9 @@ import static java.lang.reflect.Modifier.isPublic; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.Serializable; import java.lang.annotation.Annotation; import java.lang.reflect.Method; @@ -16,9 +19,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class CallPoint implements Serializable { private static final long serialVersionUID = 362727169057343840L; private static final Map steCache = new HashMap<>(); diff --git a/main/src/main/java/mockit/coverage/CodeCoverage.java b/main/src/main/java/mockit/coverage/CodeCoverage.java index 7c03be71f..88e3b25ea 100644 --- a/main/src/main/java/mockit/coverage/CodeCoverage.java +++ b/main/src/main/java/mockit/coverage/CodeCoverage.java @@ -4,6 +4,9 @@ */ package mockit.coverage; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassFileTransformer; import java.security.ProtectionDomain; @@ -12,9 +15,6 @@ import mockit.coverage.modification.ClassesNotLoaded; import mockit.internal.startup.Startup; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class CodeCoverage implements ClassFileTransformer { @NonNull private final ClassModification classModification; diff --git a/main/src/main/java/mockit/coverage/Configuration.java b/main/src/main/java/mockit/coverage/Configuration.java index 598199ab6..125a351a0 100644 --- a/main/src/main/java/mockit/coverage/Configuration.java +++ b/main/src/main/java/mockit/coverage/Configuration.java @@ -4,11 +4,11 @@ */ package mockit.coverage; -import java.io.File; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.io.File; + public final class Configuration { private static final String COVERAGE_PREFIX = "coverage-"; diff --git a/main/src/main/java/mockit/coverage/CoverageCheck.java b/main/src/main/java/mockit/coverage/CoverageCheck.java index fb78a8ef8..b266cecfa 100644 --- a/main/src/main/java/mockit/coverage/CoverageCheck.java +++ b/main/src/main/java/mockit/coverage/CoverageCheck.java @@ -4,6 +4,9 @@ */ package mockit.coverage; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.File; import java.io.IOException; import java.util.ArrayList; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class CoverageCheck { private static final String configuration = Configuration.getProperty("check", ""); diff --git a/main/src/main/java/mockit/coverage/CoveragePercentage.java b/main/src/main/java/mockit/coverage/CoveragePercentage.java index 418de4d99..868d976f1 100644 --- a/main/src/main/java/mockit/coverage/CoveragePercentage.java +++ b/main/src/main/java/mockit/coverage/CoveragePercentage.java @@ -4,10 +4,10 @@ */ package mockit.coverage; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; +import org.checkerframework.checker.index.qual.NonNegative; + public final class CoveragePercentage { private CoveragePercentage() { } diff --git a/main/src/main/java/mockit/coverage/DataFileMerging.java b/main/src/main/java/mockit/coverage/DataFileMerging.java index 52289b0cd..72027e2a0 100644 --- a/main/src/main/java/mockit/coverage/DataFileMerging.java +++ b/main/src/main/java/mockit/coverage/DataFileMerging.java @@ -4,6 +4,8 @@ */ package mockit.coverage; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.File; import java.io.IOException; import java.util.ArrayList; @@ -11,8 +13,6 @@ import mockit.coverage.data.CoverageData; -import edu.umd.cs.findbugs.annotations.NonNull; - final class DataFileMerging { @NonNull private final List inputFiles; diff --git a/main/src/main/java/mockit/coverage/OutputFileGenerator.java b/main/src/main/java/mockit/coverage/OutputFileGenerator.java index e91c86647..7b58d48e7 100644 --- a/main/src/main/java/mockit/coverage/OutputFileGenerator.java +++ b/main/src/main/java/mockit/coverage/OutputFileGenerator.java @@ -4,15 +4,15 @@ */ package mockit.coverage; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.File; import java.io.IOException; import mockit.coverage.data.CoverageData; import mockit.coverage.reporting.CoverageReport; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - @SuppressWarnings("DynamicRegexReplaceableByCompiledPattern") final class OutputFileGenerator { private static final String[] ALL_SOURCE_DIRS = {}; diff --git a/main/src/main/java/mockit/coverage/TestRun.java b/main/src/main/java/mockit/coverage/TestRun.java index 309279206..19d8db6e3 100644 --- a/main/src/main/java/mockit/coverage/TestRun.java +++ b/main/src/main/java/mockit/coverage/TestRun.java @@ -4,6 +4,8 @@ */ package mockit.coverage; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.coverage.data.CoverageData; import mockit.coverage.data.FileCoverageData; import mockit.coverage.lines.PerFileLineCoverage; @@ -11,8 +13,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - @SuppressWarnings("unused") public final class TestRun { private static final Object LOCK = new Object(); diff --git a/main/src/main/java/mockit/coverage/XmlFile.java b/main/src/main/java/mockit/coverage/XmlFile.java index b0a955a10..1d14c79b2 100644 --- a/main/src/main/java/mockit/coverage/XmlFile.java +++ b/main/src/main/java/mockit/coverage/XmlFile.java @@ -4,6 +4,8 @@ */ package mockit.coverage; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.File; import java.io.FileWriter; import java.io.IOException; @@ -18,8 +20,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Generates a XML file containing the coverage data gathered by the test run. The XML schema used is the one * defined by the SonarQube project: diff --git a/main/src/main/java/mockit/coverage/data/CoverageData.java b/main/src/main/java/mockit/coverage/data/CoverageData.java index 47cac1212..135ff7417 100644 --- a/main/src/main/java/mockit/coverage/data/CoverageData.java +++ b/main/src/main/java/mockit/coverage/data/CoverageData.java @@ -4,6 +4,9 @@ */ package mockit.coverage.data; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; @@ -27,9 +30,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Coverage data captured for all source files exercised during a test run. */ diff --git a/main/src/main/java/mockit/coverage/data/FileCoverageData.java b/main/src/main/java/mockit/coverage/data/FileCoverageData.java index 8cbc6e510..f716ae862 100644 --- a/main/src/main/java/mockit/coverage/data/FileCoverageData.java +++ b/main/src/main/java/mockit/coverage/data/FileCoverageData.java @@ -4,6 +4,9 @@ */ package mockit.coverage.data; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.Serializable; import mockit.coverage.CoveragePercentage; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Coverage data gathered for the lines, branching points, and fields of a single source file. */ diff --git a/main/src/main/java/mockit/coverage/dataItems/FieldData.java b/main/src/main/java/mockit/coverage/dataItems/FieldData.java index 278f88016..064eea7ef 100644 --- a/main/src/main/java/mockit/coverage/dataItems/FieldData.java +++ b/main/src/main/java/mockit/coverage/dataItems/FieldData.java @@ -4,15 +4,15 @@ */ package mockit.coverage.dataItems; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.IOException; import java.io.ObjectOutputStream; import java.io.Serializable; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public abstract class FieldData implements Serializable { private static final long serialVersionUID = 8565599590976858508L; diff --git a/main/src/main/java/mockit/coverage/dataItems/InstanceFieldData.java b/main/src/main/java/mockit/coverage/dataItems/InstanceFieldData.java index 930844580..8997cc7ed 100644 --- a/main/src/main/java/mockit/coverage/dataItems/InstanceFieldData.java +++ b/main/src/main/java/mockit/coverage/dataItems/InstanceFieldData.java @@ -6,6 +6,8 @@ import static java.util.Collections.emptyList; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.Collection; import java.util.HashMap; import java.util.LinkedList; @@ -14,8 +16,6 @@ import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class InstanceFieldData extends FieldData { private static final long serialVersionUID = 6991762113575259754L; diff --git a/main/src/main/java/mockit/coverage/dataItems/PerFileDataCoverage.java b/main/src/main/java/mockit/coverage/dataItems/PerFileDataCoverage.java index 01da6b6eb..2fa080e93 100644 --- a/main/src/main/java/mockit/coverage/dataItems/PerFileDataCoverage.java +++ b/main/src/main/java/mockit/coverage/dataItems/PerFileDataCoverage.java @@ -4,6 +4,9 @@ */ package mockit.coverage.dataItems; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.IOException; import java.io.ObjectInputStream; import java.util.ArrayList; @@ -17,9 +20,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class PerFileDataCoverage implements PerFileCoverage { private static final long serialVersionUID = -4561686103982673490L; diff --git a/main/src/main/java/mockit/coverage/dataItems/StaticFieldData.java b/main/src/main/java/mockit/coverage/dataItems/StaticFieldData.java index a5138cfe7..8518ba269 100644 --- a/main/src/main/java/mockit/coverage/dataItems/StaticFieldData.java +++ b/main/src/main/java/mockit/coverage/dataItems/StaticFieldData.java @@ -4,13 +4,13 @@ */ package mockit.coverage.dataItems; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.HashMap; import java.util.Map; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class StaticFieldData extends FieldData { private static final long serialVersionUID = -6596622341651601060L; diff --git a/main/src/main/java/mockit/coverage/lines/BranchCoverageData.java b/main/src/main/java/mockit/coverage/lines/BranchCoverageData.java index f7867fc25..2eb1dee89 100644 --- a/main/src/main/java/mockit/coverage/lines/BranchCoverageData.java +++ b/main/src/main/java/mockit/coverage/lines/BranchCoverageData.java @@ -4,6 +4,8 @@ */ package mockit.coverage.lines; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; @@ -12,8 +14,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Coverage data gathered for a branch inside a line of source code. */ diff --git a/main/src/main/java/mockit/coverage/lines/LineCoverageData.java b/main/src/main/java/mockit/coverage/lines/LineCoverageData.java index e3b49bbce..704c25f91 100644 --- a/main/src/main/java/mockit/coverage/lines/LineCoverageData.java +++ b/main/src/main/java/mockit/coverage/lines/LineCoverageData.java @@ -6,6 +6,9 @@ import static java.util.Collections.emptyList; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -15,9 +18,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Coverage data gathered for a single executable line of code in a source file. */ diff --git a/main/src/main/java/mockit/coverage/lines/LineSegmentData.java b/main/src/main/java/mockit/coverage/lines/LineSegmentData.java index 374dfa9e3..697f3af0a 100644 --- a/main/src/main/java/mockit/coverage/lines/LineSegmentData.java +++ b/main/src/main/java/mockit/coverage/lines/LineSegmentData.java @@ -4,6 +4,9 @@ */ package mockit.coverage.lines; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.Serializable; import java.util.ArrayList; import java.util.List; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public class LineSegmentData implements Serializable { private static final long serialVersionUID = -6233980722802474992L; private static final int MAX_CALL_POINTS = Integer.parseInt(Configuration.getProperty("maxCallPoints", "10")); diff --git a/main/src/main/java/mockit/coverage/lines/PerFileLineCoverage.java b/main/src/main/java/mockit/coverage/lines/PerFileLineCoverage.java index f6f6e931b..5132e01d7 100644 --- a/main/src/main/java/mockit/coverage/lines/PerFileLineCoverage.java +++ b/main/src/main/java/mockit/coverage/lines/PerFileLineCoverage.java @@ -4,6 +4,9 @@ */ package mockit.coverage.lines; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.IOException; import java.io.ObjectInputStream; import java.util.HashMap; @@ -16,9 +19,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class PerFileLineCoverage implements PerFileCoverage { private static final long serialVersionUID = 6318915843739466316L; private static final int[] NO_EXECUTIONS_YET = {}; diff --git a/main/src/main/java/mockit/coverage/modification/CFGTracking.java b/main/src/main/java/mockit/coverage/modification/CFGTracking.java index fb031531a..73823e54f 100644 --- a/main/src/main/java/mockit/coverage/modification/CFGTracking.java +++ b/main/src/main/java/mockit/coverage/modification/CFGTracking.java @@ -8,6 +8,8 @@ import static mockit.asm.jvmConstants.Opcodes.ICONST_1; import static mockit.asm.jvmConstants.Opcodes.INVOKEVIRTUAL; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.ArrayList; import java.util.List; @@ -18,8 +20,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - final class CFGTracking { @NonNull private final PerFileLineCoverage lineCoverageInfo; diff --git a/main/src/main/java/mockit/coverage/modification/ClassModification.java b/main/src/main/java/mockit/coverage/modification/ClassModification.java index 465f0d599..85934963c 100644 --- a/main/src/main/java/mockit/coverage/modification/ClassModification.java +++ b/main/src/main/java/mockit/coverage/modification/ClassModification.java @@ -4,6 +4,9 @@ */ package mockit.coverage.modification; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.security.ProtectionDomain; import java.util.ArrayList; import java.util.HashSet; @@ -12,9 +15,6 @@ import mockit.asm.classes.ClassReader; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ClassModification { @NonNull private final Set modifiedClasses; diff --git a/main/src/main/java/mockit/coverage/modification/ClassSelection.java b/main/src/main/java/mockit/coverage/modification/ClassSelection.java index 8cc4f7950..fe4680a17 100644 --- a/main/src/main/java/mockit/coverage/modification/ClassSelection.java +++ b/main/src/main/java/mockit/coverage/modification/ClassSelection.java @@ -8,6 +8,9 @@ import static mockit.internal.util.GeneratedClasses.isExternallyGeneratedSubclass; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.net.URL; import java.security.CodeSource; import java.security.ProtectionDomain; @@ -16,9 +19,6 @@ import mockit.coverage.Configuration; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class ClassSelection { private static final String THIS_CLASS_NAME = ClassSelection.class.getName(); private static final ClassLoader THIS_CLASS_LOADER = ClassSelection.class.getClassLoader(); diff --git a/main/src/main/java/mockit/coverage/modification/ClassesNotLoaded.java b/main/src/main/java/mockit/coverage/modification/ClassesNotLoaded.java index 6cd814a09..d461e55b9 100644 --- a/main/src/main/java/mockit/coverage/modification/ClassesNotLoaded.java +++ b/main/src/main/java/mockit/coverage/modification/ClassesNotLoaded.java @@ -4,6 +4,8 @@ */ package mockit.coverage.modification; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.File; import java.security.ProtectionDomain; import java.util.HashSet; @@ -11,8 +13,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Finds and loads all classes that should also be measured, but were not loaded until now. */ diff --git a/main/src/main/java/mockit/coverage/modification/CoverageModifier.java b/main/src/main/java/mockit/coverage/modification/CoverageModifier.java index d638b00f2..cc15c89fc 100644 --- a/main/src/main/java/mockit/coverage/modification/CoverageModifier.java +++ b/main/src/main/java/mockit/coverage/modification/CoverageModifier.java @@ -13,6 +13,9 @@ import static mockit.asm.jvmConstants.Access.SUPER; import static mockit.asm.jvmConstants.Access.SYNTHETIC; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.HashMap; import java.util.Map; @@ -27,9 +30,6 @@ import mockit.coverage.data.FileCoverageData; import mockit.internal.ClassFile; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class CoverageModifier extends WrappingClassVisitor { private static final Map INNER_CLASS_MODIFIERS = new HashMap<>(); private static final int FIELD_MODIFIERS_TO_IGNORE = FINAL + SYNTHETIC; diff --git a/main/src/main/java/mockit/coverage/modification/MethodModifier.java b/main/src/main/java/mockit/coverage/modification/MethodModifier.java index 3313c4595..3d5110057 100644 --- a/main/src/main/java/mockit/coverage/modification/MethodModifier.java +++ b/main/src/main/java/mockit/coverage/modification/MethodModifier.java @@ -26,6 +26,9 @@ import static mockit.asm.jvmConstants.Opcodes.RETURN; import static mockit.asm.jvmConstants.Opcodes.SIPUSH; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.annotations.AnnotationVisitor; import mockit.asm.controlFlow.Label; import mockit.asm.methods.MethodWriter; @@ -35,9 +38,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class MethodModifier extends WrappingMethodVisitor { private static final String DATA_RECORDING_CLASS = "mockit/coverage/TestRun"; diff --git a/main/src/main/java/mockit/coverage/reporting/CoverageReport.java b/main/src/main/java/mockit/coverage/reporting/CoverageReport.java index 5ea7e03f0..232a5ad28 100644 --- a/main/src/main/java/mockit/coverage/reporting/CoverageReport.java +++ b/main/src/main/java/mockit/coverage/reporting/CoverageReport.java @@ -4,6 +4,9 @@ */ package mockit.coverage.reporting; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.File; import java.io.IOException; import java.util.ArrayList; @@ -21,9 +24,6 @@ import mockit.coverage.reporting.sourceFiles.FileCoverageReport; import mockit.coverage.reporting.sourceFiles.InputFile; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class CoverageReport { @NonNull private final String outputDir; diff --git a/main/src/main/java/mockit/coverage/reporting/ListOfCallPoints.java b/main/src/main/java/mockit/coverage/reporting/ListOfCallPoints.java index 4b042dc62..d1a8b8bf6 100644 --- a/main/src/main/java/mockit/coverage/reporting/ListOfCallPoints.java +++ b/main/src/main/java/mockit/coverage/reporting/ListOfCallPoints.java @@ -4,14 +4,14 @@ */ package mockit.coverage.reporting; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import java.util.regex.Pattern; import mockit.coverage.CallPoint; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ListOfCallPoints { @NonNull private static final String EOL = System.lineSeparator(); diff --git a/main/src/main/java/mockit/coverage/reporting/OutputFile.java b/main/src/main/java/mockit/coverage/reporting/OutputFile.java index 48698c7f6..902ad7437 100644 --- a/main/src/main/java/mockit/coverage/reporting/OutputFile.java +++ b/main/src/main/java/mockit/coverage/reporting/OutputFile.java @@ -4,14 +4,14 @@ */ package mockit.coverage.reporting; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.File; import java.io.IOException; import java.io.PrintWriter; import java.nio.charset.StandardCharsets; import java.util.regex.Pattern; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class OutputFile extends PrintWriter { private static final Pattern PATH_SEPARATOR = Pattern.compile("/"); diff --git a/main/src/main/java/mockit/coverage/reporting/SourceFiles.java b/main/src/main/java/mockit/coverage/reporting/SourceFiles.java index a37038f00..991d3f126 100644 --- a/main/src/main/java/mockit/coverage/reporting/SourceFiles.java +++ b/main/src/main/java/mockit/coverage/reporting/SourceFiles.java @@ -4,12 +4,12 @@ */ package mockit.coverage.reporting; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.File; import java.util.ArrayList; import java.util.List; -import edu.umd.cs.findbugs.annotations.NonNull; - final class SourceFiles { @NonNull private final List srcDirs = new ArrayList<>(); diff --git a/main/src/main/java/mockit/coverage/reporting/StaticFiles.java b/main/src/main/java/mockit/coverage/reporting/StaticFiles.java index a27201b7f..981824eb7 100644 --- a/main/src/main/java/mockit/coverage/reporting/StaticFiles.java +++ b/main/src/main/java/mockit/coverage/reporting/StaticFiles.java @@ -4,6 +4,8 @@ */ package mockit.coverage.reporting; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; @@ -15,8 +17,6 @@ import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; - final class StaticFiles { @NonNull private final String outputDir; diff --git a/main/src/main/java/mockit/coverage/reporting/dataCoverage/DataCoverageOutput.java b/main/src/main/java/mockit/coverage/reporting/dataCoverage/DataCoverageOutput.java index f856de4e2..0a09e5273 100644 --- a/main/src/main/java/mockit/coverage/reporting/dataCoverage/DataCoverageOutput.java +++ b/main/src/main/java/mockit/coverage/reporting/dataCoverage/DataCoverageOutput.java @@ -4,6 +4,9 @@ */ package mockit.coverage.reporting.dataCoverage; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.coverage.dataItems.FieldData; import mockit.coverage.dataItems.InstanceFieldData; import mockit.coverage.dataItems.PerFileDataCoverage; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class DataCoverageOutput { @NonNull private final StringBuilder openingTag; diff --git a/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineCoverageFormatter.java b/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineCoverageFormatter.java index 6f92fbefd..769d0344a 100644 --- a/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineCoverageFormatter.java +++ b/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineCoverageFormatter.java @@ -4,6 +4,9 @@ */ package mockit.coverage.reporting.lineCoverage; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import mockit.coverage.CallPoint; @@ -12,9 +15,6 @@ import mockit.coverage.reporting.ListOfCallPoints; import mockit.coverage.reporting.parsing.LineParser; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class LineCoverageFormatter { @NonNull private final StringBuilder formattedLine; diff --git a/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineCoverageOutput.java b/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineCoverageOutput.java index e7576e35a..91f63bf73 100644 --- a/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineCoverageOutput.java +++ b/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineCoverageOutput.java @@ -4,6 +4,8 @@ */ package mockit.coverage.reporting.lineCoverage; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.PrintWriter; import mockit.coverage.lines.PerFileLineCoverage; @@ -11,8 +13,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class LineCoverageOutput { @NonNull private final PrintWriter output; diff --git a/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineSegmentsFormatter.java b/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineSegmentsFormatter.java index acf13bcfd..58dbeec86 100644 --- a/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineSegmentsFormatter.java +++ b/main/src/main/java/mockit/coverage/reporting/lineCoverage/LineSegmentsFormatter.java @@ -6,6 +6,9 @@ import static java.lang.Character.isWhitespace; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import mockit.coverage.CallPoint; @@ -18,9 +21,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class LineSegmentsFormatter { @Nullable private final ListOfCallPoints listOfCallPoints; diff --git a/main/src/main/java/mockit/coverage/reporting/packages/IndexPage.java b/main/src/main/java/mockit/coverage/reporting/packages/IndexPage.java index 8027667f5..e1b7a69d8 100644 --- a/main/src/main/java/mockit/coverage/reporting/packages/IndexPage.java +++ b/main/src/main/java/mockit/coverage/reporting/packages/IndexPage.java @@ -4,6 +4,9 @@ */ package mockit.coverage.reporting.packages; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.File; import java.io.IOException; import java.lang.reflect.Method; @@ -22,9 +25,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class IndexPage extends ListWithFilesAndPercentages { @Nullable private final List sourceDirs; diff --git a/main/src/main/java/mockit/coverage/reporting/packages/ListWithFilesAndPercentages.java b/main/src/main/java/mockit/coverage/reporting/packages/ListWithFilesAndPercentages.java index 3dbf7dbcf..7689e60e2 100644 --- a/main/src/main/java/mockit/coverage/reporting/packages/ListWithFilesAndPercentages.java +++ b/main/src/main/java/mockit/coverage/reporting/packages/ListWithFilesAndPercentages.java @@ -4,6 +4,9 @@ */ package mockit.coverage.reporting.packages; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.PrintWriter; import java.util.Collections; import java.util.List; @@ -12,9 +15,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - abstract class ListWithFilesAndPercentages { @NonNull protected final PrintWriter output; diff --git a/main/src/main/java/mockit/coverage/reporting/packages/PackageCoverageReport.java b/main/src/main/java/mockit/coverage/reporting/packages/PackageCoverageReport.java index 8a7c74131..771ea3693 100644 --- a/main/src/main/java/mockit/coverage/reporting/packages/PackageCoverageReport.java +++ b/main/src/main/java/mockit/coverage/reporting/packages/PackageCoverageReport.java @@ -4,6 +4,9 @@ */ package mockit.coverage.reporting.packages; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.PrintWriter; import java.util.Arrays; import java.util.Collection; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class PackageCoverageReport extends ListWithFilesAndPercentages { @NonNull private final Map filesToFileData; diff --git a/main/src/main/java/mockit/coverage/reporting/parsing/FileParser.java b/main/src/main/java/mockit/coverage/reporting/parsing/FileParser.java index fc95f2388..7bb4d035a 100644 --- a/main/src/main/java/mockit/coverage/reporting/parsing/FileParser.java +++ b/main/src/main/java/mockit/coverage/reporting/parsing/FileParser.java @@ -4,12 +4,12 @@ */ package mockit.coverage.reporting.parsing; -import java.util.ArrayList; -import java.util.List; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.util.ArrayList; +import java.util.List; + public final class FileParser { private static final class PendingClass { @NonNull diff --git a/main/src/main/java/mockit/coverage/reporting/parsing/LineElement.java b/main/src/main/java/mockit/coverage/reporting/parsing/LineElement.java index 59e56f791..128838ef1 100644 --- a/main/src/main/java/mockit/coverage/reporting/parsing/LineElement.java +++ b/main/src/main/java/mockit/coverage/reporting/parsing/LineElement.java @@ -6,14 +6,14 @@ import static java.util.Arrays.asList; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.Iterator; import java.util.List; import java.util.NoSuchElementException; import java.util.regex.Pattern; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class LineElement implements Iterable { private static final List CONDITIONAL_OPERATORS = asList("||", "&&", ":", "else", "?"); private static final Pattern OPEN_TAG = Pattern.compile("<"); diff --git a/main/src/main/java/mockit/coverage/reporting/parsing/LineParser.java b/main/src/main/java/mockit/coverage/reporting/parsing/LineParser.java index 4c162e1d3..872667aa2 100644 --- a/main/src/main/java/mockit/coverage/reporting/parsing/LineParser.java +++ b/main/src/main/java/mockit/coverage/reporting/parsing/LineParser.java @@ -4,13 +4,13 @@ */ package mockit.coverage.reporting.parsing; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.coverage.reporting.parsing.LineElement.ElementType; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Parses a source line into one or more consecutive segments, identifying which ones contain Java code and which ones * contain only comments. Block comments initiated in a previous line are kept track of until the end of the block is diff --git a/main/src/main/java/mockit/coverage/reporting/sourceFiles/FileCoverageReport.java b/main/src/main/java/mockit/coverage/reporting/sourceFiles/FileCoverageReport.java index f1f7cc70a..d8eb6e6e5 100644 --- a/main/src/main/java/mockit/coverage/reporting/sourceFiles/FileCoverageReport.java +++ b/main/src/main/java/mockit/coverage/reporting/sourceFiles/FileCoverageReport.java @@ -4,6 +4,9 @@ */ package mockit.coverage.reporting.sourceFiles; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.IOException; import mockit.coverage.data.FileCoverageData; @@ -17,9 +20,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Generates an HTML page containing line-by-line coverage information for a single source file. */ diff --git a/main/src/main/java/mockit/coverage/reporting/sourceFiles/InputFile.java b/main/src/main/java/mockit/coverage/reporting/sourceFiles/InputFile.java index 7dbe1e37b..1834db88f 100644 --- a/main/src/main/java/mockit/coverage/reporting/sourceFiles/InputFile.java +++ b/main/src/main/java/mockit/coverage/reporting/sourceFiles/InputFile.java @@ -4,6 +4,9 @@ */ package mockit.coverage.reporting.sourceFiles; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.BufferedReader; import java.io.File; import java.io.FileFilter; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class InputFile { @NonNull final String filePath; diff --git a/main/src/main/java/mockit/coverage/reporting/sourceFiles/NeutralOutput.java b/main/src/main/java/mockit/coverage/reporting/sourceFiles/NeutralOutput.java index add4d2c50..bd2f0d00a 100644 --- a/main/src/main/java/mockit/coverage/reporting/sourceFiles/NeutralOutput.java +++ b/main/src/main/java/mockit/coverage/reporting/sourceFiles/NeutralOutput.java @@ -4,14 +4,14 @@ */ package mockit.coverage.reporting.sourceFiles; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.PrintWriter; import mockit.coverage.reporting.parsing.LineElement; import mockit.coverage.reporting.parsing.LineParser; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class NeutralOutput { @NonNull private final PrintWriter output; diff --git a/main/src/main/java/mockit/coverage/testRedundancy/JUnitListener.java b/main/src/main/java/mockit/coverage/testRedundancy/JUnitListener.java index bd637fca1..ab07042d7 100644 --- a/main/src/main/java/mockit/coverage/testRedundancy/JUnitListener.java +++ b/main/src/main/java/mockit/coverage/testRedundancy/JUnitListener.java @@ -4,13 +4,13 @@ */ package mockit.coverage.testRedundancy; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.reflect.Method; import org.junit.runner.Description; import org.junit.runner.notification.RunListener; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class JUnitListener extends RunListener { @NonNull private final TestCoverage testCoverage; diff --git a/main/src/main/java/mockit/coverage/testRedundancy/TestCoverage.java b/main/src/main/java/mockit/coverage/testRedundancy/TestCoverage.java index 1e85cc44b..a313bb2f5 100644 --- a/main/src/main/java/mockit/coverage/testRedundancy/TestCoverage.java +++ b/main/src/main/java/mockit/coverage/testRedundancy/TestCoverage.java @@ -4,6 +4,9 @@ */ package mockit.coverage.testRedundancy; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import java.util.ArrayList; import java.util.LinkedHashMap; @@ -15,9 +18,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class TestCoverage { @Nullable public static final TestCoverage INSTANCE; diff --git a/main/src/main/java/mockit/integration/TestRunnerDecorator.java b/main/src/main/java/mockit/integration/TestRunnerDecorator.java index 8e8b56ce1..658fa210d 100644 --- a/main/src/main/java/mockit/integration/TestRunnerDecorator.java +++ b/main/src/main/java/mockit/integration/TestRunnerDecorator.java @@ -6,6 +6,9 @@ import static mockit.internal.reflection.ParameterReflection.getParameterCount; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import java.util.Collections; import java.util.List; @@ -25,9 +28,6 @@ import mockit.internal.util.StackTrace; import mockit.internal.util.TestMethod; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Base class for "test runner decorators", which provide integration between JMockit and specific test runners from * JUnit and TestNG. diff --git a/main/src/main/java/mockit/integration/junit4/FakeFrameworkMethod.java b/main/src/main/java/mockit/integration/junit4/FakeFrameworkMethod.java index 364c5fa89..53ee8349b 100644 --- a/main/src/main/java/mockit/integration/junit4/FakeFrameworkMethod.java +++ b/main/src/main/java/mockit/integration/junit4/FakeFrameworkMethod.java @@ -4,6 +4,9 @@ */ package mockit.integration.junit4; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.util.List; @@ -17,9 +20,6 @@ import org.junit.runners.model.FrameworkMethod; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Startup fake that modifies the JUnit 4.5+ test runner so that it calls back to JMockit immediately after every test * executes. When that happens, JMockit will assert any expectations recorded during the test in {@link Expectations} diff --git a/main/src/main/java/mockit/integration/junit4/FakeRunNotifier.java b/main/src/main/java/mockit/integration/junit4/FakeRunNotifier.java index b64146313..dbd8ed09a 100644 --- a/main/src/main/java/mockit/integration/junit4/FakeRunNotifier.java +++ b/main/src/main/java/mockit/integration/junit4/FakeRunNotifier.java @@ -4,6 +4,8 @@ */ package mockit.integration.junit4; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.Invocation; import mockit.Mock; import mockit.MockUp; @@ -17,8 +19,6 @@ import org.junit.runner.Result; import org.junit.runner.notification.RunNotifier; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Startup fake which works in conjunction with {@link JUnit4TestRunnerDecorator} to provide JUnit 4.5+ integration. *

diff --git a/main/src/main/java/mockit/integration/junit4/JUnit4TestRunnerDecorator.java b/main/src/main/java/mockit/integration/junit4/JUnit4TestRunnerDecorator.java index 594ce0c2a..111337189 100644 --- a/main/src/main/java/mockit/integration/junit4/JUnit4TestRunnerDecorator.java +++ b/main/src/main/java/mockit/integration/junit4/JUnit4TestRunnerDecorator.java @@ -6,6 +6,9 @@ import static mockit.internal.util.StackTrace.filterStackTrace; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import mockit.integration.TestRunnerDecorator; @@ -21,9 +24,6 @@ import org.junit.Test; import org.junit.runners.model.FrameworkMethod; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class JUnit4TestRunnerDecorator extends TestRunnerDecorator { @Nullable Object invokeExplosively(@NonNull FakeInvocation invocation, @Nullable Object target, Object... params) diff --git a/main/src/main/java/mockit/integration/junit5/JMockitExtension.java b/main/src/main/java/mockit/integration/junit5/JMockitExtension.java index d9e9161de..93ae94278 100644 --- a/main/src/main/java/mockit/integration/junit5/JMockitExtension.java +++ b/main/src/main/java/mockit/integration/junit5/JMockitExtension.java @@ -6,6 +6,9 @@ import static mockit.internal.util.StackTrace.filterStackTrace; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import java.util.Arrays; import java.util.stream.Collectors; @@ -35,9 +38,6 @@ import org.junit.jupiter.api.extension.TestExecutionExceptionHandler; import org.junit.jupiter.api.extension.TestInstancePostProcessor; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - @SuppressWarnings("Since15") public final class JMockitExtension extends TestRunnerDecorator implements BeforeAllCallback, AfterAllCallback, TestInstancePostProcessor, BeforeEachCallback, AfterEachCallback, BeforeTestExecutionCallback, diff --git a/main/src/main/java/mockit/integration/springframework/BeanLookup.java b/main/src/main/java/mockit/integration/springframework/BeanLookup.java index 42a1d452c..d159c0cf8 100644 --- a/main/src/main/java/mockit/integration/springframework/BeanLookup.java +++ b/main/src/main/java/mockit/integration/springframework/BeanLookup.java @@ -4,14 +4,14 @@ */ package mockit.integration.springframework; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.injection.BeanExporter; import org.springframework.beans.factory.BeanNotOfRequiredTypeException; import org.springframework.beans.factory.NoSuchBeanDefinitionException; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class BeanLookup { private BeanLookup() { } diff --git a/main/src/main/java/mockit/integration/springframework/FakeBeanFactory.java b/main/src/main/java/mockit/integration/springframework/FakeBeanFactory.java index 3cffcf410..5ea6d3f56 100644 --- a/main/src/main/java/mockit/integration/springframework/FakeBeanFactory.java +++ b/main/src/main/java/mockit/integration/springframework/FakeBeanFactory.java @@ -4,6 +4,9 @@ */ package mockit.integration.springframework; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.Injectable; import mockit.Invocation; import mockit.Mock; @@ -16,9 +19,6 @@ import org.springframework.beans.factory.support.AbstractBeanFactory; import org.springframework.beans.factory.support.DefaultListableBeanFactory; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * If applied, this fake will take over calls to {@link AbstractBeanFactory#getBean(String)} and * {@link AbstractBeanFactory#getBean(String, Class)} in any implementation class, returning instead a diff --git a/main/src/main/java/mockit/integration/springframework/TestWebApplicationContext.java b/main/src/main/java/mockit/integration/springframework/TestWebApplicationContext.java index b6f790b12..f2584fdf4 100644 --- a/main/src/main/java/mockit/integration/springframework/TestWebApplicationContext.java +++ b/main/src/main/java/mockit/integration/springframework/TestWebApplicationContext.java @@ -4,6 +4,9 @@ */ package mockit.integration.springframework; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.injection.BeanExporter; import mockit.internal.injection.TestedClassInstantiations; import mockit.internal.state.TestRun; @@ -11,9 +14,6 @@ import org.springframework.beans.factory.BeanDefinitionStoreException; import org.springframework.web.context.support.StaticWebApplicationContext; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A {@link org.springframework.web.context.WebApplicationContext} implementation which exposes the * {@linkplain mockit.Tested @Tested} objects and their injected dependencies declared in the current test class. diff --git a/main/src/main/java/mockit/integration/testng/TestNGRunnerDecorator.java b/main/src/main/java/mockit/integration/testng/TestNGRunnerDecorator.java index 878519066..c70200ba0 100644 --- a/main/src/main/java/mockit/integration/testng/TestNGRunnerDecorator.java +++ b/main/src/main/java/mockit/integration/testng/TestNGRunnerDecorator.java @@ -6,6 +6,9 @@ import static mockit.internal.util.StackTrace.filterStackTrace; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import mockit.Expectations; @@ -22,9 +25,6 @@ import org.testng.TestException; import org.testng.annotations.Test; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Provides callbacks to be called by the TestNG 6.2+ test runner for each test execution. JMockit will then assert any * expectations recorded in {@link Expectations} subclasses during the test. diff --git a/main/src/main/java/mockit/internal/BaseClassModifier.java b/main/src/main/java/mockit/internal/BaseClassModifier.java index ba8ce3641..412ea7e6b 100644 --- a/main/src/main/java/mockit/internal/BaseClassModifier.java +++ b/main/src/main/java/mockit/internal/BaseClassModifier.java @@ -24,6 +24,9 @@ import static mockit.asm.jvmConstants.Opcodes.RETURN; import static mockit.asm.jvmConstants.Opcodes.SIPUSH; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.annotations.AnnotationVisitor; import mockit.asm.classes.ClassInfo; import mockit.asm.classes.ClassReader; @@ -47,9 +50,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public class BaseClassModifier extends WrappingClassVisitor { private static final int METHOD_ACCESS_MASK = 0xFFFF - Access.ABSTRACT - Access.NATIVE; protected static final JavaType VOID_TYPE = ObjectType.create("java/lang/Void"); diff --git a/main/src/main/java/mockit/internal/BaseInvocation.java b/main/src/main/java/mockit/internal/BaseInvocation.java index 41e17b897..f04f1884a 100644 --- a/main/src/main/java/mockit/internal/BaseInvocation.java +++ b/main/src/main/java/mockit/internal/BaseInvocation.java @@ -4,6 +4,9 @@ */ package mockit.internal; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Constructor; import java.lang.reflect.Member; import java.lang.reflect.Method; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Base class for encapsulating state and logic needed by both the Mocking and Faking APIs, but which should not go into * {@link Invocation} in order to keep the published API clean. diff --git a/main/src/main/java/mockit/internal/ClassFile.java b/main/src/main/java/mockit/internal/ClassFile.java index 57d2983ac..e18b789d3 100644 --- a/main/src/main/java/mockit/internal/ClassFile.java +++ b/main/src/main/java/mockit/internal/ClassFile.java @@ -4,6 +4,9 @@ */ package mockit.internal; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.IOException; import java.io.InputStream; import java.util.Map; @@ -13,9 +16,6 @@ import mockit.internal.state.CachedClassfiles; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ClassFile { private static final Map CLASS_FILES = new ConcurrentHashMap<>(); diff --git a/main/src/main/java/mockit/internal/ClassLoadingBridge.java b/main/src/main/java/mockit/internal/ClassLoadingBridge.java index 4d0f0a79e..5cd9c374a 100644 --- a/main/src/main/java/mockit/internal/ClassLoadingBridge.java +++ b/main/src/main/java/mockit/internal/ClassLoadingBridge.java @@ -4,6 +4,9 @@ */ package mockit.internal; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.File; import java.io.FileInputStream; import java.lang.reflect.InvocationHandler; @@ -23,9 +26,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public abstract class ClassLoadingBridge implements InvocationHandler { private static final Object[] EMPTY_ARGS = {}; private static final ReentrantLock LOCK = new ReentrantLock(); diff --git a/main/src/main/java/mockit/internal/capturing/CaptureOfImplementations.java b/main/src/main/java/mockit/internal/capturing/CaptureOfImplementations.java index 3fb77d0cc..bd50bcc54 100644 --- a/main/src/main/java/mockit/internal/capturing/CaptureOfImplementations.java +++ b/main/src/main/java/mockit/internal/capturing/CaptureOfImplementations.java @@ -4,15 +4,15 @@ */ package mockit.internal.capturing; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.classes.ClassReader; import mockit.internal.BaseClassModifier; import mockit.internal.ClassFile; import mockit.internal.startup.Startup; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public abstract class CaptureOfImplementations { protected CaptureOfImplementations() { } diff --git a/main/src/main/java/mockit/internal/capturing/CaptureTransformer.java b/main/src/main/java/mockit/internal/capturing/CaptureTransformer.java index 9b8f42c5a..902ae39d0 100644 --- a/main/src/main/java/mockit/internal/capturing/CaptureTransformer.java +++ b/main/src/main/java/mockit/internal/capturing/CaptureTransformer.java @@ -6,6 +6,9 @@ import static mockit.internal.capturing.CapturedType.isNotToBeCaptured; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassFileTransformer; import java.security.ProtectionDomain; import java.util.Collections; @@ -21,9 +24,6 @@ import mockit.internal.startup.Startup; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class CaptureTransformer implements ClassFileTransformer { @NonNull private final CapturedType capturedType; diff --git a/main/src/main/java/mockit/internal/capturing/CapturedType.java b/main/src/main/java/mockit/internal/capturing/CapturedType.java index c6a7ac33c..88a4c51c2 100644 --- a/main/src/main/java/mockit/internal/capturing/CapturedType.java +++ b/main/src/main/java/mockit/internal/capturing/CapturedType.java @@ -7,13 +7,13 @@ import static mockit.internal.util.GeneratedClasses.isExternallyGeneratedSubclass; import static mockit.internal.util.GeneratedClasses.isGeneratedClass; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.security.ProtectionDomain; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class CapturedType { private static final ProtectionDomain JMOCKIT_DOMAIN = CapturedType.class.getProtectionDomain(); diff --git a/main/src/main/java/mockit/internal/classGeneration/BaseSubclassGenerator.java b/main/src/main/java/mockit/internal/classGeneration/BaseSubclassGenerator.java index 7ec267b33..1bf367853 100644 --- a/main/src/main/java/mockit/internal/classGeneration/BaseSubclassGenerator.java +++ b/main/src/main/java/mockit/internal/classGeneration/BaseSubclassGenerator.java @@ -9,6 +9,9 @@ import static mockit.asm.jvmConstants.Opcodes.ALOAD; import static mockit.asm.jvmConstants.Opcodes.INVOKESPECIAL; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.ArrayList; @@ -28,9 +31,6 @@ import mockit.internal.ClassFile; import mockit.internal.util.TypeDescriptor; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public class BaseSubclassGenerator extends BaseClassModifier { private static final int CLASS_ACCESS_MASK = 0xFFFF - Access.ABSTRACT; private static final int CONSTRUCTOR_ACCESS_MASK = Access.PUBLIC + Access.PROTECTED; diff --git a/main/src/main/java/mockit/internal/classGeneration/ConcreteSubclass.java b/main/src/main/java/mockit/internal/classGeneration/ConcreteSubclass.java index d9959b2de..547435ca4 100644 --- a/main/src/main/java/mockit/internal/classGeneration/ConcreteSubclass.java +++ b/main/src/main/java/mockit/internal/classGeneration/ConcreteSubclass.java @@ -6,12 +6,12 @@ import static mockit.asm.jvmConstants.Access.PUBLIC; -import mockit.asm.classes.ClassReader; -import mockit.asm.classes.ClassVisitor; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import mockit.asm.classes.ClassReader; +import mockit.asm.classes.ClassVisitor; + /** * Generates a concrete subclass for an {@code abstract} base class. */ diff --git a/main/src/main/java/mockit/internal/classGeneration/ImplementationClass.java b/main/src/main/java/mockit/internal/classGeneration/ImplementationClass.java index 61fd9978b..793f994b1 100644 --- a/main/src/main/java/mockit/internal/classGeneration/ImplementationClass.java +++ b/main/src/main/java/mockit/internal/classGeneration/ImplementationClass.java @@ -4,6 +4,9 @@ */ package mockit.internal.classGeneration; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Type; import mockit.asm.classes.ClassReader; @@ -13,9 +16,6 @@ import mockit.internal.util.GeneratedClasses; import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Allows the creation of new implementation classes for interfaces and abstract classes. */ diff --git a/main/src/main/java/mockit/internal/classGeneration/MockedTypeInfo.java b/main/src/main/java/mockit/internal/classGeneration/MockedTypeInfo.java index 26d13e5fe..ba308e67c 100644 --- a/main/src/main/java/mockit/internal/classGeneration/MockedTypeInfo.java +++ b/main/src/main/java/mockit/internal/classGeneration/MockedTypeInfo.java @@ -4,14 +4,14 @@ */ package mockit.internal.classGeneration; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import mockit.internal.reflection.GenericTypeReflection; import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class MockedTypeInfo { @NonNull public final GenericTypeReflection genericTypeMap; diff --git a/main/src/main/java/mockit/internal/expectations/ActiveInvocations.java b/main/src/main/java/mockit/internal/expectations/ActiveInvocations.java index 3ebaed813..8249f6e4c 100644 --- a/main/src/main/java/mockit/internal/expectations/ActiveInvocations.java +++ b/main/src/main/java/mockit/internal/expectations/ActiveInvocations.java @@ -15,6 +15,9 @@ import static mockit.internal.expectations.argumentMatching.AlwaysTrueMatcher.ANY_STRING; import static mockit.internal.expectations.argumentMatching.AlwaysTrueMatcher.ANY_VALUE; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.expectations.argumentMatching.ArgumentMatcher; import mockit.internal.expectations.transformation.ArgumentCapturing; import mockit.internal.state.TestRun; @@ -22,9 +25,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - @SuppressWarnings("unused") public final class ActiveInvocations { private ActiveInvocations() { diff --git a/main/src/main/java/mockit/internal/expectations/BaseVerificationPhase.java b/main/src/main/java/mockit/internal/expectations/BaseVerificationPhase.java index 572e4af58..94cf72e04 100644 --- a/main/src/main/java/mockit/internal/expectations/BaseVerificationPhase.java +++ b/main/src/main/java/mockit/internal/expectations/BaseVerificationPhase.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; import java.util.Map; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public abstract class BaseVerificationPhase extends TestOnlyPhase { @NonNull final ReplayPhase replayPhase; diff --git a/main/src/main/java/mockit/internal/expectations/EquivalentInstances.java b/main/src/main/java/mockit/internal/expectations/EquivalentInstances.java index 3a6ba7e75..4acaf6873 100644 --- a/main/src/main/java/mockit/internal/expectations/EquivalentInstances.java +++ b/main/src/main/java/mockit/internal/expectations/EquivalentInstances.java @@ -4,15 +4,15 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.IdentityHashMap; import java.util.Map; import java.util.Map.Entry; import mockit.internal.expectations.invocation.ExpectedInvocation; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class EquivalentInstances { @NonNull final Map instanceMap; diff --git a/main/src/main/java/mockit/internal/expectations/ExecutionMode.java b/main/src/main/java/mockit/internal/expectations/ExecutionMode.java index c919e4f19..844768312 100644 --- a/main/src/main/java/mockit/internal/expectations/ExecutionMode.java +++ b/main/src/main/java/mockit/internal/expectations/ExecutionMode.java @@ -7,11 +7,11 @@ import static java.lang.reflect.Modifier.isNative; import static java.lang.reflect.Modifier.isStatic; -import mockit.internal.state.TestRun; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import mockit.internal.state.TestRun; + public enum ExecutionMode { Regular { @Override diff --git a/main/src/main/java/mockit/internal/expectations/Expectation.java b/main/src/main/java/mockit/internal/expectations/Expectation.java index a27256eb4..6f614061d 100644 --- a/main/src/main/java/mockit/internal/expectations/Expectation.java +++ b/main/src/main/java/mockit/internal/expectations/Expectation.java @@ -4,15 +4,15 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.expectations.invocation.ExpectedInvocation; import mockit.internal.expectations.invocation.InvocationConstraints; import mockit.internal.expectations.invocation.InvocationResults; import mockit.internal.expectations.invocation.ReturnTypeConversion; import mockit.internal.util.TypeDescriptor; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class Expectation { @Nullable final RecordPhase recordPhase; diff --git a/main/src/main/java/mockit/internal/expectations/FullVerificationPhase.java b/main/src/main/java/mockit/internal/expectations/FullVerificationPhase.java index 1247b9583..cae3630e4 100644 --- a/main/src/main/java/mockit/internal/expectations/FullVerificationPhase.java +++ b/main/src/main/java/mockit/internal/expectations/FullVerificationPhase.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class FullVerificationPhase extends UnorderedVerificationPhase { @NonNull private final Object[] mockedTypesAndInstancesToVerify; diff --git a/main/src/main/java/mockit/internal/expectations/InstanceBasedMatching.java b/main/src/main/java/mockit/internal/expectations/InstanceBasedMatching.java index 8deb0589e..b1982994b 100644 --- a/main/src/main/java/mockit/internal/expectations/InstanceBasedMatching.java +++ b/main/src/main/java/mockit/internal/expectations/InstanceBasedMatching.java @@ -6,13 +6,13 @@ import static mockit.internal.util.Utilities.containsReference; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.LinkedList; import java.util.List; import mockit.internal.util.GeneratedClasses; -import edu.umd.cs.findbugs.annotations.NonNull; - final class InstanceBasedMatching { @NonNull private final List> mockedTypesToMatchOnInstances; diff --git a/main/src/main/java/mockit/internal/expectations/MockingFilters.java b/main/src/main/java/mockit/internal/expectations/MockingFilters.java index bcef4b4ed..b9b73c827 100644 --- a/main/src/main/java/mockit/internal/expectations/MockingFilters.java +++ b/main/src/main/java/mockit/internal/expectations/MockingFilters.java @@ -4,10 +4,10 @@ */ package mockit.internal.expectations; -import mockit.asm.types.JavaType; - import edu.umd.cs.findbugs.annotations.NonNull; +import mockit.asm.types.JavaType; + public final class MockingFilters { private MockingFilters() { } diff --git a/main/src/main/java/mockit/internal/expectations/OrderedVerificationPhase.java b/main/src/main/java/mockit/internal/expectations/OrderedVerificationPhase.java index 6d899f9c1..0b0f75753 100644 --- a/main/src/main/java/mockit/internal/expectations/OrderedVerificationPhase.java +++ b/main/src/main/java/mockit/internal/expectations/OrderedVerificationPhase.java @@ -6,6 +6,9 @@ import static java.util.Collections.emptyList; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.Collections; import java.util.List; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class OrderedVerificationPhase extends BaseVerificationPhase { @NonNegative private final int expectationCount; diff --git a/main/src/main/java/mockit/internal/expectations/PartiallyMockedInstances.java b/main/src/main/java/mockit/internal/expectations/PartiallyMockedInstances.java index 41846a3f2..463fa3750 100644 --- a/main/src/main/java/mockit/internal/expectations/PartiallyMockedInstances.java +++ b/main/src/main/java/mockit/internal/expectations/PartiallyMockedInstances.java @@ -6,10 +6,10 @@ import static mockit.internal.util.Utilities.containsReference; -import java.util.List; - import edu.umd.cs.findbugs.annotations.NonNull; +import java.util.List; + final class PartiallyMockedInstances { @NonNull private final List dynamicMockInstancesToMatch; diff --git a/main/src/main/java/mockit/internal/expectations/Phase.java b/main/src/main/java/mockit/internal/expectations/Phase.java index 2e2bd15ad..354f6ce5e 100644 --- a/main/src/main/java/mockit/internal/expectations/Phase.java +++ b/main/src/main/java/mockit/internal/expectations/Phase.java @@ -4,11 +4,11 @@ */ package mockit.internal.expectations; -import java.util.Map; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.util.Map; + abstract class Phase { @NonNull final PhasedExecutionState executionState; diff --git a/main/src/main/java/mockit/internal/expectations/PhasedExecutionState.java b/main/src/main/java/mockit/internal/expectations/PhasedExecutionState.java index ff24bf978..1eaa65cb7 100644 --- a/main/src/main/java/mockit/internal/expectations/PhasedExecutionState.java +++ b/main/src/main/java/mockit/internal/expectations/PhasedExecutionState.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; @@ -12,9 +15,6 @@ import mockit.internal.state.TestRun; import mockit.internal.util.GeneratedClasses; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class PhasedExecutionState { @NonNull final List expectations; diff --git a/main/src/main/java/mockit/internal/expectations/RecordAndReplayExecution.java b/main/src/main/java/mockit/internal/expectations/RecordAndReplayExecution.java index 3f9f02ce9..1495886fd 100644 --- a/main/src/main/java/mockit/internal/expectations/RecordAndReplayExecution.java +++ b/main/src/main/java/mockit/internal/expectations/RecordAndReplayExecution.java @@ -6,6 +6,9 @@ import static mockit.internal.util.Utilities.NO_ARGS; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; import java.util.concurrent.locks.ReentrantLock; @@ -22,9 +25,6 @@ import mockit.internal.util.DefaultValues; import mockit.internal.util.ObjectMethods; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class RecordAndReplayExecution { public static final ReentrantLock RECORD_OR_REPLAY_LOCK = new ReentrantLock(); public static final ReentrantLock TEST_ONLY_PHASE_LOCK = new ReentrantLock(); diff --git a/main/src/main/java/mockit/internal/expectations/RecordPhase.java b/main/src/main/java/mockit/internal/expectations/RecordPhase.java index bb36589ac..a1a583ca7 100644 --- a/main/src/main/java/mockit/internal/expectations/RecordPhase.java +++ b/main/src/main/java/mockit/internal/expectations/RecordPhase.java @@ -6,13 +6,13 @@ import static mockit.internal.expectations.state.ExecutingTest.isInstanceMethodWithStandardBehavior; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.Map; import mockit.internal.expectations.invocation.ExpectedInvocation; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class RecordPhase extends TestOnlyPhase { RecordPhase(@NonNull PhasedExecutionState executionState) { super(executionState); diff --git a/main/src/main/java/mockit/internal/expectations/ReplayPhase.java b/main/src/main/java/mockit/internal/expectations/ReplayPhase.java index 9e6b69eb9..a65ecdb88 100644 --- a/main/src/main/java/mockit/internal/expectations/ReplayPhase.java +++ b/main/src/main/java/mockit/internal/expectations/ReplayPhase.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; import java.util.Map; @@ -12,9 +15,6 @@ import mockit.internal.expectations.invocation.InvocationConstraints; import mockit.internal.expectations.invocation.UnexpectedInvocation; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class ReplayPhase extends Phase { @NonNull final FailureState failureState; diff --git a/main/src/main/java/mockit/internal/expectations/SequenceOfReturnValues.java b/main/src/main/java/mockit/internal/expectations/SequenceOfReturnValues.java index 6003abca7..989dbe62c 100644 --- a/main/src/main/java/mockit/internal/expectations/SequenceOfReturnValues.java +++ b/main/src/main/java/mockit/internal/expectations/SequenceOfReturnValues.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Collection; @@ -15,9 +18,6 @@ import java.util.SortedSet; import java.util.TreeSet; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class SequenceOfReturnValues { @NonNull private final Expectation expectation; diff --git a/main/src/main/java/mockit/internal/expectations/TestOnlyPhase.java b/main/src/main/java/mockit/internal/expectations/TestOnlyPhase.java index 11cdd9d0f..8d68f1abb 100644 --- a/main/src/main/java/mockit/internal/expectations/TestOnlyPhase.java +++ b/main/src/main/java/mockit/internal/expectations/TestOnlyPhase.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public abstract class TestOnlyPhase extends Phase { boolean matchInstance; @Nullable diff --git a/main/src/main/java/mockit/internal/expectations/UnorderedVerificationPhase.java b/main/src/main/java/mockit/internal/expectations/UnorderedVerificationPhase.java index 8cae85220..f5709cbcd 100644 --- a/main/src/main/java/mockit/internal/expectations/UnorderedVerificationPhase.java +++ b/main/src/main/java/mockit/internal/expectations/UnorderedVerificationPhase.java @@ -4,14 +4,14 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; import mockit.internal.expectations.invocation.ExpectedInvocation; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - class UnorderedVerificationPhase extends BaseVerificationPhase { @NonNull private final List verifiedExpectations; diff --git a/main/src/main/java/mockit/internal/expectations/VerifiedExpectation.java b/main/src/main/java/mockit/internal/expectations/VerifiedExpectation.java index ea353c1a9..5d97eb48c 100644 --- a/main/src/main/java/mockit/internal/expectations/VerifiedExpectation.java +++ b/main/src/main/java/mockit/internal/expectations/VerifiedExpectation.java @@ -4,15 +4,15 @@ */ package mockit.internal.expectations; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import mockit.internal.expectations.argumentMatching.ArgumentMatcher; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class VerifiedExpectation { @NonNull final Expectation expectation; diff --git a/main/src/main/java/mockit/internal/expectations/argumentMatching/ArgumentMismatch.java b/main/src/main/java/mockit/internal/expectations/argumentMatching/ArgumentMismatch.java index cfc10ced1..6a1b9911b 100644 --- a/main/src/main/java/mockit/internal/expectations/argumentMatching/ArgumentMismatch.java +++ b/main/src/main/java/mockit/internal/expectations/argumentMatching/ArgumentMismatch.java @@ -4,14 +4,14 @@ */ package mockit.internal.expectations.argumentMatching; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import java.lang.reflect.Method; import mockit.internal.util.ObjectMethods; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ArgumentMismatch { @NonNull private final StringBuilder out = new StringBuilder(50); diff --git a/main/src/main/java/mockit/internal/expectations/argumentMatching/CaptureMatcher.java b/main/src/main/java/mockit/internal/expectations/argumentMatching/CaptureMatcher.java index 891dd438b..769f6a0b6 100644 --- a/main/src/main/java/mockit/internal/expectations/argumentMatching/CaptureMatcher.java +++ b/main/src/main/java/mockit/internal/expectations/argumentMatching/CaptureMatcher.java @@ -4,11 +4,11 @@ */ package mockit.internal.expectations.argumentMatching; -import java.util.List; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.util.List; + public final class CaptureMatcher implements ArgumentMatcher> { @NonNull private final List valueHolder; diff --git a/main/src/main/java/mockit/internal/expectations/argumentMatching/ClassMatcher.java b/main/src/main/java/mockit/internal/expectations/argumentMatching/ClassMatcher.java index a9a18305c..3ba9a7d35 100644 --- a/main/src/main/java/mockit/internal/expectations/argumentMatching/ClassMatcher.java +++ b/main/src/main/java/mockit/internal/expectations/argumentMatching/ClassMatcher.java @@ -4,12 +4,12 @@ */ package mockit.internal.expectations.argumentMatching; -import java.util.IdentityHashMap; -import java.util.Map; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.util.IdentityHashMap; +import java.util.Map; + public final class ClassMatcher implements ArgumentMatcher { private static final Map, ClassMatcher> PRIMITIVE_MATCHERS; static { diff --git a/main/src/main/java/mockit/internal/expectations/argumentMatching/EqualityMatcher.java b/main/src/main/java/mockit/internal/expectations/argumentMatching/EqualityMatcher.java index 1c8d6f317..79ca8c770 100644 --- a/main/src/main/java/mockit/internal/expectations/argumentMatching/EqualityMatcher.java +++ b/main/src/main/java/mockit/internal/expectations/argumentMatching/EqualityMatcher.java @@ -4,11 +4,11 @@ */ package mockit.internal.expectations.argumentMatching; -import java.lang.reflect.Array; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.lang.reflect.Array; + public class EqualityMatcher implements ArgumentMatcher { @Nullable final Object object; diff --git a/main/src/main/java/mockit/internal/expectations/argumentMatching/HamcrestAdapter.java b/main/src/main/java/mockit/internal/expectations/argumentMatching/HamcrestAdapter.java index c795761fb..ca19b2a3a 100644 --- a/main/src/main/java/mockit/internal/expectations/argumentMatching/HamcrestAdapter.java +++ b/main/src/main/java/mockit/internal/expectations/argumentMatching/HamcrestAdapter.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.argumentMatching; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.reflection.FieldReflection; import org.hamcrest.Description; @@ -14,9 +17,6 @@ import org.hamcrest.core.IsNot; import org.hamcrest.core.IsSame; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Adapts the org.hamcrest.Matcher interface to {@link ArgumentMatcher}. */ diff --git a/main/src/main/java/mockit/internal/expectations/argumentMatching/LenientEqualityMatcher.java b/main/src/main/java/mockit/internal/expectations/argumentMatching/LenientEqualityMatcher.java index 6ef7558e8..53c075b6c 100644 --- a/main/src/main/java/mockit/internal/expectations/argumentMatching/LenientEqualityMatcher.java +++ b/main/src/main/java/mockit/internal/expectations/argumentMatching/LenientEqualityMatcher.java @@ -4,11 +4,11 @@ */ package mockit.internal.expectations.argumentMatching; -import java.util.Map; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.util.Map; + public final class LenientEqualityMatcher extends EqualityMatcher { @NonNull private final Map instanceMap; diff --git a/main/src/main/java/mockit/internal/expectations/argumentMatching/PatternMatcher.java b/main/src/main/java/mockit/internal/expectations/argumentMatching/PatternMatcher.java index 77cbad1ab..e61f60128 100644 --- a/main/src/main/java/mockit/internal/expectations/argumentMatching/PatternMatcher.java +++ b/main/src/main/java/mockit/internal/expectations/argumentMatching/PatternMatcher.java @@ -4,11 +4,11 @@ */ package mockit.internal.expectations.argumentMatching; -import java.util.regex.Pattern; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.util.regex.Pattern; + public final class PatternMatcher implements ArgumentMatcher { @NonNull private final Pattern pattern; diff --git a/main/src/main/java/mockit/internal/expectations/argumentMatching/ReflectiveMatcher.java b/main/src/main/java/mockit/internal/expectations/argumentMatching/ReflectiveMatcher.java index e7c4238f1..05f4acb2f 100644 --- a/main/src/main/java/mockit/internal/expectations/argumentMatching/ReflectiveMatcher.java +++ b/main/src/main/java/mockit/internal/expectations/argumentMatching/ReflectiveMatcher.java @@ -4,14 +4,14 @@ */ package mockit.internal.expectations.argumentMatching; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import mockit.Delegate; import mockit.internal.reflection.MethodReflection; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ReflectiveMatcher implements ArgumentMatcher { @NonNull private final Delegate delegate; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchers.java b/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchers.java index 7d647c99a..48b96865c 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchers.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchers.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.invocation; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import java.util.Map; @@ -16,9 +19,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - abstract class ArgumentValuesAndMatchers { @NonNull final InvocationArguments signature; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchersWithVarargs.java b/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchersWithVarargs.java index 2f5623a0a..63813e1ec 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchersWithVarargs.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchersWithVarargs.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.invocation; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import java.util.Map; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class ArgumentValuesAndMatchersWithVarargs extends ArgumentValuesAndMatchers { ArgumentValuesAndMatchersWithVarargs(@NonNull InvocationArguments signature, @NonNull Object[] values) { super(signature, values); diff --git a/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchersWithoutVarargs.java b/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchersWithoutVarargs.java index dd2aef835..1eb03e2b3 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchersWithoutVarargs.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/ArgumentValuesAndMatchersWithoutVarargs.java @@ -4,14 +4,14 @@ */ package mockit.internal.expectations.invocation; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.Map; import mockit.internal.expectations.argumentMatching.ArgumentMatcher; import mockit.internal.expectations.argumentMatching.EqualityMatcher; import mockit.internal.expectations.argumentMatching.LenientEqualityMatcher; -import edu.umd.cs.findbugs.annotations.NonNull; - final class ArgumentValuesAndMatchersWithoutVarargs extends ArgumentValuesAndMatchers { ArgumentValuesAndMatchersWithoutVarargs(@NonNull InvocationArguments signature, @NonNull Object[] values) { super(signature, values); diff --git a/main/src/main/java/mockit/internal/expectations/invocation/DelegateInvocation.java b/main/src/main/java/mockit/internal/expectations/invocation/DelegateInvocation.java index 94b3cc127..e647d0b90 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/DelegateInvocation.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/DelegateInvocation.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.invocation; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Constructor; import java.lang.reflect.Member; @@ -11,9 +14,6 @@ import mockit.internal.expectations.state.ExecutingTest; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class DelegateInvocation extends BaseInvocation { @NonNull private final InvocationArguments invocationArguments; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/DelegatedResult.java b/main/src/main/java/mockit/internal/expectations/invocation/DelegatedResult.java index 4514b0ccc..593431342 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/DelegatedResult.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/DelegatedResult.java @@ -8,6 +8,9 @@ import static mockit.internal.reflection.MethodReflection.findNonPrivateHandlerMethod; import static mockit.internal.reflection.MethodReflection.invoke; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import java.util.concurrent.locks.ReentrantLock; @@ -20,9 +23,6 @@ import mockit.internal.util.MethodFormatter; import mockit.internal.util.TypeDescriptor; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class DelegatedResult extends InvocationResult { private static final Object[] NO_ARGS = {}; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/ExpectationError.java b/main/src/main/java/mockit/internal/expectations/invocation/ExpectationError.java index 253dbbe88..413262f82 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/ExpectationError.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/ExpectationError.java @@ -4,10 +4,10 @@ */ package mockit.internal.expectations.invocation; -import mockit.internal.util.StackTrace; - import edu.umd.cs.findbugs.annotations.NonNull; +import mockit.internal.util.StackTrace; + final class ExpectationError extends AssertionError { private static final long serialVersionUID = 1L; private String message; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/ExpectedInvocation.java b/main/src/main/java/mockit/internal/expectations/invocation/ExpectedInvocation.java index 15ff8ccf3..2744fff14 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/ExpectedInvocation.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/ExpectedInvocation.java @@ -6,6 +6,9 @@ import static mockit.internal.util.TypeDescriptor.getClassForType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.IOException; import java.util.List; import java.util.Map; @@ -23,9 +26,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - @SuppressWarnings("OverlyComplexClass") public final class ExpectedInvocation { @NonNull diff --git a/main/src/main/java/mockit/internal/expectations/invocation/InvocationArguments.java b/main/src/main/java/mockit/internal/expectations/invocation/InvocationArguments.java index 0ee323c74..7f2e3296a 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/InvocationArguments.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/InvocationArguments.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.invocation; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Member; import java.util.List; import java.util.Map; @@ -15,9 +18,6 @@ import mockit.internal.state.TestRun; import mockit.internal.util.MethodFormatter; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class InvocationArguments { @NonNull final String classDesc; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/InvocationConstraints.java b/main/src/main/java/mockit/internal/expectations/invocation/InvocationConstraints.java index 5401b2fc3..7f795b450 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/InvocationConstraints.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/InvocationConstraints.java @@ -4,14 +4,14 @@ */ package mockit.internal.expectations.invocation; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.Collections; import java.util.List; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class InvocationConstraints { public int minInvocations; private int maxInvocations; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/InvocationResult.java b/main/src/main/java/mockit/internal/expectations/invocation/InvocationResult.java index bc5671ddb..ed0f796ab 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/InvocationResult.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/InvocationResult.java @@ -4,11 +4,11 @@ */ package mockit.internal.expectations.invocation; -import java.util.Iterator; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.util.Iterator; + class InvocationResult { InvocationResult next; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/InvocationResults.java b/main/src/main/java/mockit/internal/expectations/invocation/InvocationResults.java index bd02fdf0e..346fd8e72 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/InvocationResults.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/InvocationResults.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.invocation; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import java.util.Iterator; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class InvocationResults { @NonNull private final ExpectedInvocation invocation; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/MultiValuedConversion.java b/main/src/main/java/mockit/internal/expectations/invocation/MultiValuedConversion.java index 01aa86313..93d4d1a0b 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/MultiValuedConversion.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/MultiValuedConversion.java @@ -6,6 +6,9 @@ import static mockit.internal.util.Utilities.JAVA8; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Collection; @@ -24,9 +27,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class MultiValuedConversion { @NonNull private final InvocationResults invocationResults; diff --git a/main/src/main/java/mockit/internal/expectations/invocation/ReturnTypeConversion.java b/main/src/main/java/mockit/internal/expectations/invocation/ReturnTypeConversion.java index 12e90ceb9..e5a2e4757 100644 --- a/main/src/main/java/mockit/internal/expectations/invocation/ReturnTypeConversion.java +++ b/main/src/main/java/mockit/internal/expectations/invocation/ReturnTypeConversion.java @@ -11,6 +11,9 @@ import static mockit.internal.reflection.MethodReflection.invokePublicIfAvailable; import static mockit.internal.util.Utilities.JAVA8; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.ByteArrayInputStream; import java.io.StringReader; import java.lang.reflect.Array; @@ -29,9 +32,6 @@ import mockit.internal.util.AutoBoxing; import mockit.internal.util.MethodFormatter; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ReturnTypeConversion { private static final Class[] STRING = { String.class }; diff --git a/main/src/main/java/mockit/internal/expectations/mocking/BaseTypeRedefinition.java b/main/src/main/java/mockit/internal/expectations/mocking/BaseTypeRedefinition.java index 9fa6e0d3e..1b4ec89e3 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/BaseTypeRedefinition.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/BaseTypeRedefinition.java @@ -11,6 +11,9 @@ import static mockit.internal.util.Utilities.JAVA8; import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassDefinition; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Proxy; @@ -34,9 +37,6 @@ import mockit.internal.util.ClassLoad; import mockit.internal.util.VisitInterruptedException; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - class BaseTypeRedefinition { private static final ClassDefinition[] CLASS_DEFINITIONS = {}; diff --git a/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstances.java b/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstances.java index 8bdab8cf9..37dcb4081 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstances.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstances.java @@ -6,6 +6,9 @@ import static mockit.internal.reflection.FieldReflection.getFieldValue; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassDefinition; import java.util.ArrayList; import java.util.Collection; @@ -22,9 +25,6 @@ import mockit.internal.state.TestRun; import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public class CaptureOfNewInstances extends CaptureOfImplementations { protected static final class Capture { @NonNull diff --git a/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstancesForFields.java b/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstancesForFields.java index 3c9b9833f..0facf554b 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstancesForFields.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/CaptureOfNewInstancesForFields.java @@ -4,12 +4,12 @@ */ package mockit.internal.expectations.mocking; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.reflect.Field; import java.util.Collection; import java.util.List; -import edu.umd.cs.findbugs.annotations.NonNull; - final class CaptureOfNewInstancesForFields extends CaptureOfNewInstances { void resetCaptureCount(@NonNull Field mockField) { Collection> capturesForAllBaseTypes = getCapturesForAllBaseTypes(); diff --git a/main/src/main/java/mockit/internal/expectations/mocking/CascadingTypeRedefinition.java b/main/src/main/java/mockit/internal/expectations/mocking/CascadingTypeRedefinition.java index 65bb59351..4294e9dd1 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/CascadingTypeRedefinition.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/CascadingTypeRedefinition.java @@ -4,11 +4,11 @@ */ package mockit.internal.expectations.mocking; -import java.lang.reflect.Type; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.lang.reflect.Type; + public final class CascadingTypeRedefinition extends BaseTypeRedefinition { @NonNull private final Type mockedType; diff --git a/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinition.java b/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinition.java index b4e8d51a6..4ec260b97 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinition.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinition.java @@ -4,12 +4,12 @@ */ package mockit.internal.expectations.mocking; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.reflect.TypeVariable; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; - final class FieldTypeRedefinition extends TypeRedefinition { private boolean usePartialMocking; diff --git a/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinitions.java b/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinitions.java index 64205d451..8651a35c1 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinitions.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/FieldTypeRedefinitions.java @@ -6,6 +6,8 @@ import static java.lang.reflect.Modifier.isFinal; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.reflect.Field; import java.util.ArrayList; import java.util.HashMap; @@ -18,8 +20,6 @@ import mockit.internal.state.TestRun; import mockit.internal.util.StackTrace; -import edu.umd.cs.findbugs.annotations.NonNull; - @SuppressWarnings("UnnecessaryFullyQualifiedName") public final class FieldTypeRedefinitions extends TypeRedefinitions { private static final int FIELD_ACCESS_MASK = Access.SYNTHETIC + Access.STATIC; diff --git a/main/src/main/java/mockit/internal/expectations/mocking/InstanceFactory.java b/main/src/main/java/mockit/internal/expectations/mocking/InstanceFactory.java index 9309a034a..f67366766 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/InstanceFactory.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/InstanceFactory.java @@ -4,13 +4,13 @@ */ package mockit.internal.expectations.mocking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.util.StackTrace; import org.objenesis.ObjenesisHelper; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Factory for the creation of new mocked instances, and for obtaining/clearing the last instance created. There are * separate subclasses dedicated to mocked interfaces and mocked classes. diff --git a/main/src/main/java/mockit/internal/expectations/mocking/InterfaceImplementationGenerator.java b/main/src/main/java/mockit/internal/expectations/mocking/InterfaceImplementationGenerator.java index 8b909b827..7ed8a1a9a 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/InterfaceImplementationGenerator.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/InterfaceImplementationGenerator.java @@ -12,6 +12,9 @@ import static mockit.asm.jvmConstants.Opcodes.ALOAD; import static mockit.asm.jvmConstants.Opcodes.INVOKESPECIAL; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Type; import java.util.ArrayList; import java.util.EnumSet; @@ -31,9 +34,6 @@ import mockit.internal.reflection.GenericTypeReflection; import mockit.internal.reflection.GenericTypeReflection.GenericSignature; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class InterfaceImplementationGenerator extends BaseClassModifier { private static final int CLASS_ACCESS = PUBLIC + FINAL; private static final EnumSet SIGNATURE = EnumSet.of(Attribute.Signature); diff --git a/main/src/main/java/mockit/internal/expectations/mocking/MockedBridge.java b/main/src/main/java/mockit/internal/expectations/mocking/MockedBridge.java index 7a7353320..7b530ab90 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/MockedBridge.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/MockedBridge.java @@ -7,6 +7,9 @@ import static mockit.internal.expectations.RecordAndReplayExecution.RECORD_OR_REPLAY_LOCK; import static mockit.internal.expectations.RecordAndReplayExecution.recordOrReplay; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import mockit.internal.ClassLoadingBridge; @@ -14,9 +17,6 @@ import mockit.internal.state.TestRun; import mockit.internal.util.ObjectMethods; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class MockedBridge extends ClassLoadingBridge { @NonNull public static final ClassLoadingBridge MB = new MockedBridge(); diff --git a/main/src/main/java/mockit/internal/expectations/mocking/MockedClassModifier.java b/main/src/main/java/mockit/internal/expectations/mocking/MockedClassModifier.java index 67191f9a3..7a8ce1a94 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/MockedClassModifier.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/MockedClassModifier.java @@ -22,6 +22,9 @@ import static mockit.internal.util.ObjectMethods.isMethodFromObject; import static mockit.internal.util.Utilities.HOTSPOT_VM; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -35,9 +38,6 @@ import mockit.internal.BaseClassModifier; import mockit.internal.expectations.ExecutionMode; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class MockedClassModifier extends BaseClassModifier { private static final int METHOD_ACCESS_MASK = PRIVATE + SYNTHETIC + ABSTRACT; private static final int PUBLIC_OR_PROTECTED = PUBLIC + PROTECTED; diff --git a/main/src/main/java/mockit/internal/expectations/mocking/MockedType.java b/main/src/main/java/mockit/internal/expectations/mocking/MockedType.java index e2ccb353a..996c37dd8 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/MockedType.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/MockedType.java @@ -6,6 +6,9 @@ import static java.lang.reflect.Modifier.isFinal; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.ParameterizedType; @@ -29,9 +32,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - @SuppressWarnings("EqualsAndHashcode") public final class MockedType extends InjectionProvider { @Mocked diff --git a/main/src/main/java/mockit/internal/expectations/mocking/ParameterTypeRedefinitions.java b/main/src/main/java/mockit/internal/expectations/mocking/ParameterTypeRedefinitions.java index 4feb7196b..0bf64842b 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/ParameterTypeRedefinitions.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/ParameterTypeRedefinitions.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.mocking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Type; import java.util.ArrayList; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ParameterTypeRedefinitions extends TypeRedefinitions { @NonNull private final TestMethod testMethod; diff --git a/main/src/main/java/mockit/internal/expectations/mocking/PartialMocking.java b/main/src/main/java/mockit/internal/expectations/mocking/PartialMocking.java index f49535952..5ea507ab6 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/PartialMocking.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/PartialMocking.java @@ -8,6 +8,8 @@ import static mockit.internal.util.GeneratedClasses.getMockedClass; import static mockit.internal.util.GeneratedClasses.isGeneratedImplementationClass; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -16,8 +18,6 @@ import mockit.internal.expectations.MockingFilters; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class PartialMocking extends BaseTypeRedefinition { @NonNull public final List targetInstances; diff --git a/main/src/main/java/mockit/internal/expectations/mocking/SubclassGenerationModifier.java b/main/src/main/java/mockit/internal/expectations/mocking/SubclassGenerationModifier.java index dc7f98a40..cf6e4e2fb 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/SubclassGenerationModifier.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/SubclassGenerationModifier.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.mocking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Type; import mockit.asm.classes.ClassReader; @@ -11,9 +14,6 @@ import mockit.internal.classGeneration.BaseSubclassGenerator; import mockit.internal.util.ObjectMethods; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class SubclassGenerationModifier extends BaseSubclassGenerator { public SubclassGenerationModifier(@NonNull Class baseClass, @NonNull Type mockedType, @NonNull ClassReader cr, @NonNull String subclassName, boolean copyConstructors) { diff --git a/main/src/main/java/mockit/internal/expectations/mocking/TypeRedefinition.java b/main/src/main/java/mockit/internal/expectations/mocking/TypeRedefinition.java index 4420afd7d..362a85abb 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/TypeRedefinition.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/TypeRedefinition.java @@ -4,13 +4,13 @@ */ package mockit.internal.expectations.mocking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Type; import mockit.internal.expectations.MockingFilters; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - class TypeRedefinition extends BaseTypeRedefinition { TypeRedefinition(@NonNull MockedType typeMetadata) { super(typeMetadata); diff --git a/main/src/main/java/mockit/internal/expectations/mocking/TypeRedefinitions.java b/main/src/main/java/mockit/internal/expectations/mocking/TypeRedefinitions.java index 10df9554d..1a1c01c43 100644 --- a/main/src/main/java/mockit/internal/expectations/mocking/TypeRedefinitions.java +++ b/main/src/main/java/mockit/internal/expectations/mocking/TypeRedefinitions.java @@ -4,15 +4,15 @@ */ package mockit.internal.expectations.mocking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.TypeVariable; import java.util.ArrayList; import java.util.List; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public class TypeRedefinitions { @NonNull private final List> targetClasses; diff --git a/main/src/main/java/mockit/internal/expectations/state/CascadingTypes.java b/main/src/main/java/mockit/internal/expectations/state/CascadingTypes.java index 230b98c4d..d8020b994 100644 --- a/main/src/main/java/mockit/internal/expectations/state/CascadingTypes.java +++ b/main/src/main/java/mockit/internal/expectations/state/CascadingTypes.java @@ -6,6 +6,9 @@ import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Type; import java.util.Iterator; import java.util.Map; @@ -13,9 +16,6 @@ import mockit.asm.types.JavaType; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class CascadingTypes { @NonNull private final Map mockedTypesToCascades; diff --git a/main/src/main/java/mockit/internal/expectations/state/ExecutingTest.java b/main/src/main/java/mockit/internal/expectations/state/ExecutingTest.java index 5c9aa45e0..b367d3aa5 100644 --- a/main/src/main/java/mockit/internal/expectations/state/ExecutingTest.java +++ b/main/src/main/java/mockit/internal/expectations/state/ExecutingTest.java @@ -6,6 +6,9 @@ import static mockit.internal.util.Utilities.containsReference; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Type; import java.util.ArrayList; import java.util.IdentityHashMap; @@ -17,9 +20,6 @@ import mockit.internal.expectations.mocking.MockedType; import mockit.internal.expectations.mocking.ParameterTypeRedefinitions; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ExecutingTest { @Nullable private RecordAndReplayExecution currentRecordAndReplay; diff --git a/main/src/main/java/mockit/internal/expectations/state/MockedTypeCascade.java b/main/src/main/java/mockit/internal/expectations/state/MockedTypeCascade.java index 2df7bbc46..e9ae24076 100644 --- a/main/src/main/java/mockit/internal/expectations/state/MockedTypeCascade.java +++ b/main/src/main/java/mockit/internal/expectations/state/MockedTypeCascade.java @@ -13,6 +13,9 @@ import static mockit.internal.util.Utilities.containsReference; import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; @@ -30,9 +33,6 @@ import mockit.internal.state.TestRun; import mockit.internal.util.DefaultValues; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class MockedTypeCascade { @NonNull private static final CascadingTypes CASCADING_TYPES = TestRun.getExecutingTest().getCascadingTypes(); diff --git a/main/src/main/java/mockit/internal/expectations/transformation/ArgumentCapturing.java b/main/src/main/java/mockit/internal/expectations/transformation/ArgumentCapturing.java index 14d878f6a..551f56ef6 100644 --- a/main/src/main/java/mockit/internal/expectations/transformation/ArgumentCapturing.java +++ b/main/src/main/java/mockit/internal/expectations/transformation/ArgumentCapturing.java @@ -8,6 +8,9 @@ import static mockit.asm.jvmConstants.Opcodes.CHECKCAST; import static mockit.asm.jvmConstants.Opcodes.ISTORE; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -17,9 +20,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ArgumentCapturing { private static final Map varIndexToTypeDesc = new HashMap<>(); diff --git a/main/src/main/java/mockit/internal/expectations/transformation/ArgumentMatching.java b/main/src/main/java/mockit/internal/expectations/transformation/ArgumentMatching.java index 03e1234a3..ba2b8effa 100644 --- a/main/src/main/java/mockit/internal/expectations/transformation/ArgumentMatching.java +++ b/main/src/main/java/mockit/internal/expectations/transformation/ArgumentMatching.java @@ -7,13 +7,13 @@ import static mockit.asm.jvmConstants.Opcodes.GETFIELD; import static mockit.asm.jvmConstants.Opcodes.SIPUSH; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.methods.MethodWriter; import mockit.asm.types.JavaType; import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - final class ArgumentMatching { private static final JavaType[] NO_PARAMETERS = {}; private static final String ANY_FIELDS = "any anyString anyInt anyBoolean anyLong anyDouble anyFloat anyChar anyShort anyByte"; diff --git a/main/src/main/java/mockit/internal/expectations/transformation/Capture.java b/main/src/main/java/mockit/internal/expectations/transformation/Capture.java index 5116c66a3..4414c941f 100644 --- a/main/src/main/java/mockit/internal/expectations/transformation/Capture.java +++ b/main/src/main/java/mockit/internal/expectations/transformation/Capture.java @@ -10,6 +10,9 @@ import static mockit.internal.util.TypeConversionBytecode.generateCastOrUnboxing; import static mockit.internal.util.TypeConversionBytecode.isPrimitiveWrapper; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.methods.MethodWriter; import mockit.asm.types.ArrayType; import mockit.asm.types.JavaType; @@ -18,9 +21,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class Capture { @NonNull private final InvocationBlockModifier invocationBlockModifier; diff --git a/main/src/main/java/mockit/internal/expectations/transformation/ExpectationsTransformer.java b/main/src/main/java/mockit/internal/expectations/transformation/ExpectationsTransformer.java index 7a230e765..bbc863119 100644 --- a/main/src/main/java/mockit/internal/expectations/transformation/ExpectationsTransformer.java +++ b/main/src/main/java/mockit/internal/expectations/transformation/ExpectationsTransformer.java @@ -4,6 +4,9 @@ */ package mockit.internal.expectations.transformation; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassFileTransformer; import java.security.ProtectionDomain; @@ -16,9 +19,6 @@ import mockit.internal.util.ClassNaming; import mockit.internal.util.VisitInterruptedException; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ExpectationsTransformer implements ClassFileTransformer { private static final String BASE_CLASSES = "mockit/Expectations mockit/Verifications mockit/VerificationsInOrder mockit/FullVerifications"; diff --git a/main/src/main/java/mockit/internal/expectations/transformation/InvocationBlockModifier.java b/main/src/main/java/mockit/internal/expectations/transformation/InvocationBlockModifier.java index 4d6c6f91b..309001e36 100644 --- a/main/src/main/java/mockit/internal/expectations/transformation/InvocationBlockModifier.java +++ b/main/src/main/java/mockit/internal/expectations/transformation/InvocationBlockModifier.java @@ -22,6 +22,9 @@ import static mockit.internal.util.TypeConversionBytecode.isBoxing; import static mockit.internal.util.TypeConversionBytecode.isUnboxing; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.asm.controlFlow.Label; import mockit.asm.jvmConstants.JVMInstruction; import mockit.asm.methods.MethodWriter; @@ -30,9 +33,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class InvocationBlockModifier extends WrappingMethodVisitor { private static final String CLASS_DESC = "mockit/internal/expectations/ActiveInvocations"; diff --git a/main/src/main/java/mockit/internal/faking/CaptureOfFakedImplementations.java b/main/src/main/java/mockit/internal/faking/CaptureOfFakedImplementations.java index be533a932..027b484a5 100644 --- a/main/src/main/java/mockit/internal/faking/CaptureOfFakedImplementations.java +++ b/main/src/main/java/mockit/internal/faking/CaptureOfFakedImplementations.java @@ -6,6 +6,9 @@ import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Type; import mockit.MockUp; @@ -13,9 +16,6 @@ import mockit.internal.BaseClassModifier; import mockit.internal.capturing.CaptureOfImplementations; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class CaptureOfFakedImplementations extends CaptureOfImplementations { private final FakeClassSetup fakeClassSetup; diff --git a/main/src/main/java/mockit/internal/faking/FakeBridge.java b/main/src/main/java/mockit/internal/faking/FakeBridge.java index 1e9d3d3e8..61ddcc131 100644 --- a/main/src/main/java/mockit/internal/faking/FakeBridge.java +++ b/main/src/main/java/mockit/internal/faking/FakeBridge.java @@ -4,14 +4,14 @@ */ package mockit.internal.faking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import mockit.internal.ClassLoadingBridge; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class FakeBridge extends ClassLoadingBridge { @NonNull public static final ClassLoadingBridge MB = new FakeBridge(); diff --git a/main/src/main/java/mockit/internal/faking/FakeClassSetup.java b/main/src/main/java/mockit/internal/faking/FakeClassSetup.java index db85ea519..bed901fdb 100644 --- a/main/src/main/java/mockit/internal/faking/FakeClassSetup.java +++ b/main/src/main/java/mockit/internal/faking/FakeClassSetup.java @@ -4,6 +4,9 @@ */ package mockit.internal.faking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassDefinition; import java.lang.reflect.Proxy; import java.lang.reflect.Type; @@ -16,9 +19,6 @@ import mockit.internal.state.CachedClassfiles; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class FakeClassSetup { @NonNull final Class realClass; diff --git a/main/src/main/java/mockit/internal/faking/FakeClasses.java b/main/src/main/java/mockit/internal/faking/FakeClasses.java index 5c58a844c..6218092c0 100644 --- a/main/src/main/java/mockit/internal/faking/FakeClasses.java +++ b/main/src/main/java/mockit/internal/faking/FakeClasses.java @@ -4,6 +4,9 @@ */ package mockit.internal.faking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -14,9 +17,6 @@ import mockit.MockUp; import mockit.internal.util.ClassLoad; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class FakeClasses { private static final Field INVOKED_INSTANCE_FIELD; private static final Method ON_TEAR_DOWN_METHOD; diff --git a/main/src/main/java/mockit/internal/faking/FakeInvocation.java b/main/src/main/java/mockit/internal/faking/FakeInvocation.java index 40f7e603a..fd3d34397 100644 --- a/main/src/main/java/mockit/internal/faking/FakeInvocation.java +++ b/main/src/main/java/mockit/internal/faking/FakeInvocation.java @@ -6,6 +6,9 @@ import static mockit.internal.util.Utilities.NO_ARGS; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Constructor; import java.lang.reflect.Member; @@ -14,9 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * An invocation to a {@linkplain mockit.Mock fake} method. */ diff --git a/main/src/main/java/mockit/internal/faking/FakeMethodBridge.java b/main/src/main/java/mockit/internal/faking/FakeMethodBridge.java index 80bb15af0..987aedbbd 100644 --- a/main/src/main/java/mockit/internal/faking/FakeMethodBridge.java +++ b/main/src/main/java/mockit/internal/faking/FakeMethodBridge.java @@ -4,6 +4,9 @@ */ package mockit.internal.faking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import mockit.Invocation; @@ -14,9 +17,6 @@ import mockit.internal.util.DefaultValues; import mockit.internal.util.TypeDescriptor; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class FakeMethodBridge extends ClassLoadingBridge { @NonNull public static final ClassLoadingBridge MB = new FakeMethodBridge(); diff --git a/main/src/main/java/mockit/internal/faking/FakeMethodCollector.java b/main/src/main/java/mockit/internal/faking/FakeMethodCollector.java index 3c1867868..267d30114 100644 --- a/main/src/main/java/mockit/internal/faking/FakeMethodCollector.java +++ b/main/src/main/java/mockit/internal/faking/FakeMethodCollector.java @@ -9,6 +9,8 @@ import static mockit.asm.jvmConstants.Access.NATIVE; import static mockit.asm.jvmConstants.Access.SYNTHETIC; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.EnumSet; import java.util.List; @@ -22,8 +24,6 @@ import mockit.internal.faking.FakeMethods.FakeMethod; import mockit.internal.util.ClassLoad; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Responsible for collecting the signatures of all methods defined in a given fake class which are explicitly annotated * as {@link Mock fakes}. diff --git a/main/src/main/java/mockit/internal/faking/FakeMethods.java b/main/src/main/java/mockit/internal/faking/FakeMethods.java index 1c54fdfa3..268e9a3d3 100644 --- a/main/src/main/java/mockit/internal/faking/FakeMethods.java +++ b/main/src/main/java/mockit/internal/faking/FakeMethods.java @@ -8,6 +8,9 @@ import static mockit.internal.util.ObjectMethods.isMethodFromObject; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.lang.reflect.Modifier; @@ -22,9 +25,6 @@ import mockit.internal.util.TypeDescriptor; import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A container for the fake methods "collected" from a fake class. */ diff --git a/main/src/main/java/mockit/internal/faking/FakeState.java b/main/src/main/java/mockit/internal/faking/FakeState.java index 32ff5b0e5..f57972287 100644 --- a/main/src/main/java/mockit/internal/faking/FakeState.java +++ b/main/src/main/java/mockit/internal/faking/FakeState.java @@ -4,6 +4,9 @@ */ package mockit.internal.faking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Member; import java.lang.reflect.Method; @@ -12,9 +15,6 @@ import mockit.internal.reflection.RealMethodOrConstructor; import mockit.internal.util.ClassLoad; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class FakeState { private static final ClassLoader THIS_CL = FakeState.class.getClassLoader(); diff --git a/main/src/main/java/mockit/internal/faking/FakeStates.java b/main/src/main/java/mockit/internal/faking/FakeStates.java index aee65ee27..33351c26f 100644 --- a/main/src/main/java/mockit/internal/faking/FakeStates.java +++ b/main/src/main/java/mockit/internal/faking/FakeStates.java @@ -4,6 +4,9 @@ */ package mockit.internal.faking; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.IdentityHashMap; import java.util.Iterator; @@ -16,9 +19,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Holds state associated with fake class containing {@linkplain mockit.Mock annotated fakes}. */ diff --git a/main/src/main/java/mockit/internal/faking/FakedClassModifier.java b/main/src/main/java/mockit/internal/faking/FakedClassModifier.java index 2a60092d6..ad0d4d2c9 100644 --- a/main/src/main/java/mockit/internal/faking/FakedClassModifier.java +++ b/main/src/main/java/mockit/internal/faking/FakedClassModifier.java @@ -25,6 +25,9 @@ import static mockit.asm.jvmConstants.Opcodes.RETURN; import static mockit.asm.jvmConstants.Opcodes.SIPUSH; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.MockUp; import mockit.asm.classes.ClassReader; import mockit.asm.controlFlow.Label; @@ -39,9 +42,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Responsible for generating all necessary bytecode in the redefined (real) class. Such code will redirect calls made * on "real" methods to equivalent calls on the corresponding "fake" methods. The original code won't be executed by the diff --git a/main/src/main/java/mockit/internal/faking/FakedImplementationClass.java b/main/src/main/java/mockit/internal/faking/FakedImplementationClass.java index 63babb7b9..3293d93b3 100644 --- a/main/src/main/java/mockit/internal/faking/FakedImplementationClass.java +++ b/main/src/main/java/mockit/internal/faking/FakedImplementationClass.java @@ -6,6 +6,9 @@ import static java.lang.reflect.Modifier.isPublic; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Proxy; import java.lang.reflect.Type; @@ -16,9 +19,6 @@ import mockit.internal.expectations.mocking.InterfaceImplementationGenerator; import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class FakedImplementationClass { private static final ClassLoader THIS_CL = FakedImplementationClass.class.getClassLoader(); diff --git a/main/src/main/java/mockit/internal/injection/BeanExporter.java b/main/src/main/java/mockit/internal/injection/BeanExporter.java index 4a3b3eb0e..34d933e25 100644 --- a/main/src/main/java/mockit/internal/injection/BeanExporter.java +++ b/main/src/main/java/mockit/internal/injection/BeanExporter.java @@ -4,13 +4,13 @@ */ package mockit.internal.injection; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.injection.InjectionPoint.KindOfInjectionPoint; import mockit.internal.injection.field.FieldInjection; import mockit.internal.injection.full.FullInjection; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class BeanExporter { @NonNull private final InjectionState injectionState; diff --git a/main/src/main/java/mockit/internal/injection/InjectionPoint.java b/main/src/main/java/mockit/internal/injection/InjectionPoint.java index 2e9aa1816..331f5b697 100644 --- a/main/src/main/java/mockit/internal/injection/InjectionPoint.java +++ b/main/src/main/java/mockit/internal/injection/InjectionPoint.java @@ -12,6 +12,9 @@ import static mockit.internal.reflection.ParameterReflection.NO_PARAMETERS; import static mockit.internal.util.ClassLoad.searchTypeInClasspath; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.AccessibleObject; import java.lang.reflect.Constructor; @@ -32,9 +35,6 @@ import javax.persistence.PersistenceUnit; import javax.servlet.Servlet; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class InjectionPoint { public enum KindOfInjectionPoint { NotAnnotated, Required, Optional diff --git a/main/src/main/java/mockit/internal/injection/InjectionProvider.java b/main/src/main/java/mockit/internal/injection/InjectionProvider.java index e9382388b..66f9fa2fb 100644 --- a/main/src/main/java/mockit/internal/injection/InjectionProvider.java +++ b/main/src/main/java/mockit/internal/injection/InjectionProvider.java @@ -4,12 +4,12 @@ */ package mockit.internal.injection; -import java.lang.annotation.Annotation; -import java.lang.reflect.Type; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; + /** * Provides type, name, and value(s) for an injection point, which is either a field to be injected or a parameter in * the chosen constructor of a tested class. diff --git a/main/src/main/java/mockit/internal/injection/InjectionProviders.java b/main/src/main/java/mockit/internal/injection/InjectionProviders.java index 1ad0766ad..ada894536 100644 --- a/main/src/main/java/mockit/internal/injection/InjectionProviders.java +++ b/main/src/main/java/mockit/internal/injection/InjectionProviders.java @@ -7,6 +7,9 @@ import static mockit.internal.injection.InjectionPoint.INJECT_CLASS; import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.ArrayList; @@ -18,9 +21,6 @@ import mockit.internal.injection.InjectionPoint.KindOfInjectionPoint; import mockit.internal.reflection.GenericTypeReflection; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class InjectionProviders { @NonNull private List injectables; diff --git a/main/src/main/java/mockit/internal/injection/InjectionState.java b/main/src/main/java/mockit/internal/injection/InjectionState.java index e50942a78..3413960dc 100644 --- a/main/src/main/java/mockit/internal/injection/InjectionState.java +++ b/main/src/main/java/mockit/internal/injection/InjectionState.java @@ -6,6 +6,9 @@ import static mockit.internal.injection.InjectionPoint.getQualifiedName; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Field; import java.lang.reflect.Type; import java.util.LinkedHashMap; @@ -17,9 +20,6 @@ import mockit.internal.reflection.FieldReflection; import mockit.internal.reflection.GenericTypeReflection; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Holds state used throughout the injection process while it's in progress for a given set of tested objects. */ diff --git a/main/src/main/java/mockit/internal/injection/Injector.java b/main/src/main/java/mockit/internal/injection/Injector.java index 74c585ef6..e72688f85 100644 --- a/main/src/main/java/mockit/internal/injection/Injector.java +++ b/main/src/main/java/mockit/internal/injection/Injector.java @@ -17,6 +17,9 @@ import static mockit.internal.injection.InjectionPoint.wrapInProviderIfNeeded; import static mockit.internal.injection.InjectionProvider.NULL; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Field; import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; @@ -32,9 +35,6 @@ import mockit.internal.reflection.FieldReflection; import mockit.internal.util.DefaultValues; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public class Injector { private static final Pattern TYPE_NAME = compile("class |interface |java\\.lang\\."); diff --git a/main/src/main/java/mockit/internal/injection/InterfaceResolution.java b/main/src/main/java/mockit/internal/injection/InterfaceResolution.java index 2905e404b..19c169b8c 100644 --- a/main/src/main/java/mockit/internal/injection/InterfaceResolution.java +++ b/main/src/main/java/mockit/internal/injection/InterfaceResolution.java @@ -7,6 +7,9 @@ import static mockit.internal.reflection.MethodReflection.invoke; import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; @@ -15,9 +18,6 @@ import java.util.NavigableMap; import java.util.TreeMap; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class InterfaceResolution { @NonNull private final NavigableMap interfaceResolutionMethods; diff --git a/main/src/main/java/mockit/internal/injection/LifecycleMethods.java b/main/src/main/java/mockit/internal/injection/LifecycleMethods.java index 60a15886b..eb5087ee1 100644 --- a/main/src/main/java/mockit/internal/injection/LifecycleMethods.java +++ b/main/src/main/java/mockit/internal/injection/LifecycleMethods.java @@ -9,6 +9,9 @@ import static mockit.internal.reflection.ParameterReflection.getParameterCount; import static mockit.internal.util.Utilities.NO_ARGS; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.util.ArrayList; @@ -24,9 +27,6 @@ import mockit.internal.reflection.MethodReflection; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class LifecycleMethods { @NonNull private final List> classesSearched; diff --git a/main/src/main/java/mockit/internal/injection/MultiValuedProvider.java b/main/src/main/java/mockit/internal/injection/MultiValuedProvider.java index 68d061e9e..499aa81ce 100644 --- a/main/src/main/java/mockit/internal/injection/MultiValuedProvider.java +++ b/main/src/main/java/mockit/internal/injection/MultiValuedProvider.java @@ -6,13 +6,13 @@ import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Type; import java.util.ArrayList; import java.util.List; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class MultiValuedProvider extends InjectionProvider { @NonNull private final List individualProviders; diff --git a/main/src/main/java/mockit/internal/injection/TestedClass.java b/main/src/main/java/mockit/internal/injection/TestedClass.java index 87fccf88e..a16a77d82 100644 --- a/main/src/main/java/mockit/internal/injection/TestedClass.java +++ b/main/src/main/java/mockit/internal/injection/TestedClass.java @@ -4,6 +4,9 @@ */ package mockit.internal.injection; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.File; import java.lang.reflect.Type; import java.security.CodeSource; @@ -12,9 +15,6 @@ import mockit.internal.reflection.GenericTypeReflection; import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class TestedClass { @NonNull final Type declaredType; diff --git a/main/src/main/java/mockit/internal/injection/TestedClassInstantiations.java b/main/src/main/java/mockit/internal/injection/TestedClassInstantiations.java index b35b7a354..7afdd0904 100644 --- a/main/src/main/java/mockit/internal/injection/TestedClassInstantiations.java +++ b/main/src/main/java/mockit/internal/injection/TestedClassInstantiations.java @@ -6,6 +6,8 @@ import static mockit.internal.injection.TestedObject.getTestedAnnotationIfPresent; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.Method; @@ -20,8 +22,6 @@ import mockit.asm.jvmConstants.Access; import mockit.internal.expectations.mocking.MockedType; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class TestedClassInstantiations { private static final int FIELD_ACCESS_MASK = Access.SYNTHETIC + Access.STATIC; private static final int METHOD_ACCESS_MASK = Access.BRIDGE + Access.VARARGS + Access.NATIVE + Access.ABSTRACT diff --git a/main/src/main/java/mockit/internal/injection/TestedField.java b/main/src/main/java/mockit/internal/injection/TestedField.java index 1da9c4ee3..395db8415 100644 --- a/main/src/main/java/mockit/internal/injection/TestedField.java +++ b/main/src/main/java/mockit/internal/injection/TestedField.java @@ -9,14 +9,14 @@ import static mockit.internal.reflection.FieldReflection.getFieldValue; import static mockit.internal.reflection.FieldReflection.setFieldValue; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Field; import mockit.Tested; import mockit.internal.util.TypeConversion; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class TestedField extends TestedObject { @NonNull private final Field testedField; diff --git a/main/src/main/java/mockit/internal/injection/TestedObject.java b/main/src/main/java/mockit/internal/injection/TestedObject.java index bb5adb30a..f3b85c431 100644 --- a/main/src/main/java/mockit/internal/injection/TestedObject.java +++ b/main/src/main/java/mockit/internal/injection/TestedObject.java @@ -7,6 +7,9 @@ import static mockit.internal.util.AutoBoxing.isWrapperOfPrimitiveType; import static mockit.internal.util.DefaultValues.defaultValueForPrimitiveType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.Type; @@ -16,9 +19,6 @@ import mockit.internal.injection.field.FieldInjection; import mockit.internal.injection.full.FullInjection; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - abstract class TestedObject { @NonNull private final InjectionState injectionState; diff --git a/main/src/main/java/mockit/internal/injection/TestedObjectCreation.java b/main/src/main/java/mockit/internal/injection/TestedObjectCreation.java index 862871c56..c6a7dd07f 100644 --- a/main/src/main/java/mockit/internal/injection/TestedObjectCreation.java +++ b/main/src/main/java/mockit/internal/injection/TestedObjectCreation.java @@ -6,6 +6,9 @@ import static java.lang.reflect.Modifier.isAbstract; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Constructor; import java.lang.reflect.Type; @@ -18,9 +21,6 @@ import mockit.internal.injection.full.FullInjection; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class TestedObjectCreation { @NonNull private final InjectionState injectionState; diff --git a/main/src/main/java/mockit/internal/injection/TestedParameter.java b/main/src/main/java/mockit/internal/injection/TestedParameter.java index 2d7ba3bea..df5d5736f 100644 --- a/main/src/main/java/mockit/internal/injection/TestedParameter.java +++ b/main/src/main/java/mockit/internal/injection/TestedParameter.java @@ -4,6 +4,9 @@ */ package mockit.internal.injection; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.Tested; import mockit.internal.state.ParameterNames; import mockit.internal.util.TestMethod; @@ -11,9 +14,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class TestedParameter extends TestedObject { @NonNull private final TestMethod testMethod; diff --git a/main/src/main/java/mockit/internal/injection/TestedParameters.java b/main/src/main/java/mockit/internal/injection/TestedParameters.java index 6711be4c8..45d90d331 100644 --- a/main/src/main/java/mockit/internal/injection/TestedParameters.java +++ b/main/src/main/java/mockit/internal/injection/TestedParameters.java @@ -4,6 +4,9 @@ */ package mockit.internal.injection; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.util.List; @@ -13,9 +16,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class TestedParameters { @NonNull private final TestMethod testMethod; diff --git a/main/src/main/java/mockit/internal/injection/constructor/ConstructorInjection.java b/main/src/main/java/mockit/internal/injection/constructor/ConstructorInjection.java index 50eddc83c..fe25ae6b1 100644 --- a/main/src/main/java/mockit/internal/injection/constructor/ConstructorInjection.java +++ b/main/src/main/java/mockit/internal/injection/constructor/ConstructorInjection.java @@ -14,6 +14,9 @@ import static mockit.internal.util.Utilities.ensureThatMemberIsAccessible; import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Type; @@ -33,9 +36,6 @@ import mockit.internal.util.MethodFormatter; import mockit.internal.util.StackTrace; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ConstructorInjection extends Injector { @NonNull private final Constructor constructor; diff --git a/main/src/main/java/mockit/internal/injection/constructor/ConstructorParameter.java b/main/src/main/java/mockit/internal/injection/constructor/ConstructorParameter.java index 5c698f3ff..5fe64030b 100644 --- a/main/src/main/java/mockit/internal/injection/constructor/ConstructorParameter.java +++ b/main/src/main/java/mockit/internal/injection/constructor/ConstructorParameter.java @@ -6,14 +6,14 @@ import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Type; import mockit.internal.injection.InjectionProvider; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class ConstructorParameter extends InjectionProvider { @NonNull private final Class classOfDeclaredType; diff --git a/main/src/main/java/mockit/internal/injection/constructor/ConstructorSearch.java b/main/src/main/java/mockit/internal/injection/constructor/ConstructorSearch.java index 656f16a70..02cfec981 100644 --- a/main/src/main/java/mockit/internal/injection/constructor/ConstructorSearch.java +++ b/main/src/main/java/mockit/internal/injection/constructor/ConstructorSearch.java @@ -12,6 +12,9 @@ import static mockit.internal.injection.InjectionPoint.getTypeOfInjectionPointFromVarargsParameter; import static mockit.internal.injection.InjectionPoint.kindOfInjectionPoint; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; import java.lang.reflect.Type; @@ -30,9 +33,6 @@ import mockit.internal.state.ParameterNames; import mockit.internal.util.ParameterNameExtractor; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ConstructorSearch { private static final int CONSTRUCTOR_ACCESS = PUBLIC + PROTECTED + PRIVATE; diff --git a/main/src/main/java/mockit/internal/injection/field/FieldInjection.java b/main/src/main/java/mockit/internal/injection/field/FieldInjection.java index 521df8f51..f6c648183 100644 --- a/main/src/main/java/mockit/internal/injection/field/FieldInjection.java +++ b/main/src/main/java/mockit/internal/injection/field/FieldInjection.java @@ -4,13 +4,13 @@ */ package mockit.internal.injection.field; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.injection.InjectionState; import mockit.internal.injection.Injector; import mockit.internal.injection.full.FullInjection; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class FieldInjection extends Injector { public FieldInjection(@NonNull InjectionState injectionState, @Nullable FullInjection fullInjection) { super(injectionState, fullInjection); diff --git a/main/src/main/java/mockit/internal/injection/field/FieldToInject.java b/main/src/main/java/mockit/internal/injection/field/FieldToInject.java index 712150718..4b8a73274 100644 --- a/main/src/main/java/mockit/internal/injection/field/FieldToInject.java +++ b/main/src/main/java/mockit/internal/injection/field/FieldToInject.java @@ -4,6 +4,8 @@ */ package mockit.internal.injection.field; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.annotation.Annotation; import java.lang.reflect.Field; @@ -11,8 +13,6 @@ import mockit.internal.injection.InjectionPoint.KindOfInjectionPoint; import mockit.internal.injection.InjectionProvider; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class FieldToInject extends InjectionProvider { @NonNull private final Field targetField; diff --git a/main/src/main/java/mockit/internal/injection/full/FullInjection.java b/main/src/main/java/mockit/internal/injection/full/FullInjection.java index d666be215..2013d134a 100644 --- a/main/src/main/java/mockit/internal/injection/full/FullInjection.java +++ b/main/src/main/java/mockit/internal/injection/full/FullInjection.java @@ -13,6 +13,9 @@ import static mockit.internal.reflection.ConstructorReflection.newInstanceUsingDefaultConstructorIfAvailable; import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; @@ -33,9 +36,6 @@ import mockit.internal.injection.TestedClass; import mockit.internal.injection.TestedObjectCreation; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Responsible for recursive injection of dependencies into a @Tested(fullyInitialized = true) object. */ diff --git a/main/src/main/java/mockit/internal/injection/full/JPADependencies.java b/main/src/main/java/mockit/internal/injection/full/JPADependencies.java index de0a5d699..72404816a 100644 --- a/main/src/main/java/mockit/internal/injection/full/JPADependencies.java +++ b/main/src/main/java/mockit/internal/injection/full/JPADependencies.java @@ -4,6 +4,9 @@ */ package mockit.internal.injection.full; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.io.IOException; import java.io.InputStream; import java.lang.annotation.Annotation; @@ -25,9 +28,6 @@ import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHandler; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Detects and resolves dependencies belonging to the javax.persistence API, namely * EntityManagerFactory and EntityManager. diff --git a/main/src/main/java/mockit/internal/injection/full/ServletDependencies.java b/main/src/main/java/mockit/internal/injection/full/ServletDependencies.java index 2f225fc91..41ab4de81 100644 --- a/main/src/main/java/mockit/internal/injection/full/ServletDependencies.java +++ b/main/src/main/java/mockit/internal/injection/full/ServletDependencies.java @@ -6,6 +6,8 @@ import static java.util.Collections.enumeration; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.InputStream; import java.net.URL; import java.util.Enumeration; @@ -31,8 +33,6 @@ import mockit.internal.injection.InjectionPoint; import mockit.internal.injection.InjectionState; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * Detects and resolves dependencies belonging to the javax.servlet API, namely ServletContext * and HttpSession. diff --git a/main/src/main/java/mockit/internal/injection/full/TestDataSource.java b/main/src/main/java/mockit/internal/injection/full/TestDataSource.java index 34b8863df..39720cb2e 100644 --- a/main/src/main/java/mockit/internal/injection/full/TestDataSource.java +++ b/main/src/main/java/mockit/internal/injection/full/TestDataSource.java @@ -4,6 +4,9 @@ */ package mockit.internal.injection.full; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.beans.BeanInfo; import java.beans.IntrospectionException; import java.beans.Introspector; @@ -19,9 +22,6 @@ import mockit.internal.injection.InjectionPoint; import mockit.internal.injection.TestedClass; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class TestDataSource { @Nullable private final String dsName; diff --git a/main/src/main/java/mockit/internal/reflection/AnnotationReflection.java b/main/src/main/java/mockit/internal/reflection/AnnotationReflection.java index 44e3bec93..be1833864 100644 --- a/main/src/main/java/mockit/internal/reflection/AnnotationReflection.java +++ b/main/src/main/java/mockit/internal/reflection/AnnotationReflection.java @@ -6,12 +6,12 @@ import static mockit.internal.reflection.ParameterReflection.NO_PARAMETERS; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + public final class AnnotationReflection { private AnnotationReflection() { } diff --git a/main/src/main/java/mockit/internal/reflection/ConstructorReflection.java b/main/src/main/java/mockit/internal/reflection/ConstructorReflection.java index c60e736cd..421158c78 100644 --- a/main/src/main/java/mockit/internal/reflection/ConstructorReflection.java +++ b/main/src/main/java/mockit/internal/reflection/ConstructorReflection.java @@ -9,14 +9,14 @@ import static mockit.internal.reflection.ParameterReflection.matchesParameterTypes; import static mockit.internal.util.Utilities.ensureThatMemberIsAccessible; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import org.objenesis.instantiator.sun.SunReflectionFactoryInstantiator; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ConstructorReflection { private ConstructorReflection() { } diff --git a/main/src/main/java/mockit/internal/reflection/EmptyProxy.java b/main/src/main/java/mockit/internal/reflection/EmptyProxy.java index 9c566ba6c..46fa5c9b7 100644 --- a/main/src/main/java/mockit/internal/reflection/EmptyProxy.java +++ b/main/src/main/java/mockit/internal/reflection/EmptyProxy.java @@ -4,6 +4,9 @@ */ package mockit.internal.reflection; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.ParameterizedType; import java.lang.reflect.Proxy; import java.lang.reflect.Type; @@ -11,9 +14,6 @@ import java.util.ArrayList; import java.util.List; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * This marker interface exists only to guarantee that JMockit can get the bytecode definition of each Proxy class it * creates through java.lang.reflect.Proxy. If such a class is created before JMockit is initialized, its diff --git a/main/src/main/java/mockit/internal/reflection/FieldReflection.java b/main/src/main/java/mockit/internal/reflection/FieldReflection.java index d246d6e98..740b1df61 100644 --- a/main/src/main/java/mockit/internal/reflection/FieldReflection.java +++ b/main/src/main/java/mockit/internal/reflection/FieldReflection.java @@ -8,15 +8,15 @@ import static mockit.internal.util.Utilities.ensureThatMemberIsAccessible; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Field; import java.lang.reflect.Type; import mockit.internal.util.AutoBoxing; import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class FieldReflection { private FieldReflection() { } diff --git a/main/src/main/java/mockit/internal/reflection/GenericTypeReflection.java b/main/src/main/java/mockit/internal/reflection/GenericTypeReflection.java index 45a324cc9..f969fc286 100644 --- a/main/src/main/java/mockit/internal/reflection/GenericTypeReflection.java +++ b/main/src/main/java/mockit/internal/reflection/GenericTypeReflection.java @@ -4,6 +4,9 @@ */ package mockit.internal.reflection; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.GenericArrayType; import java.lang.reflect.GenericDeclaration; import java.lang.reflect.Member; @@ -18,9 +21,6 @@ import java.util.Map; import java.util.Map.Entry; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - @SuppressWarnings("OverlyComplexClass") public final class GenericTypeReflection { @NonNull diff --git a/main/src/main/java/mockit/internal/reflection/MethodReflection.java b/main/src/main/java/mockit/internal/reflection/MethodReflection.java index 4d0464fdd..4261ce96b 100644 --- a/main/src/main/java/mockit/internal/reflection/MethodReflection.java +++ b/main/src/main/java/mockit/internal/reflection/MethodReflection.java @@ -9,6 +9,9 @@ import static mockit.internal.reflection.ParameterReflection.*; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.regex.Pattern; @@ -17,9 +20,6 @@ import mockit.internal.util.StackTrace; import mockit.internal.util.Utilities; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class MethodReflection { @NonNull public static final Pattern JAVA_LANG = Pattern.compile("java.lang.", Pattern.LITERAL); diff --git a/main/src/main/java/mockit/internal/reflection/MockInvocationHandler.java b/main/src/main/java/mockit/internal/reflection/MockInvocationHandler.java index 86537876b..02a9e5709 100644 --- a/main/src/main/java/mockit/internal/reflection/MockInvocationHandler.java +++ b/main/src/main/java/mockit/internal/reflection/MockInvocationHandler.java @@ -4,6 +4,9 @@ */ package mockit.internal.reflection; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationHandler; @@ -12,9 +15,6 @@ import mockit.internal.util.DefaultValues; import mockit.internal.util.ObjectMethods; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Handles invocations to all kinds of mock implementations created for interfaces and annotation types through any of * the mocking APIs. diff --git a/main/src/main/java/mockit/internal/reflection/ParameterReflection.java b/main/src/main/java/mockit/internal/reflection/ParameterReflection.java index 266fab445..b2e09a63e 100644 --- a/main/src/main/java/mockit/internal/reflection/ParameterReflection.java +++ b/main/src/main/java/mockit/internal/reflection/ParameterReflection.java @@ -7,6 +7,8 @@ import static mockit.internal.reflection.MethodReflection.JAVA_LANG; import static mockit.internal.util.Utilities.JAVA8; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.reflect.Method; import mockit.Invocation; @@ -15,8 +17,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class ParameterReflection { @NonNull public static final Class[] NO_PARAMETERS = {}; diff --git a/main/src/main/java/mockit/internal/reflection/RealMethodOrConstructor.java b/main/src/main/java/mockit/internal/reflection/RealMethodOrConstructor.java index 2ba7796ee..357fb9c35 100644 --- a/main/src/main/java/mockit/internal/reflection/RealMethodOrConstructor.java +++ b/main/src/main/java/mockit/internal/reflection/RealMethodOrConstructor.java @@ -4,6 +4,9 @@ */ package mockit.internal.reflection; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Constructor; import java.lang.reflect.Member; import java.lang.reflect.Method; @@ -11,9 +14,6 @@ import mockit.internal.util.ClassLoad; import mockit.internal.util.TypeDescriptor; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class RealMethodOrConstructor { @NonNull public final Member member; diff --git a/main/src/main/java/mockit/internal/startup/ClassLoadingBridgeFields.java b/main/src/main/java/mockit/internal/startup/ClassLoadingBridgeFields.java index 39c14be81..cbf8c2b24 100644 --- a/main/src/main/java/mockit/internal/startup/ClassLoadingBridgeFields.java +++ b/main/src/main/java/mockit/internal/startup/ClassLoadingBridgeFields.java @@ -8,6 +8,9 @@ import static java.lang.reflect.Modifier.STATIC; import static java.lang.reflect.Modifier.isPublic; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassFileTransformer; import java.lang.instrument.Instrumentation; import java.security.ProtectionDomain; @@ -23,9 +26,6 @@ import mockit.internal.faking.FakeBridge; import mockit.internal.faking.FakeMethodBridge; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - final class ClassLoadingBridgeFields { private ClassLoadingBridgeFields() { } diff --git a/main/src/main/java/mockit/internal/startup/JMockitInitialization.java b/main/src/main/java/mockit/internal/startup/JMockitInitialization.java index 602e13d5f..d8eae1a20 100644 --- a/main/src/main/java/mockit/internal/startup/JMockitInitialization.java +++ b/main/src/main/java/mockit/internal/startup/JMockitInitialization.java @@ -9,6 +9,8 @@ import static mockit.internal.util.ClassLoad.loadClassAtStartup; import static mockit.internal.util.ClassLoad.searchTypeInClasspath; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.instrument.Instrumentation; import java.util.Collection; import java.util.Collections; @@ -22,8 +24,6 @@ import mockit.internal.reflection.ConstructorReflection; import mockit.internal.util.StackTrace; -import edu.umd.cs.findbugs.annotations.NonNull; - final class JMockitInitialization { private JMockitInitialization() { } diff --git a/main/src/main/java/mockit/internal/startup/Startup.java b/main/src/main/java/mockit/internal/startup/Startup.java index 199e42776..a4c10988e 100644 --- a/main/src/main/java/mockit/internal/startup/Startup.java +++ b/main/src/main/java/mockit/internal/startup/Startup.java @@ -6,6 +6,9 @@ import static mockit.internal.startup.ClassLoadingBridgeFields.createSyntheticFieldsInJREClassToHoldClassLoadingBridges; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassDefinition; import java.lang.instrument.Instrumentation; import java.lang.instrument.UnmodifiableClassException; @@ -14,9 +17,6 @@ import mockit.internal.expectations.transformation.ExpectationsTransformer; import mockit.internal.state.CachedClassfiles; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * This is the "agent class" that initializes the JMockit "Java agent", provided the JVM is initialized with * diff --git a/main/src/main/java/mockit/internal/state/CachedClassfiles.java b/main/src/main/java/mockit/internal/state/CachedClassfiles.java index 1af921c11..659ef2ec5 100644 --- a/main/src/main/java/mockit/internal/state/CachedClassfiles.java +++ b/main/src/main/java/mockit/internal/state/CachedClassfiles.java @@ -4,6 +4,9 @@ */ package mockit.internal.state; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassFileTransformer; import java.security.ProtectionDomain; import java.util.HashMap; @@ -12,9 +15,6 @@ import mockit.internal.startup.Startup; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Holds a map of internal class names to the corresponding class files (bytecode arrays), for the classes that have * already been loaded during the test run. These classfiles are not necessarily the same as those stored in the diff --git a/main/src/main/java/mockit/internal/state/MockFixture.java b/main/src/main/java/mockit/internal/state/MockFixture.java index 5e376cf2c..d678f1a79 100644 --- a/main/src/main/java/mockit/internal/state/MockFixture.java +++ b/main/src/main/java/mockit/internal/state/MockFixture.java @@ -11,6 +11,9 @@ import static mockit.internal.util.GeneratedClasses.isGeneratedImplementationClass; import static mockit.internal.util.Utilities.getClassType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.instrument.ClassDefinition; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -35,9 +38,6 @@ import mockit.internal.startup.Startup; import mockit.internal.util.ClassLoad; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Holds data about redefined/transformed classes, with methods to add/remove and query such data. */ diff --git a/main/src/main/java/mockit/internal/state/ParameterNames.java b/main/src/main/java/mockit/internal/state/ParameterNames.java index 712e38f73..fc41723cf 100644 --- a/main/src/main/java/mockit/internal/state/ParameterNames.java +++ b/main/src/main/java/mockit/internal/state/ParameterNames.java @@ -4,6 +4,9 @@ */ package mockit.internal.state; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.HashMap; import java.util.Map; @@ -11,9 +14,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ParameterNames { private static final Map> classesToMethodsToParameters = new HashMap<>(); diff --git a/main/src/main/java/mockit/internal/state/SavePoint.java b/main/src/main/java/mockit/internal/state/SavePoint.java index d883ec3c2..d933d90c5 100644 --- a/main/src/main/java/mockit/internal/state/SavePoint.java +++ b/main/src/main/java/mockit/internal/state/SavePoint.java @@ -6,6 +6,8 @@ import static mockit.internal.expectations.RecordAndReplayExecution.RECORD_OR_REPLAY_LOCK; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.List; import java.util.Map; import java.util.Set; @@ -13,8 +15,6 @@ import mockit.internal.ClassIdentification; import mockit.internal.faking.FakeClasses; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class SavePoint { @NonNull private final Set previousTransformedClasses; diff --git a/main/src/main/java/mockit/internal/state/TestRun.java b/main/src/main/java/mockit/internal/state/TestRun.java index 157445330..854f6985f 100644 --- a/main/src/main/java/mockit/internal/state/TestRun.java +++ b/main/src/main/java/mockit/internal/state/TestRun.java @@ -4,6 +4,9 @@ */ package mockit.internal.state; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import mockit.internal.expectations.RecordAndReplayExecution; import mockit.internal.expectations.mocking.FieldTypeRedefinitions; import mockit.internal.expectations.state.ExecutingTest; @@ -12,9 +15,6 @@ import mockit.internal.injection.TestedClassInstantiations; import mockit.internal.util.StackTrace; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * A singleton which stores several data structures which in turn hold global state for individual test methods, test * classes, and for the test run as a whole. diff --git a/main/src/main/java/mockit/internal/util/AutoBoxing.java b/main/src/main/java/mockit/internal/util/AutoBoxing.java index 1238ac980..1ed9ff662 100644 --- a/main/src/main/java/mockit/internal/util/AutoBoxing.java +++ b/main/src/main/java/mockit/internal/util/AutoBoxing.java @@ -4,12 +4,12 @@ */ package mockit.internal.util; -import java.util.HashMap; -import java.util.Map; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.util.HashMap; +import java.util.Map; + public final class AutoBoxing { private static final Map, Class> PRIMITIVE_TO_WRAPPER = new HashMap<>(); private static final Map, Class> WRAPPER_TO_PRIMITIVE = new HashMap<>(); diff --git a/main/src/main/java/mockit/internal/util/ClassLoad.java b/main/src/main/java/mockit/internal/util/ClassLoad.java index 4e7b89190..2a851a35f 100644 --- a/main/src/main/java/mockit/internal/util/ClassLoad.java +++ b/main/src/main/java/mockit/internal/util/ClassLoad.java @@ -4,14 +4,14 @@ */ package mockit.internal.util; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import mockit.internal.state.TestRun; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class ClassLoad { public static final String OBJECT = "java/lang/Object"; diff --git a/main/src/main/java/mockit/internal/util/DefaultValues.java b/main/src/main/java/mockit/internal/util/DefaultValues.java index 1326822a4..29c6f249b 100644 --- a/main/src/main/java/mockit/internal/util/DefaultValues.java +++ b/main/src/main/java/mockit/internal/util/DefaultValues.java @@ -14,6 +14,9 @@ import static mockit.internal.util.Utilities.JAVA8; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.reflect.Array; import java.lang.reflect.Type; import java.util.HashMap; @@ -37,9 +40,6 @@ import mockit.asm.types.ArrayType; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Provides default values for each type, typically used for returning default values according to method return types. */ diff --git a/main/src/main/java/mockit/internal/util/GeneratedClasses.java b/main/src/main/java/mockit/internal/util/GeneratedClasses.java index 38d8c58d4..96c0e035a 100644 --- a/main/src/main/java/mockit/internal/util/GeneratedClasses.java +++ b/main/src/main/java/mockit/internal/util/GeneratedClasses.java @@ -4,11 +4,11 @@ */ package mockit.internal.util; -import java.lang.reflect.Proxy; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; +import java.lang.reflect.Proxy; + public final class GeneratedClasses { private static final String IMPLCLASS_PREFIX = "$Impl_"; private static final String SUBCLASS_PREFIX = "$Subclass_"; diff --git a/main/src/main/java/mockit/internal/util/MethodFormatter.java b/main/src/main/java/mockit/internal/util/MethodFormatter.java index fb17b0618..d290b0926 100644 --- a/main/src/main/java/mockit/internal/util/MethodFormatter.java +++ b/main/src/main/java/mockit/internal/util/MethodFormatter.java @@ -4,15 +4,15 @@ */ package mockit.internal.util; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; import java.util.regex.Pattern; import mockit.internal.state.ParameterNames; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class MethodFormatter { private static final Pattern CONSTRUCTOR_NAME = Pattern.compile(""); private static final Pattern JAVA_LANG_PREFIX = Pattern.compile("java/lang/"); diff --git a/main/src/main/java/mockit/internal/util/ParameterNameExtractor.java b/main/src/main/java/mockit/internal/util/ParameterNameExtractor.java index 4762aced5..fe8f4e8c3 100644 --- a/main/src/main/java/mockit/internal/util/ParameterNameExtractor.java +++ b/main/src/main/java/mockit/internal/util/ParameterNameExtractor.java @@ -4,6 +4,8 @@ */ package mockit.internal.util; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.EnumSet; import java.util.List; @@ -13,8 +15,6 @@ import mockit.internal.ClassFile; import mockit.internal.state.ParameterNames; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class ParameterNameExtractor { private static final EnumSet PARAMETERS = EnumSet.of(Attribute.Parameters); diff --git a/main/src/main/java/mockit/internal/util/StackTrace.java b/main/src/main/java/mockit/internal/util/StackTrace.java index b2fd91965..20b6e47f9 100644 --- a/main/src/main/java/mockit/internal/util/StackTrace.java +++ b/main/src/main/java/mockit/internal/util/StackTrace.java @@ -4,10 +4,10 @@ */ package mockit.internal.util; -import java.io.IOException; - import edu.umd.cs.findbugs.annotations.NonNull; +import java.io.IOException; + /** * Provides utility methods to extract and filter stack trace information. */ diff --git a/main/src/main/java/mockit/internal/util/TestMethod.java b/main/src/main/java/mockit/internal/util/TestMethod.java index 133e5de0d..9781aca2f 100644 --- a/main/src/main/java/mockit/internal/util/TestMethod.java +++ b/main/src/main/java/mockit/internal/util/TestMethod.java @@ -4,6 +4,9 @@ */ package mockit.internal.util; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.lang.reflect.Type; @@ -12,9 +15,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class TestMethod { @NonNull public final Class testClass; diff --git a/main/src/main/java/mockit/internal/util/TypeConversion.java b/main/src/main/java/mockit/internal/util/TypeConversion.java index 6c46a5569..23f64b741 100644 --- a/main/src/main/java/mockit/internal/util/TypeConversion.java +++ b/main/src/main/java/mockit/internal/util/TypeConversion.java @@ -6,14 +6,14 @@ import static mockit.internal.util.AutoBoxing.isWrapperOfPrimitiveType; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.math.BigDecimal; import java.math.BigInteger; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - public final class TypeConversion { private TypeConversion() { } diff --git a/main/src/main/java/mockit/internal/util/TypeConversionBytecode.java b/main/src/main/java/mockit/internal/util/TypeConversionBytecode.java index ac394403b..207f6570a 100644 --- a/main/src/main/java/mockit/internal/util/TypeConversionBytecode.java +++ b/main/src/main/java/mockit/internal/util/TypeConversionBytecode.java @@ -10,6 +10,8 @@ import static mockit.asm.jvmConstants.Opcodes.INVOKEVIRTUAL; import static mockit.asm.jvmConstants.Opcodes.POP; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.methods.MethodVisitor; import mockit.asm.types.JavaType; import mockit.asm.types.PrimitiveType; @@ -17,8 +19,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class TypeConversionBytecode { private TypeConversionBytecode() { } diff --git a/main/src/main/java/mockit/internal/util/TypeDescriptor.java b/main/src/main/java/mockit/internal/util/TypeDescriptor.java index ad9b0472c..f1186ac92 100644 --- a/main/src/main/java/mockit/internal/util/TypeDescriptor.java +++ b/main/src/main/java/mockit/internal/util/TypeDescriptor.java @@ -4,12 +4,12 @@ */ package mockit.internal.util; +import edu.umd.cs.findbugs.annotations.NonNull; + import mockit.asm.types.ArrayType; import mockit.asm.types.JavaType; import mockit.asm.types.PrimitiveType; -import edu.umd.cs.findbugs.annotations.NonNull; - public final class TypeDescriptor { private static final Class[] NO_PARAMETERS = {}; diff --git a/main/src/main/java/mockit/internal/util/Utilities.java b/main/src/main/java/mockit/internal/util/Utilities.java index 309bd4c5d..bd996444c 100644 --- a/main/src/main/java/mockit/internal/util/Utilities.java +++ b/main/src/main/java/mockit/internal/util/Utilities.java @@ -4,6 +4,9 @@ */ package mockit.internal.util; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.lang.annotation.Annotation; import java.lang.reflect.AccessibleObject; import java.lang.reflect.GenericArrayType; @@ -17,9 +20,6 @@ import java.security.CodeSource; import java.util.List; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Miscellaneous utility constants and methods. */ diff --git a/main/src/test/java/mockit/FakingBaseTypesTest.java b/main/src/test/java/mockit/FakingBaseTypesTest.java index aaf2783b4..981d6f970 100644 --- a/main/src/test/java/mockit/FakingBaseTypesTest.java +++ b/main/src/test/java/mockit/FakingBaseTypesTest.java @@ -3,6 +3,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.StringReader; import java.nio.CharBuffer; @@ -14,8 +16,6 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestMethodOrder; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * The Class FakingBaseTypesTest. */ diff --git a/main/src/test/java/mockit/MockedAnnotationsTest.java b/main/src/test/java/mockit/MockedAnnotationsTest.java index 591bc7080..0d98755e7 100644 --- a/main/src/test/java/mockit/MockedAnnotationsTest.java +++ b/main/src/test/java/mockit/MockedAnnotationsTest.java @@ -6,6 +6,8 @@ import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.lang.annotation.Annotation; import javax.annotation.Resource; @@ -13,8 +15,6 @@ import org.checkerframework.checker.index.qual.NonNegative; import org.junit.jupiter.api.Test; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * The Class MockedAnnotationsTest. */ diff --git a/main/src/test/java/mockit/MockedClassWithSuperClassTest.java b/main/src/test/java/mockit/MockedClassWithSuperClassTest.java index 8d39b672b..fbb684c83 100644 --- a/main/src/test/java/mockit/MockedClassWithSuperClassTest.java +++ b/main/src/test/java/mockit/MockedClassWithSuperClassTest.java @@ -3,12 +3,12 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertSame; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.io.Writer; import org.junit.jupiter.api.Test; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * The Class MockedClassWithSuperClassTest. */ diff --git a/main/src/test/java/mockit/NaturalOrderingTest.java b/main/src/test/java/mockit/NaturalOrderingTest.java index 39d95b343..7e04b4267 100644 --- a/main/src/test/java/mockit/NaturalOrderingTest.java +++ b/main/src/test/java/mockit/NaturalOrderingTest.java @@ -3,12 +3,12 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.Date; import org.junit.jupiter.api.Test; -import edu.umd.cs.findbugs.annotations.NonNull; - /** * The Class NaturalOrderingTest. */ diff --git a/samples/LoginService/src/main/java/jmockit/loginExample/domain/userLogin/LoginService.java b/samples/LoginService/src/main/java/jmockit/loginExample/domain/userLogin/LoginService.java index 0abcf0ec9..966185db4 100644 --- a/samples/LoginService/src/main/java/jmockit/loginExample/domain/userLogin/LoginService.java +++ b/samples/LoginService/src/main/java/jmockit/loginExample/domain/userLogin/LoginService.java @@ -1,9 +1,10 @@ package jmockit.loginExample.domain.userLogin; -import org.checkerframework.checker.index.qual.NonNegative; - import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; + +import org.checkerframework.checker.index.qual.NonNegative; + import jmockit.loginExample.domain.userAccount.UserAccount; public final class LoginService { diff --git a/samples/petclinic/src/main/java/petclinic/owners/Owner.java b/samples/petclinic/src/main/java/petclinic/owners/Owner.java index 1767ed25c..b4e38f779 100644 --- a/samples/petclinic/src/main/java/petclinic/owners/Owner.java +++ b/samples/petclinic/src/main/java/petclinic/owners/Owner.java @@ -1,5 +1,8 @@ package petclinic.owners; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.ArrayList; import java.util.List; @@ -9,8 +12,6 @@ import javax.persistence.OrderBy; import javax.validation.constraints.NotNull; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; import petclinic.pets.Pet; import petclinic.util.Person; diff --git a/samples/petclinic/src/main/java/petclinic/owners/OwnerMaintenance.java b/samples/petclinic/src/main/java/petclinic/owners/OwnerMaintenance.java index adb8824ea..50c246d33 100644 --- a/samples/petclinic/src/main/java/petclinic/owners/OwnerMaintenance.java +++ b/samples/petclinic/src/main/java/petclinic/owners/OwnerMaintenance.java @@ -1,12 +1,13 @@ package petclinic.owners; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import javax.inject.Inject; import javax.transaction.Transactional; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; import petclinic.util.Database; /** diff --git a/samples/petclinic/src/main/java/petclinic/owners/OwnerScreen.java b/samples/petclinic/src/main/java/petclinic/owners/OwnerScreen.java index 4ceb6eb6d..1e7cdbabe 100644 --- a/samples/petclinic/src/main/java/petclinic/owners/OwnerScreen.java +++ b/samples/petclinic/src/main/java/petclinic/owners/OwnerScreen.java @@ -1,5 +1,7 @@ package petclinic.owners; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import javax.faces.view.ViewScoped; @@ -7,8 +9,6 @@ import javax.inject.Named; import javax.transaction.Transactional; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * An application service class that handles {@link Owner}-related operations from the owner screen. */ diff --git a/samples/petclinic/src/main/java/petclinic/pets/PetMaintenance.java b/samples/petclinic/src/main/java/petclinic/pets/PetMaintenance.java index dc3301d4f..3f214a338 100644 --- a/samples/petclinic/src/main/java/petclinic/pets/PetMaintenance.java +++ b/samples/petclinic/src/main/java/petclinic/pets/PetMaintenance.java @@ -1,13 +1,14 @@ package petclinic.pets; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import javax.inject.Inject; import javax.transaction.Transactional; import javax.validation.ValidationException; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; import petclinic.owners.Owner; import petclinic.util.Database; diff --git a/samples/petclinic/src/main/java/petclinic/pets/PetScreen.java b/samples/petclinic/src/main/java/petclinic/pets/PetScreen.java index 09a195570..ae3e94ae5 100644 --- a/samples/petclinic/src/main/java/petclinic/pets/PetScreen.java +++ b/samples/petclinic/src/main/java/petclinic/pets/PetScreen.java @@ -1,5 +1,8 @@ package petclinic.pets; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import javax.faces.view.ViewScoped; @@ -7,8 +10,6 @@ import javax.inject.Named; import javax.transaction.Transactional; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; import petclinic.owners.Owner; import petclinic.owners.OwnerMaintenance; diff --git a/samples/petclinic/src/main/java/petclinic/util/Database.java b/samples/petclinic/src/main/java/petclinic/util/Database.java index 424659801..df2ee7e54 100644 --- a/samples/petclinic/src/main/java/petclinic/util/Database.java +++ b/samples/petclinic/src/main/java/petclinic/util/Database.java @@ -1,5 +1,8 @@ package petclinic.util; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import javax.persistence.EntityManager; @@ -9,9 +12,6 @@ import org.checkerframework.checker.index.qual.NonNegative; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * Provides access to the application database, allowing transient instances of entity classes to be persisted, and * persistent instances to be recovered or removed from the database. diff --git a/samples/petclinic/src/main/java/petclinic/vets/VetMaintenance.java b/samples/petclinic/src/main/java/petclinic/vets/VetMaintenance.java index 524c41cc7..981412306 100644 --- a/samples/petclinic/src/main/java/petclinic/vets/VetMaintenance.java +++ b/samples/petclinic/src/main/java/petclinic/vets/VetMaintenance.java @@ -1,11 +1,12 @@ package petclinic.vets; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.List; import javax.inject.Inject; import javax.transaction.Transactional; -import edu.umd.cs.findbugs.annotations.NonNull; import petclinic.util.Database; /** diff --git a/samples/petclinic/src/main/java/petclinic/vets/VetScreen.java b/samples/petclinic/src/main/java/petclinic/vets/VetScreen.java index a012d7812..476b9c297 100644 --- a/samples/petclinic/src/main/java/petclinic/vets/VetScreen.java +++ b/samples/petclinic/src/main/java/petclinic/vets/VetScreen.java @@ -1,5 +1,7 @@ package petclinic.vets; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import javax.faces.view.ViewScoped; @@ -7,8 +9,6 @@ import javax.inject.Named; import javax.transaction.Transactional; -import edu.umd.cs.findbugs.annotations.Nullable; - /** * An application service class that handles {@link Vet}-related operations from the vet screen. */ diff --git a/samples/petclinic/src/main/java/petclinic/visits/VisitMaintenance.java b/samples/petclinic/src/main/java/petclinic/visits/VisitMaintenance.java index f59964bf5..4b1f6cbd4 100644 --- a/samples/petclinic/src/main/java/petclinic/visits/VisitMaintenance.java +++ b/samples/petclinic/src/main/java/petclinic/visits/VisitMaintenance.java @@ -1,12 +1,13 @@ package petclinic.visits; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import javax.inject.Inject; import javax.transaction.Transactional; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; import petclinic.pets.Pet; import petclinic.util.Database; diff --git a/samples/petclinic/src/main/java/petclinic/visits/VisitScreen.java b/samples/petclinic/src/main/java/petclinic/visits/VisitScreen.java index 3d01199bc..a8b6b6ee7 100644 --- a/samples/petclinic/src/main/java/petclinic/visits/VisitScreen.java +++ b/samples/petclinic/src/main/java/petclinic/visits/VisitScreen.java @@ -1,5 +1,7 @@ package petclinic.visits; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.List; import javax.faces.view.ViewScoped; @@ -7,7 +9,6 @@ import javax.inject.Named; import javax.transaction.Transactional; -import edu.umd.cs.findbugs.annotations.Nullable; import petclinic.pets.Pet; import petclinic.pets.PetMaintenance; diff --git a/samples/petclinic/src/test/java/petclinic/owners/OwnerData.java b/samples/petclinic/src/test/java/petclinic/owners/OwnerData.java index f0392aa48..07bc14144 100644 --- a/samples/petclinic/src/test/java/petclinic/owners/OwnerData.java +++ b/samples/petclinic/src/test/java/petclinic/owners/OwnerData.java @@ -1,6 +1,7 @@ package petclinic.owners; import edu.umd.cs.findbugs.annotations.NonNull; + import petclinic.util.TestDatabase; /** diff --git a/samples/petclinic/src/test/java/petclinic/pets/PetData.java b/samples/petclinic/src/test/java/petclinic/pets/PetData.java index f53076bb6..d45bf7915 100644 --- a/samples/petclinic/src/test/java/petclinic/pets/PetData.java +++ b/samples/petclinic/src/test/java/petclinic/pets/PetData.java @@ -1,11 +1,12 @@ package petclinic.pets; +import edu.umd.cs.findbugs.annotations.NonNull; +import edu.umd.cs.findbugs.annotations.Nullable; + import java.util.Date; import javax.inject.Inject; -import edu.umd.cs.findbugs.annotations.NonNull; -import edu.umd.cs.findbugs.annotations.Nullable; import petclinic.owners.Owner; import petclinic.owners.OwnerData; import petclinic.util.TestDatabase; diff --git a/samples/petclinic/src/test/java/petclinic/vets/VetData.java b/samples/petclinic/src/test/java/petclinic/vets/VetData.java index f5c68dc2b..29f5b099c 100644 --- a/samples/petclinic/src/test/java/petclinic/vets/VetData.java +++ b/samples/petclinic/src/test/java/petclinic/vets/VetData.java @@ -1,6 +1,7 @@ package petclinic.vets; import edu.umd.cs.findbugs.annotations.NonNull; + import petclinic.util.TestDatabase; /** diff --git a/samples/petclinic/src/test/java/petclinic/visits/VisitData.java b/samples/petclinic/src/test/java/petclinic/visits/VisitData.java index b4eb967d7..a745b4699 100644 --- a/samples/petclinic/src/test/java/petclinic/visits/VisitData.java +++ b/samples/petclinic/src/test/java/petclinic/visits/VisitData.java @@ -1,10 +1,11 @@ package petclinic.visits; +import edu.umd.cs.findbugs.annotations.NonNull; + import java.util.Date; import javax.inject.Inject; -import edu.umd.cs.findbugs.annotations.NonNull; import petclinic.pets.Pet; import petclinic.pets.PetData; import petclinic.util.TestDatabase;