From 59822573ee5020818b0f463927b26e5a39be3a78 Mon Sep 17 00:00:00 2001 From: "R. Kaleta" Date: Tue, 11 Jun 2024 22:32:20 +0200 Subject: [PATCH] Reorganize test comments --- .../java/dicontainer/DiContainerTest.java | 48 +++++++++++++++++++ .../dictionary/DiDictionaryTest.java | 39 +++++++++++++++ .../resolver/ConstructorComparatorTest.java | 6 +++ .../dicontainer/resolver/DiResolverTest.java | 41 ++++++++++++++++ 4 files changed, 134 insertions(+) diff --git a/src/test/java/dicontainer/DiContainerTest.java b/src/test/java/dicontainer/DiContainerTest.java index c6e1512..8028e7c 100644 --- a/src/test/java/dicontainer/DiContainerTest.java +++ b/src/test/java/dicontainer/DiContainerTest.java @@ -41,9 +41,11 @@ public void registerType_WhenSingleClass_ThenDifferentInstances() { // given testObject.registerType(ClassConstructorDefault.class); + // when ClassConstructorDefault result1 = testObject.resolve(ClassConstructorDefault.class); ClassConstructorDefault result2 = testObject.resolve(ClassConstructorDefault.class); + // then Assertions.assertThat(result1).isNotNull(); Assertions.assertThat(result2).isNotNull().isNotSameAs(result1); @@ -54,9 +56,11 @@ public void registerType_WhenSingleClassAsSingleton_ThenSameInstance() { // given testObject.registerType(ClassConstructorDefault.class, ConstructionPolicy.SINGLETON); + // when ClassConstructorDefault result1 = testObject.resolve(ClassConstructorDefault.class); ClassConstructorDefault result2 = testObject.resolve(ClassConstructorDefault.class); + // then Assertions.assertThat(result1).isNotNull(); Assertions.assertThat(result2).isNotNull().isSameAs(result1); @@ -67,18 +71,22 @@ public void registerType_WhenSingleClassChangesSingleton_ThenChangesInstances() { // given 1 testObject.registerType(ClassConstructorDefault.class, ConstructionPolicy.SINGLETON); + // when 1 ClassConstructorDefault result11 = testObject.resolve(ClassConstructorDefault.class); ClassConstructorDefault result12 = testObject.resolve(ClassConstructorDefault.class); + // then 1 Assertions.assertThat(result11).isNotNull(); Assertions.assertThat(result12).isNotNull().isSameAs(result11); // given 2 testObject.registerType(ClassConstructorDefault.class, ConstructionPolicy.CONSTRUCT); + // when 2 ClassConstructorDefault result21 = testObject.resolve(ClassConstructorDefault.class); ClassConstructorDefault result22 = testObject.resolve(ClassConstructorDefault.class); + // then 2 Assertions.assertThat(result21).isNotNull(); Assertions.assertThat(result22).isNotNull().isNotSameAs(result21); @@ -106,9 +114,11 @@ public void registerType_WhenInheritanceFromInterface_ThenDifferentInstances() { // given testObject.registerType(InterfaceBasic.class, ClassConstructorDefault.class); + // when InterfaceBasic result1 = testObject.resolve(InterfaceBasic.class); InterfaceBasic result2 = testObject.resolve(InterfaceBasic.class); + // then Assertions.assertThat(result1).isNotNull().isInstanceOf(ClassConstructorDefault.class); Assertions.assertThat(result2) @@ -123,9 +133,11 @@ public void registerType_WhenInheritanceFromInterfaceAsSingleton_ThenSameInstanc // given testObject.registerType(InterfaceBasic.class, ClassConstructorDefault.class, ConstructionPolicy.SINGLETON); + // when InterfaceBasic result1 = testObject.resolve(InterfaceBasic.class); InterfaceBasic result2 = testObject.resolve(InterfaceBasic.class); + // then Assertions.assertThat(result1).isNotNull().isInstanceOf(ClassConstructorDefault.class); Assertions.assertThat(result2) @@ -140,9 +152,11 @@ public void registerType_WhenInheritanceFromInterfaceChangesSingleton_ThenChange // given 1 testObject.registerType(InterfaceBasic.class, ClassConstructorDefault.class, ConstructionPolicy.SINGLETON); + // when 1 InterfaceBasic result11 = testObject.resolve(InterfaceBasic.class); InterfaceBasic result12 = testObject.resolve(InterfaceBasic.class); + // then 1 Assertions.assertThat(result11).isNotNull().isInstanceOf(ClassConstructorDefault.class); Assertions.assertThat(result12) @@ -153,9 +167,11 @@ public void registerType_WhenInheritanceFromInterfaceChangesSingleton_ThenChange // given 2 testObject.registerType(InterfaceBasic.class, ClassConstructorDefault.class, ConstructionPolicy.CONSTRUCT); + // when 2 InterfaceBasic result21 = testObject.resolve(InterfaceBasic.class); InterfaceBasic result22 = testObject.resolve(InterfaceBasic.class); + // then 2 Assertions.assertThat(result21).isNotNull().isInstanceOf(ClassConstructorDefault.class); Assertions.assertThat(result22) @@ -169,16 +185,20 @@ public void registerType_WhenInheritanceFromInterfaceChangesClass_ThenInstanceIs { // given 1 testObject.registerType(InterfaceBasic.class, ClassConstructorDefault.class); + // when 1 InterfaceBasic result1 = testObject.resolve(InterfaceBasic.class); + // then 1 Assertions.assertThat(result1).isNotNull().isInstanceOf(ClassConstructorDefault.class); // given 2 testObject.registerType(InterfaceBasic.class, ClassConstructorDefaultAndParameterized.class); + // when 2 InterfaceBasic result3 = testObject.resolve(InterfaceBasic.class); + // then 2 Assertions.assertThat(result3) .isNotNull() @@ -190,8 +210,10 @@ public void registerType_WhenInheritanceFromAbstractClass_ThenInstanceIsDerived( { // given testObject.registerType(ClassBasicAbstract.class, ClassBasicInheritsFromAbstract.class); + // when ClassBasicAbstract result = testObject.resolve(ClassBasicAbstract.class); + // then Assertions.assertThat(result) .isNotNull() @@ -204,9 +226,11 @@ public void registerType_WhenInheritanceFromConcreteClass_ThenInstanceIsDerived( // given testObject.registerType(ClassConstructorParameterized.class, ClassConstructorSuperParameterized.class); + // when ClassConstructorParameterized result = testObject.resolve(ClassConstructorParameterized.class); + // then Assertions.assertThat(result) .isNotNull() @@ -219,8 +243,10 @@ public void registerType_WhenTwoStepsOfHierarchy_ThenInstanceIsDerived() // given testObject.registerType(InterfaceBasic.class, ClassBasicAbstract.class) .registerType(ClassBasicAbstract.class, ClassBasicInheritsFromAbstract.class); + // when InterfaceBasic result = testObject.resolve(InterfaceBasic.class); + // then Assertions.assertThat(result) .isNotNull() @@ -237,8 +263,10 @@ public void registerInstance_WhenInterface_ThenRegisteredInstance() ClassConstructorDefault instance = new ClassConstructorDefault(); testObject.registerInstance(InterfaceBasic.class, instance); + // when InterfaceBasic result = testObject.resolve(InterfaceBasic.class); + // then Assertions.assertThat(result) .isNotNull() @@ -253,8 +281,10 @@ public void registerInstance_WhenAbstractClass_ThenRegisteredInstance() ClassBasicInheritsFromAbstract instance = new ClassBasicInheritsFromAbstract(); testObject.registerInstance(ClassBasicAbstract.class, instance); + // when ClassBasicAbstract result = testObject.resolve(ClassBasicAbstract.class); + // then Assertions.assertThat(result) .isNotNull() @@ -270,9 +300,11 @@ public void registerInstance_WhenSameConcreteClass_ThenRegisteredInstance() new ClassConstructorDefaultAndParameterized(); testObject.registerInstance(ClassConstructorDefaultAndParameterized.class, instance); + // when ClassConstructorDefaultAndParameterized result = testObject.resolve(ClassConstructorDefaultAndParameterized.class); + // then Assertions.assertThat(result).isNotNull().isSameAs(instance); Assertions.assertThat(result.getText()).isEqualTo(instance.getText()); @@ -285,9 +317,11 @@ public void registerInstance_WhenDerivedConcreteClass_ThenRegisteredInstance() ClassConstructorSuperParameterized instance = new ClassConstructorSuperParameterized(); testObject.registerInstance(ClassConstructorParameterized.class, instance); + // when ClassConstructorParameterized result = testObject.resolve(ClassConstructorParameterized.class); + // then Assertions.assertThat(result) .isNotNull() @@ -350,8 +384,10 @@ public void resolve_WhenDependencySetterOnly_ThenInstanceIsResolved() // given testObject.registerType(InterfaceSetter.class, ClassSetterSingle.class) .registerType(InterfaceBasic.class, ClassConstructorDefault.class); + // when InterfaceSetter result = testObject.resolve(InterfaceSetter.class); + // then Assertions.assertThat(result).isNotNull().isInstanceOf(ClassSetterSingle.class); Assertions.assertThat(result.getBasicObject()).isNotNull(); @@ -363,8 +399,10 @@ public void resolve_WhenDependencySetterAndConstructor_ThenInstanceIsResolved() // given testObject.registerType(InterfaceSetter.class, ClassSetterConstructor.class) .registerType(InterfaceBasic.class, ClassConstructorDefault.class); + // when InterfaceSetter result = testObject.resolve(InterfaceSetter.class); + // then Assertions.assertThat(result).isNotNull().isInstanceOf(ClassSetterConstructor.class); Assertions.assertThat(result.getBasicObject()).isNotNull(); @@ -376,6 +414,7 @@ public void resolve_WhenDoubleDependencySetter_ThenIncorrectDependencySetterExce // given testObject.registerType(InterfaceSetterMultipleParameters.class, ClassSetterMultipleParameters.class); + // then Assertions.assertThatThrownBy( () -> testObject.resolve(InterfaceSetterMultipleParameters.class)) @@ -392,8 +431,10 @@ public void resolve_WhenMultipleDependencySetters_ThenInstanceIsResolved() .registerType(InterfaceSetterMultiple.class, ClassSetterMultiple.class) .registerType(InterfaceBasic.class, ClassConstructorDefault.class) .registerType(InterfaceBasicStringGetter.class, ClassBasicStringGetter.class); + // when InterfaceSetterMultiple result = testObject.resolve(InterfaceSetterMultiple.class); + // then Assertions.assertThat(result).isNotNull().isInstanceOf(ClassSetterMultiple.class); Assertions.assertThat(result.getBasicObject()).isNotNull(); @@ -411,8 +452,10 @@ public void buildUp_WhenDependencySetterOnly_ThenInstanceIsBuiltUp() testObject.registerType(InterfaceBasic.class, ClassConstructorDefault.class); InterfaceSetter instance = new ClassSetterSingle(); + // when InterfaceSetter result = testObject.buildUp(instance); + // then Assertions.assertThat(result).isNotNull().isSameAs(instance); Assertions.assertThat(instance).isNotNull(); @@ -425,6 +468,7 @@ public void buildUp_WhenDependencySetterHasMultipleParameters_ThenIncorrectDepen { // given InterfaceSetterMultipleParameters instance = new ClassSetterMultipleParameters(); + // then Assertions.assertThatThrownBy(() -> testObject.buildUp(instance)) .isInstanceOf(IncorrectDependencySetterException.class); @@ -440,8 +484,10 @@ public void buildUp_WhenMultipleDependencySetters_ThenInstanceIsBuiltUp() testObject.registerType(InterfaceBasic.class, ClassConstructorDefault.class) .registerType(InterfaceBasicStringGetter.class, ClassBasicStringGetter.class) .registerInstance(String.class, string); + // when InterfaceSetterMultiple result = testObject.buildUp(instance); + // then Assertions.assertThat(result).isNotNull().isSameAs(instance); Assertions.assertThat(instance).isNotNull(); @@ -472,8 +518,10 @@ public void buildUp_WhenComplexDependency_ThenInstanceIsBuiltUp() testObject.resolve(InterfaceBasicStringGetter.class); InterfaceBasicComplexDependency instance = new ClassBasicComplexDependency(diamond1, withString); + // when InterfaceBasicComplexDependency result = testObject.buildUp(instance); + // then Assertions.assertThat(result).isNotNull().isSameAs(instance); Assertions.assertThat(instance).isNotNull(); diff --git a/src/test/java/dicontainer/dictionary/DiDictionaryTest.java b/src/test/java/dicontainer/dictionary/DiDictionaryTest.java index 90f2551..d2920ed 100644 --- a/src/test/java/dicontainer/dictionary/DiDictionaryTest.java +++ b/src/test/java/dicontainer/dictionary/DiDictionaryTest.java @@ -44,10 +44,12 @@ public void addType_findType_WhenSpecifyTypeWithSubtypeAndPolicy_ThenSubtypeInse // given Class type = ClassBasicAbstract.class; Class subtype = ClassBasicInheritsFromAbstract.class; + // when testObject.addType(type, subtype, ConstructionPolicy.SINGLETON); Subtype result = testObject.findType(type); + // then Assertions.assertThat(result.subtype).isEqualTo(subtype); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.SINGLETON); @@ -58,10 +60,12 @@ public void addType_findType_WhenSpecifyTypeAndPolicy_ThenThisTypeInserted() { // given Class type = ClassBasicInheritsFromAbstract.class; + // when testObject.addType(type, ConstructionPolicy.SINGLETON); Subtype result = testObject.findType(type); + // then Assertions.assertThat(result.subtype).isEqualTo(type); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.SINGLETON); @@ -72,10 +76,12 @@ public void addType_findType_WhenTypeHasSelfRegisterAnnotation_ThenThisTypeInser { // given Class type = ClassRegisterSelf.class; + // when testObject.addType(type); Subtype result = testObject.findType(type); + // then Assertions.assertThat(result.subtype).isEqualTo(type); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.defaultPolicy); @@ -86,10 +92,12 @@ public void addType_findType_WhenTypeHasRegisterAnnotation_ThenSubtypeInserted() { // given Class type = ClassRegisterConcrete.class; + // when testObject.addType(type); Subtype result = testObject.findType(type); + // then Assertions.assertThat(result.subtype).isEqualTo(ClassRegisterDerivedFromRegister.class); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.defaultPolicy); @@ -165,6 +173,7 @@ public void addType_WhenRegisteredInstance_ThenRegistrationException() ClassBasicStringGetter instance = new ClassBasicStringGetter(string); testObject.addInstance(type, instance); + // then Assertions.assertThatThrownBy(() -> testObject.addType(type)) .isInstanceOf(RegistrationException.class); @@ -186,11 +195,13 @@ public void addInstance_findInstance_WhenInstancePresent_ThenInstance() // given String string = "String"; ClassBasicStringGetter instance = new ClassBasicStringGetter(string); + // when testObject.addInstance(ClassBasicStringGetter.class, instance); Instance result = testObject.findInstance(ClassBasicStringGetter.class); + // then Assertions.assertThat(result.exists()).isTrue(); Assertions.assertThat(result.extract()).isSameAs(instance); @@ -209,6 +220,7 @@ public void addInstance_WhenRegisteredType_ThenRegistrationException() ClassBasicStringGetter instance = new ClassBasicStringGetter(string); testObject.addType(type); + // then Assertions.assertThatThrownBy(() -> testObject.addInstance(type, instance)) .isInstanceOf(RegistrationException.class); @@ -237,6 +249,7 @@ public void findType_WhenPrimitive_ThenFoundMapping() { // when Subtype result = testObject.findType(double.class); + // then Assertions.assertThat(result.subtype).isEqualTo(double.class); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.defaultPolicy); @@ -250,8 +263,10 @@ public void findType_WhenAbstractClass_ThenFoundMapping() ConstructionPolicy.defaultPolicy); testObject.addType(ClassBasicAbstract.class, ClassBasicInheritsFromAbstract.class, ConstructionPolicy.defaultPolicy); + // when Subtype result = testObject.findType(InterfaceBasic.class); + // then Assertions.assertThat(result.subtype).isEqualTo(ClassBasicInheritsFromAbstract.class); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.defaultPolicy); @@ -262,8 +277,10 @@ public void findType_WhenConcreteClassNotRegistered_ThenFoundNewMapping() { // given Class type = ClassBasicInheritsFromAbstract.class; + // when Subtype result = testObject.findType(type); + // then Assertions.assertThat(result.subtype).isEqualTo(type); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.defaultPolicy); @@ -275,6 +292,7 @@ public void findType_WhenAnnotatedClass_ThenMappingFromAnnotation() // when Subtype result = testObject.findType(ClassRegisterAbstract.class); + // then Assertions.assertThat(result.subtype).isEqualTo(ClassRegisterDerivedFromRegister.class); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.defaultPolicy); @@ -288,6 +306,7 @@ public void findType_WhenDifferentPolicy_ThenMixingPoliciesException() ConstructionPolicy.CONSTRUCT); testObject.addType(ClassBasicAbstract.class, ClassBasicInheritsFromAbstract.class, ConstructionPolicy.SINGLETON); + // then Assertions.assertThatThrownBy(() -> testObject.findType(InterfaceBasic.class)) .isInstanceOf(MixingPoliciesException.class); @@ -298,6 +317,7 @@ public void findType_WhenSelfRegisterClass_ThenMapping() { // when Subtype result = testObject.findType(ClassRegisterSelf.class); + // then Assertions.assertThat(result.subtype).isEqualTo(ClassRegisterSelf.class); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.defaultPolicy); @@ -310,8 +330,10 @@ public void findType_whenRegisteredInstance_ThenMappingToThisType() Class type = ClassBasicInheritsFromAbstract.class; testObject.addInstance(type, new ClassBasicInheritsFromAbstract()); + // when Subtype result = testObject.findType(type); + // then Assertions.assertThat(result.subtype).isEqualTo(type); Assertions.assertThat(result.policy).isEqualTo(ConstructionPolicy.SINGLETON); @@ -326,6 +348,7 @@ public void findInstance_WhenInstanceAbsent_ThenMappingNone() // when Instance result = testObject.findInstance(ClassBasicStringGetter.class); + // then Assertions.assertThat(result.exists()).isFalse(); } @@ -338,8 +361,10 @@ public void contains_WhenAddedInstance_ThenTrue() { // given testObject.addInstance(ClassBasicStringGetter.class, new ClassBasicStringGetter("String")); + // when boolean result = testObject.contains(ClassBasicStringGetter.class); + // then Assertions.assertThat(result).isTrue(); } @@ -349,6 +374,7 @@ public void contains_WhenAbstractTypeIsAbsent_ThenFalse() { // when boolean result = testObject.contains(InterfaceBasic.class); + // then Assertions.assertThat(result).isFalse(); } @@ -358,6 +384,7 @@ public void contains_WhenConcreteTypeIsAbsent_ThenFalse() { // when boolean result = testObject.contains(ClassBasicInheritsFromAbstract.class); + // then Assertions.assertThat(result).isFalse(); } @@ -367,6 +394,7 @@ public void contains_WhenAnnotatedTypeIsAbsent_ThenTrue() { // when boolean result = testObject.contains(ClassRegisterConcrete.class); + // then Assertions.assertThat(result).isTrue(); } @@ -378,8 +406,10 @@ public void contains_WhenAnnotatedTypeIsPresent_ThenTrue() Class type = ClassRegisterConcrete.class; testObject.addType(type); + // when boolean result = testObject.contains(type); + // then Assertions.assertThat(result).isTrue(); } @@ -391,8 +421,10 @@ public void contains_WhenInsertedTypeIsPresent_ThenTrue() Class type = InterfaceBasic.class; testObject.addType(type, ClassBasicAbstract.class); + // when boolean result = testObject.contains(type); + // then Assertions.assertThat(result).isTrue(); } @@ -402,6 +434,7 @@ public void contains_WhenAnnotatedTypeIncorrect_ThenFalse() { // when boolean result = testObject.contains(ClassRegisterSelfAbstractIncorrect.class); + // then Assertions.assertThat(result).isFalse(); } @@ -417,10 +450,12 @@ public void addSingleton_findInstance_WhenRegisteredTypeAsSingleton_ThenSingleto testObject.addType(ClassBasicAbstract.class, ClassBasicInheritsFromAbstract.class, ConstructionPolicy.SINGLETON); + // when testObject.addSingleton(ClassBasicAbstract.class, singleton); Instance result = testObject.findInstance(ClassBasicAbstract.class); + // then Assertions.assertThat(result.exists()).isTrue(); Assertions.assertThat(result.extract()).isSameAs(singleton); @@ -434,10 +469,12 @@ public void addSingleton_findInstance_WhenRegisteredTypeAsNotSingleton_ThenNoIns testObject.addType(ClassBasicAbstract.class, ClassBasicInheritsFromAbstract.class, ConstructionPolicy.CONSTRUCT); + // when testObject.addSingleton(ClassBasicAbstract.class, singleton); Instance result = testObject.findInstance(ClassBasicAbstract.class); + // then Assertions.assertThat(result.exists()).isFalse(); } @@ -447,10 +484,12 @@ public void addSingleton_findInstance_WhenNotRegisteredType_ThenNoInstance() { // given ClassBasicInheritsFromAbstract singleton = new ClassBasicInheritsFromAbstract(); + // when testObject.addSingleton(ClassBasicAbstract.class, singleton); Instance result = testObject.findInstance(ClassBasicAbstract.class); + // then Assertions.assertThat(result.exists()).isFalse(); } diff --git a/src/test/java/dicontainer/resolver/ConstructorComparatorTest.java b/src/test/java/dicontainer/resolver/ConstructorComparatorTest.java index 7fb2303..f645a7a 100644 --- a/src/test/java/dicontainer/resolver/ConstructorComparatorTest.java +++ b/src/test/java/dicontainer/resolver/ConstructorComparatorTest.java @@ -32,8 +32,10 @@ public void compare_WhenSorting_ThenFirstDependencyAndNextByParametersDescending { // given Constructor[] constructors = ClassComparatorConstructor.class.getConstructors(); + // when Arrays.sort(constructors, testObject); + // then Assertions.assertThat(constructors[0].isAnnotationPresent(Dependency.class)).isTrue(); Assertions.assertThat( @@ -47,8 +49,10 @@ public void compare_WhenDependencyAnnotated_ThenLess() // given Constructor[] constructors = ClassComparatorConstructor.class.getConstructors(); Arrays.sort(constructors, Comparator.comparingInt(Constructor::getParameterCount)); + // when int result = testObject.compare(constructors[3], constructors[4]); + // then Assertions.assertThat(result).isEqualTo(-1); } @@ -59,8 +63,10 @@ public void compare_WhenNotDependencyAnnotated_ThenByParametersCountDescending() // given Constructor[] constructors = ClassComparatorConstructor.class.getConstructors(); Arrays.sort(constructors, Comparator.comparingInt(Constructor::getParameterCount)); + // when int result = testObject.compare(constructors[2], constructors[5]); + // then Assertions.assertThat(result).isEqualTo(1); } diff --git a/src/test/java/dicontainer/resolver/DiResolverTest.java b/src/test/java/dicontainer/resolver/DiResolverTest.java index 08d1697..7db14a1 100644 --- a/src/test/java/dicontainer/resolver/DiResolverTest.java +++ b/src/test/java/dicontainer/resolver/DiResolverTest.java @@ -42,6 +42,7 @@ public void construct_WhenClassHasDefaultConstructorOnly_ThenInstanceIsResolved( { // when ClassConstructorDefault result = testObject.construct(ClassConstructorDefault.class); + // then Assertions.assertThat(result).isNotNull(); } @@ -52,6 +53,7 @@ public void construct_WhenClassInheritsFromConcreteClass_ThenInstanceIsResolved( // when ClassConstructorSuperParameterized result = testObject.construct(ClassConstructorSuperParameterized.class); + // then Assertions.assertThat(result).isNotNull(); } @@ -62,6 +64,7 @@ public void construct_WhenClassInheritsFromAbstractClass_ThenInstanceIsResolved( // when ClassBasicInheritsFromAbstract result = testObject.construct(ClassBasicInheritsFromAbstract.class); + // then Assertions.assertThat(result).isNotNull(); } @@ -81,9 +84,11 @@ public void construct_WhenClassHasParameterConstructorWithRegisteredPrimitivePar int number = 10; dictionary.addInstance(int.class, number); + // when ClassConstructorParameterized result = testObject.construct(ClassConstructorParameterized.class); + // then Assertions.assertThat(result).isNotNull(); Assertions.assertThat(result.getNumber()).isEqualTo(number); @@ -96,6 +101,7 @@ public void construct_WhenClassHasPrimitiveParameterConstructorButRegisteredRefe Integer number = 10; dictionary.addInstance(Integer.class, number); + // then Assertions.assertThatThrownBy( () -> testObject.construct(ClassConstructorParameterized.class)) @@ -108,6 +114,7 @@ public void construct_WhenClassHasDefaultAndParameterConstructorWithoutRegistere // when ClassConstructorDefaultAndParameterized result = testObject.construct(ClassConstructorDefaultAndParameterized.class); + // then Assertions.assertThat(result).isNotNull(); } @@ -202,6 +209,7 @@ public void construct_WhenSetterThrowsException_ThenSetterInvocationException() { // given dictionary.addInstance(String.class, "string"); + // then Assertions.assertThatThrownBy(() -> testObject.construct(ClassSetterThrows.class)) .isInstanceOf(SetterInvocationException.class); @@ -212,8 +220,10 @@ public void construct_WhenDependencySetterOnly_ThenInstanceIsResolved() { // given dictionary.addType(InterfaceBasic.class, ClassConstructorDefault.class); + // when InterfaceSetter result = testObject.construct(ClassSetterSingle.class); + // then Assertions.assertThat(result).isNotNull(); Assertions.assertThat(result.getBasicObject()).isNotNull(); @@ -229,8 +239,10 @@ public void construct_WhenMultipleDependencySetters_ThenInstanceIsResolved() dictionary.addType(InterfaceBasic.class, ClassConstructorDefault.class); dictionary.addType(InterfaceBasicStringGetter.class, ClassBasicStringGetter.class); dictionary.addInstance(String.class, string); + // when InterfaceSetterMultiple result = testObject.construct(InterfaceSetterMultiple.class); + // then Assertions.assertThat(result).isNotNull(); Assertions.assertThat(result.getBasicObject()).isNotNull(); @@ -259,9 +271,11 @@ public void construct_WhenDependenciesWithRegisteredInstance_ThenInstanceIsResol dictionary.addType(InterfaceBasicSimpleDependency.class, ClassConstructorNotAnnotatedWithDependency.class, ConstructionPolicy.defaultPolicy); + // when InterfaceBasicSimpleDependency result = testObject.construct(InterfaceBasicSimpleDependency.class); + // then Assertions.assertThat(result) .isNotNull() @@ -287,9 +301,11 @@ public void construct_WhenDependenciesWithoutAnnotatedConstructorsWithAllDepende dictionary.addType(InterfaceBasicSimpleDependency.class, ClassConstructorNotAnnotatedWithDependency.class, ConstructionPolicy.defaultPolicy); + // when InterfaceBasicSimpleDependency result = testObject.construct(InterfaceBasicSimpleDependency.class); + // then Assertions.assertThat(result) .isNotNull() @@ -313,9 +329,11 @@ public void construct_WhenDependenciesWithoutAnnotatedConstructorsWithoutSomeDep dictionary.addType(InterfaceBasicSimpleDependency.class, ClassConstructorNotAnnotatedWithDependency.class, ConstructionPolicy.defaultPolicy); + // when InterfaceBasicSimpleDependency result = testObject.construct(InterfaceBasicSimpleDependency.class); + // then Assertions.assertThat(result) .isNotNull() @@ -340,9 +358,11 @@ public void construct_WhenDependenciesWithAnnotatedConstructor_ThenInstanceIsRes dictionary.addType(InterfaceBasicSimpleDependency.class, ClassConstructorAnnotatedWithDependency.class, ConstructionPolicy.defaultPolicy); + // when InterfaceBasicSimpleDependency result = testObject.construct(InterfaceBasicSimpleDependency.class); + // then Assertions.assertThat(result) .isNotNull() @@ -363,6 +383,7 @@ public void construct_WhenDependenciesWithAnnotatedConstructorWithoutSomeDepende ConstructionPolicy.defaultPolicy); dictionary.addType(InterfaceDiamondBottom.class, ClassDiamondBottom.class, ConstructionPolicy.defaultPolicy); + // then Assertions.assertThatThrownBy(() -> testObject.construct(InterfaceDiamondBottom.class)) .isInstanceOf(MissingDependenciesException.class); @@ -380,8 +401,10 @@ public void construct_WhenDiamondDependenciesWithoutSingleton_ThenInstanceIsReso ConstructionPolicy.defaultPolicy); dictionary.addType(InterfaceDiamondTop.class, ClassDiamondTop.class, ConstructionPolicy.defaultPolicy); + // when InterfaceDiamondBottom result = testObject.construct(InterfaceDiamondBottom.class); + // then Assertions.assertThat(result).isNotNull().isInstanceOf(ClassDiamondBottom.class); Assertions.assertThat(result.getDiamond1()).isNotNull(); @@ -404,8 +427,10 @@ public void construct_WhenDiamondDependenciesWithSingleton_ThenInstanceIsResolve ConstructionPolicy.defaultPolicy); dictionary.addType(InterfaceDiamondTop.class, ClassDiamondTop.class, ConstructionPolicy.SINGLETON); + // when InterfaceDiamondBottom result = testObject.construct(InterfaceDiamondBottom.class); + // then Assertions.assertThat(result).isNotNull().isInstanceOf(ClassDiamondBottom.class); Assertions.assertThat(result.getDiamond1()).isNotNull(); @@ -424,6 +449,7 @@ public void construct_WhenCircularDependencies_ThenCircularDependenciesException ConstructionPolicy.defaultPolicy); dictionary.addType(InterfaceCircularRight.class, ClassCircularRight.class, ConstructionPolicy.defaultPolicy); + // then Assertions.assertThatThrownBy(() -> testObject.construct(InterfaceCircularRight.class)) .isInstanceOf(CircularDependenciesException.class); @@ -444,9 +470,11 @@ public void construct_WhenCanOmitCircularDependencies_ThenInstanceIsResolved() ConstructionPolicy.defaultPolicy); dictionary.addType(InterfaceCircularDependency.class, ClassCircularDependency.class, ConstructionPolicy.defaultPolicy); + // when InterfaceCircularDependency result = testObject.construct(InterfaceCircularDependency.class); + // then Assertions.assertThat(result).isNotNull().isInstanceOf(ClassCircularDependency.class); Assertions.assertThat(result.getNonCircularObject()).isNotNull(); @@ -473,9 +501,11 @@ public void construct_WhenComplexDependency_ThenInstanceIsResolved() dictionary.addType(InterfaceBasicStringGetter.class, ClassBasicStringGetter.class, ConstructionPolicy.defaultPolicy); dictionary.addInstance(String.class, string); + // when InterfaceBasicComplexDependency result = testObject.construct(InterfaceBasicComplexDependency.class); + // then Assertions.assertThat(result).isNotNull().isInstanceOf(ClassBasicComplexDependency.class); Assertions.assertThat(result.getBasicObject()).isNotNull(); @@ -494,6 +524,7 @@ public void construct_WhenAnnotatedInterface_ThenInstanceIsResolved() // when InterfaceRegister result1 = testObject.construct(InterfaceRegister.class); InterfaceRegister result2 = testObject.construct(InterfaceRegister.class); + // then Assertions.assertThat(result1).isNotNull().isInstanceOf(ClassRegisterInterface.class); Assertions.assertThat(result2) @@ -508,6 +539,7 @@ public void construct_WhenAnnotatedAbstractClass_ThenInstanceIsResolved() // when ClassRegisterAbstract result1 = testObject.construct(ClassRegisterAbstract.class); ClassRegisterAbstract result2 = testObject.construct(ClassRegisterAbstract.class); + // then Assertions.assertThat(result1).isNotNull().isInstanceOf(ClassRegisterConcrete.class); Assertions.assertThat(result2) @@ -522,6 +554,7 @@ public void construct_WhenAnnotatedConcreteClass_ThenInstanceIsResolved() // when ClassRegisterConcrete result1 = testObject.construct(ClassRegisterConcrete.class); ClassRegisterConcrete result2 = testObject.construct(ClassRegisterConcrete.class); + // then Assertions.assertThat(result1) .isNotNull() @@ -538,6 +571,7 @@ public void construct_WhenSelfAnnotatedConcreteClass_ThenInstanceIsResolved() // when ClassRegisterSelf result1 = testObject.construct(ClassRegisterSelf.class); ClassRegisterSelf result2 = testObject.construct(ClassRegisterSelf.class); + // then Assertions.assertThat(result1).isNotNull(); Assertions.assertThat(result2).isNotNull().isNotSameAs(result1); @@ -549,6 +583,7 @@ public void construct_WhenAnnotatedConcreteClassAsItself_ThenInstanceIsResolved( // when ClassRegisterSelfAsSubtype result1 = testObject.construct(ClassRegisterSelfAsSubtype.class); ClassRegisterSelfAsSubtype result2 = testObject.construct(ClassRegisterSelfAsSubtype.class); + // then Assertions.assertThat(result1).isNotNull(); Assertions.assertThat(result2).isNotNull().isNotSameAs(result1); @@ -615,6 +650,7 @@ public void construct_WhenAnnotatedInterfaceSingleton_ThenSameInstances() // when InterfaceRegisterSingleton result1 = testObject.construct(InterfaceRegisterSingleton.class); InterfaceRegisterSingleton result2 = testObject.construct(InterfaceRegisterSingleton.class); + // then Assertions.assertThat(result1).isNotNull().isInstanceOf(ClassRegisterSingletonBase.class); Assertions.assertThat(result2) @@ -629,6 +665,7 @@ public void construct_WhenAnnotatedConcreteClassSingleton_ThenSameInstances() // when ClassRegisterSingletonBase result1 = testObject.construct(ClassRegisterSingletonBase.class); ClassRegisterSingletonBase result2 = testObject.construct(ClassRegisterSingletonBase.class); + // then Assertions.assertThat(result1) .isNotNull() @@ -645,6 +682,7 @@ public void construct_WhenSelfAnnotatedConcreteClassSingleton_ThenSameInstances( // when ClassRegisterSelfSingleton result1 = testObject.construct(ClassRegisterSelfSingleton.class); ClassRegisterSelfSingleton result2 = testObject.construct(ClassRegisterSelfSingleton.class); + // then Assertions.assertThat(result1).isNotNull(); Assertions.assertThat(result2).isNotNull().isSameAs(result1); @@ -658,6 +696,7 @@ public void construct_WhenAnnotatedConcreteClassAsItselfSingleton_ThenSameInstan testObject.construct(ClassRegisterSelfAsSubtypeSingleton.class); ClassRegisterSelfAsSubtypeSingleton result2 = testObject.construct(ClassRegisterSelfAsSubtypeSingleton.class); + // then Assertions.assertThat(result1).isNotNull(); Assertions.assertThat(result2).isNotNull().isSameAs(result1); @@ -676,8 +715,10 @@ public void inject_WhenMultipleDependencySetters_ThenInstanceIsResolved() dictionary.addType(InterfaceBasic.class, ClassConstructorDefault.class); dictionary.addType(InterfaceBasicStringGetter.class, ClassBasicStringGetter.class); dictionary.addInstance(String.class, string); + // when InterfaceSetterMultiple result = testObject.inject(instance); + // then Assertions.assertThat(result).isSameAs(instance); Assertions.assertThat(result.getBasicObject()).isNotNull();