Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

spring-di/src/test/java/com/baeldung/autowired/FieldAutowiredIntegrationTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.autowired;
+
+import com.baeldung.configuration.ApplicationContextTestAutowiredType;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestAutowiredType.class)
+public class FieldAutowiredIntegrationTest {
+
+    @Autowired
+    private ArbitraryDependency fieldDependency;
+
+    @Test
+    public void givenAutowired_WhenSetOnField_ThenDependencyResolved() {
+        assertNotNull(fieldDependency);
+        assertEquals("Arbitrary Dependency", fieldDependency.toString());
+    }
+}

spring-di/src/test/java/com/baeldung/autowired/FieldAutowiredNameIntegrationTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.autowired;
+
+import com.baeldung.configuration.ApplicationContextTestAutowiredName;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestAutowiredName.class)
+public class FieldAutowiredNameIntegrationTest {
+
+    @Autowired
+    private ArbitraryDependency autowiredFieldDependency;
+
+    @Test
+    public void givenAutowiredAnnotation_WhenOnField_ThenDependencyValid() {
+        assertNotNull(autowiredFieldDependency);
+        assertEquals("Arbitrary Dependency", autowiredFieldDependency.toString());
+    }
+}

spring-di/src/test/java/com/baeldung/autowired/FieldQualifierAutowiredIntegrationTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.autowired;
+
+import com.baeldung.configuration.ApplicationContextTestAutowiredQualifier;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestAutowiredQualifier.class)
+public class FieldQualifierAutowiredIntegrationTest {
+
+    @Autowired
+    @Qualifier("autowiredFieldDependency")
+    private ArbitraryDependency fieldDependency1;
+
+    @Autowired
+    @Qualifier("anotherAutowiredFieldDependency")
+    private ArbitraryDependency fieldDependency2;
+
+    @Test
+    public void givenAutowiredQualifier_WhenOnField_ThenDep1Valid() {
+        assertNotNull(fieldDependency1);
+        assertEquals("Arbitrary Dependency", fieldDependency1.toString());
+    }
+
+    @Test
+    public void givenAutowiredQualifier_WhenOnField_ThenDep2Valid() {
+        assertNotNull(fieldDependency2);
+        assertEquals("Another Arbitrary Dependency", fieldDependency2.toString());
+    }
+}

spring-di/src/test/java/com/baeldung/circulardependency/CircularDependencyIntegrationTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.circulardependency;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { TestConfig.class })
+public class CircularDependencyIntegrationTest {
+
+    @Autowired
+    ApplicationContext context;
+
+    @Bean
+    public CircularDependencyA getCircularDependencyA() {
+        return new CircularDependencyA();
+    }
+
+    @Bean
+    public CircularDependencyB getCircularDependencyB() {
+        return new CircularDependencyB();
+    }
+
+    @Test
+    public void givenCircularDependency_whenSetterInjection_thenItWorks() {
+        final CircularDependencyA circA = context.getBean(CircularDependencyA.class);
+
+        Assert.assertEquals("Hi!", circA.getCircB().getMessage());
+    }
+}

spring-di/src/test/java/com/baeldung/circulardependency/TestConfig.java

@@ -0,0 +1,10 @@
+package com.baeldung.circulardependency;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan(basePackages = { "com.baeldung.circulardependency" })
+public class TestConfig {
+
+}

spring-di/src/test/java/com/baeldung/configuration/ApplicationContextTestAutowiredName.java

@@ -0,0 +1,9 @@
+package com.baeldung.configuration;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan(basePackages = {"com.baeldung.dependency"})
+public class ApplicationContextTestAutowiredName {
+}

spring-di/src/test/java/com/baeldung/configuration/ApplicationContextTestAutowiredQualifier.java

@@ -0,0 +1,24 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.AnotherArbitraryDependency;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestAutowiredQualifier {
+
+    @Bean
+    public ArbitraryDependency autowiredFieldDependency() {
+        ArbitraryDependency autowiredFieldDependency = new ArbitraryDependency();
+
+        return autowiredFieldDependency;
+    }
+
+    @Bean
+    public ArbitraryDependency anotherAutowiredFieldDependency() {
+        ArbitraryDependency anotherAutowiredFieldDependency = new AnotherArbitraryDependency();
+
+        return anotherAutowiredFieldDependency;
+    }
+}

spring-di/src/test/java/com/baeldung/configuration/ApplicationContextTestAutowiredType.java

@@ -0,0 +1,15 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.ArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestAutowiredType {
+
+    @Bean
+    public ArbitraryDependency autowiredFieldDependency() {
+        ArbitraryDependency autowiredFieldDependency = new ArbitraryDependency();
+        return autowiredFieldDependency;
+    }
+}

spring-di/src/test/java/com/baeldung/configuration/ApplicationContextTestInjectName.java

@@ -0,0 +1,16 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.ArbitraryDependency;
+import com.baeldung.dependency.YetAnotherArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestInjectName {
+
+    @Bean
+    public ArbitraryDependency yetAnotherFieldInjectDependency() {
+        ArbitraryDependency yetAnotherFieldInjectDependency = new YetAnotherArbitraryDependency();
+        return yetAnotherFieldInjectDependency;
+    }
+}

spring-di/src/test/java/com/baeldung/configuration/ApplicationContextTestInjectQualifier.java

@@ -0,0 +1,22 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.AnotherArbitraryDependency;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestInjectQualifier {
+
+    @Bean
+    public ArbitraryDependency defaultFile() {
+        ArbitraryDependency defaultFile = new ArbitraryDependency();
+        return defaultFile;
+    }
+
+    @Bean
+    public ArbitraryDependency namedFile() {
+        ArbitraryDependency namedFile = new AnotherArbitraryDependency();
+        return namedFile;
+    }
+}

spring-di/src/test/java/com/baeldung/configuration/ApplicationContextTestInjectType.java

@@ -0,0 +1,15 @@
+package com.baeldung.configuration;
+
+import com.baeldung.dependency.ArbitraryDependency;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ApplicationContextTestInjectType {
+
+    @Bean
+    public ArbitraryDependency injectDependency() {
+        ArbitraryDependency injectDependency = new ArbitraryDependency();
+        return injectDependency;
+    }
+}

spring-di/src/test/java/com/baeldung/constructordi/ConstructorDependencyInjectionIntegrationTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.constructordi;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import com.baeldung.constructordi.domain.Car;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class, classes = Config.class)
+public class ConstructorDependencyInjectionIntegrationTest {
+
+    @Test
+    public void givenPrototypeInjection_WhenObjectFactory_ThenNewInstanceReturn() {
+        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
+        Car firstContextCar = context.getBean(Car.class);
+
+        ApplicationContext xmlContext = new ClassPathXmlApplicationContext("constructordi.xml");
+        Car secondContextCar = xmlContext.getBean(Car.class);
+
+        assertThat(firstContextCar).isNotSameAs(secondContextCar);
+        assertThat(firstContextCar).hasToString("Engine: v8 5 Transmission: sliding");
+        assertThat(secondContextCar).hasToString("Engine: v4 2 Transmission: sliding");
+    }
+
+}

spring-di/src/test/java/com/baeldung/dependencyinjectiontypes/DependencyInjectionIntegrationTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.dependencyinjectiontypes;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+public class DependencyInjectionIntegrationTest {
+
+    @Test
+    public void givenAutowiredAnnotation_WhenSetOnSetter_ThenDependencyValid() {
+        
+    	ApplicationContext context = new ClassPathXmlApplicationContext("dependencyinjectiontypes-context.xml");
+    	ArticleWithSetterInjection article = (ArticleWithSetterInjection) context.getBean("articleWithSetterInjectionBean");
+        
+    	String originalText = "This is a text !";
+    	String formattedArticle = article.format(originalText);
+    	
+    	assertTrue(originalText.toUpperCase().equals(formattedArticle));
+    }
+    
+    @Test
+    public void givenAutowiredAnnotation_WhenSetOnConstructor_ThenDependencyValid() {
+    	
+    	ApplicationContext context = new ClassPathXmlApplicationContext("dependencyinjectiontypes-context.xml");
+    	ArticleWithConstructorInjection article = (ArticleWithConstructorInjection) context.getBean("articleWithConstructorInjectionBean");
+        
+    	String originalText = "This is a text !";
+    	String formattedArticle = article.format(originalText);
+    	
+    	assertTrue(originalText.toUpperCase().equals(formattedArticle));
+    }
+    
+}

spring-di/src/test/java/com/baeldung/dependson/config/TestConfig.java

@@ -0,0 +1,59 @@
+package com.baeldung.dependson.config;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.DependsOn;
+import org.springframework.context.annotation.Lazy;
+
+import com.baeldung.dependson.file.processor.FileProcessor;
+import com.baeldung.dependson.file.reader.FileReader;
+import com.baeldung.dependson.file.writer.FileWriter;
+import com.baeldung.dependson.shared.File;
+
+@Configuration
+@ComponentScan("com.baeldung.dependson")
+public class TestConfig {
+    
+    @Autowired
+    File file;
+    
+    @Bean("fileProcessor")
+    @DependsOn({"fileReader","fileWriter"})
+    @Lazy
+    public FileProcessor fileProcessor(){
+        return new FileProcessor(file);
+    }
+    
+    @Bean("fileReader")
+    public FileReader fileReader(){
+        return new FileReader(file);
+    }
+    
+    @Bean("fileWriter")
+    public FileWriter fileWriter(){
+        return new FileWriter(file);
+    }
+    
+    @Bean("dummyFileProcessor")
+    @DependsOn({"dummyfileWriter"})
+    @Lazy
+    public FileProcessor dummyFileProcessor(){
+        return new FileProcessor(file);
+    }
+    
+    @Bean("dummyFileProcessorCircular")
+    @DependsOn({"dummyFileReaderCircular"})
+    @Lazy
+    public FileProcessor dummyFileProcessorCircular(){
+        return new FileProcessor(file);
+    }
+    
+    @Bean("dummyFileReaderCircular")
+    @DependsOn({"dummyFileProcessorCircular"})
+    @Lazy
+    public FileReader dummyFileReaderCircular(){
+        return new FileReader(file);
+    }
+}

spring-di/src/test/java/com/baeldung/dependson/processor/FileProcessorIntegrationTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.dependson.processor;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.dependson.config.TestConfig;
+import com.baeldung.dependson.shared.File;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = TestConfig.class)
+public class FileProcessorIntegrationTest {
+
+    @Autowired
+    ApplicationContext context;
+    
+    @Autowired
+    File file;
+    
+    @Test
+    public void whenAllBeansCreated_FileTextEndsWithProcessed() {
+        context.getBean("fileProcessor");
+        assertTrue(file.getText().endsWith("processed"));
+    }
+
+    @Test(expected=BeanCreationException.class)
+    public void whenDependentBeanNotAvailable_ThrowsNoSuchBeanDefinitionException(){
+        context.getBean("dummyFileProcessor");
+    }
+    
+    @Test(expected=BeanCreationException.class)
+    public void whenCircularDependency_ThrowsBeanCreationException(){
+        context.getBean("dummyFileReaderCircular");
+    }
+}

spring-di/src/test/java/com/baeldung/di/spring/BeanInjectionIntegrationTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.di.spring;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+public class BeanInjectionIntegrationTest {
+
+    private ApplicationContext applicationContext;
+
+    @Before
+    public void setUp() throws Exception {
+        applicationContext = new ClassPathXmlApplicationContext("com.baeldung.di.spring.xml");
+    }
+
+    @Test
+    public void singletonBean_getBean_returnsSingleInstance() {
+        final IndexApp indexApp1 = applicationContext.getBean("indexApp", IndexApp.class);
+        final IndexApp indexApp2 = applicationContext.getBean("indexApp", IndexApp.class);
+        assertEquals(indexApp1, indexApp2);
+    }
+
+    @Test
+    public void getBean_returnsInstance() {
+        final IndexApp indexApp = applicationContext.getBean("indexApp", IndexApp.class);
+        assertNotNull(indexApp);
+    }
+
+}

spring-di/src/test/java/com/baeldung/di/spring/SpringUnitTest.java

@@ -0,0 +1,57 @@
+package com.baeldung.di.spring;
+
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@ContextConfiguration(classes = { SpringMainConfig.class })
+public class SpringUnitTest {
+	@Autowired
+	ApplicationContext context;
+
+	@Test
+	public void givenAccountServiceAutowiredToUserService_WhenGetAccountServiceInvoked_ThenReturnValueIsNotNull() {
+		UserService userService = context.getBean(UserService.class);
+		assertNotNull(userService.getAccountService());
+	}
+
+	@Test
+	public void givenBookServiceIsRegisteredAsBeanInContext_WhenBookServiceIsRetrievedFromContext_ThenReturnValueIsNotNull() {
+		BookService bookService = context.getBean(BookService.class);
+		assertNotNull(bookService);
+	}
+
+	@Test
+	public void givenBookServiceIsRegisteredAsBeanInContextByOverridingAudioBookService_WhenAudioBookServiceIsRetrievedFromContext_ThenNoSuchBeanDefinitionExceptionIsThrown() {
+		BookService bookService = context.getBean(BookService.class);
+		assertNotNull(bookService);
+		AudioBookService audioBookService = context.getBean(AudioBookService.class);
+		assertNotNull(audioBookService);
+	}
+
+	@Test
+	public void givenAuthorServiceAutowiredToBookServiceAsOptionalDependency_WhenBookServiceIsRetrievedFromContext_ThenNoSuchBeanDefinitionExceptionIsNotThrown() {
+		BookService bookService = context.getBean(BookService.class);
+		assertNotNull(bookService);
+	}
+
+	@Test
+	public void givenSpringPersonServiceConstructorAnnotatedByAutowired_WhenSpringPersonServiceIsRetrievedFromContext_ThenInstanceWillBeCreatedFromTheConstructor() {
+		SpringPersonService personService = context.getBean(SpringPersonService.class);
+		assertNotNull(personService);
+	}
+
+	@Test
+	public void givenPersonDaoAutowiredToSpringPersonServiceBySetterInjection_WhenSpringPersonServiceRetrievedFromContext_ThenPersonDaoInitializedByTheSetter() {
+		SpringPersonService personService = context.getBean(SpringPersonService.class);
+		assertNotNull(personService);
+		assertNotNull(personService.getPersonDao());
+	}
+
+}

spring-di/src/test/java/com/baeldung/inject/FieldByNameInjectIntegrationTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.inject;
+
+import com.baeldung.configuration.ApplicationContextTestInjectName;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestInjectName.class)
+public class FieldByNameInjectIntegrationTest {
+
+    @Inject
+    @Named("yetAnotherFieldInjectDependency")
+    private ArbitraryDependency yetAnotherFieldInjectDependency;
+
+    @Test
+    public void givenInjectQualifier_WhenSetOnField_ThenDependencyValid() {
+        assertNotNull(yetAnotherFieldInjectDependency);
+        assertEquals("Yet Another Arbitrary Dependency", yetAnotherFieldInjectDependency.toString());
+    }
+}

spring-di/src/test/java/com/baeldung/inject/FieldInjectIntegrationTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.inject;
+
+import com.baeldung.configuration.ApplicationContextTestInjectType;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.inject.Inject;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(
+  loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestInjectType.class)
+public class FieldInjectIntegrationTest {
+
+    @Inject
+    private ArbitraryDependency fieldInjectDependency;
+
+    @Test
+    public void givenInjectAnnotation_WhenOnField_ThenValidDependency() {
+        assertNotNull(fieldInjectDependency);
+        assertEquals("Arbitrary Dependency", fieldInjectDependency.toString());
+    }
+}

spring-di/src/test/java/com/baeldung/inject/FieldQualifierInjectIntegrationTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.inject;
+
+import com.baeldung.configuration.ApplicationContextTestInjectQualifier;
+import com.baeldung.dependency.ArbitraryDependency;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+import javax.inject.Inject;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class,
+  classes = ApplicationContextTestInjectQualifier.class)
+public class FieldQualifierInjectIntegrationTest {
+
+    @Inject
+    @Qualifier("defaultFile")
+    private ArbitraryDependency defaultDependency;
+
+    @Inject
+    @Qualifier("namedFile")
+    private ArbitraryDependency namedDependency;
+
+    @Test
+    public void givenInjectQualifier_WhenOnField_ThenDefaultFileValid() {
+        assertNotNull(defaultDependency);
+        assertEquals("Arbitrary Dependency", defaultDependency.toString());
+    }
+
+    @Test
+    public void givenInjectQualifier_WhenOnField_ThenNamedFileValid() {
+        assertNotNull(defaultDependency);
+        assertEquals("Another Arbitrary Dependency", namedDependency.toString());
+    }
+}

spring-di/src/test/java/com/baeldung/methodinjections/StudentIntegrationTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.methodinjections;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+public class StudentIntegrationTest {
+
+    @Test
+    public void whenLookupMethodCalled_thenNewInstanceReturned() {
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
+        Student student1 = context.getBean("studentBean", Student.class);
+        Student student2 = context.getBean("studentBean", Student.class);
+
+        Assert.assertEquals(student1, student2);
+        Assert.assertNotEquals(student1.getNotification("Alex"), student2.getNotification("Bethany"));
+        context.close();
+    }
+
+    @Test
+    public void whenAbstractGetterMethodInjects_thenNewInstanceReturned() {
+        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
+        StudentServices services = context.getBean("studentServices", StudentServices.class);
+
+        Assert.assertEquals("PASS", services.appendMark("Alex", 76));
+        Assert.assertEquals("FAIL", services.appendMark("Bethany", 44));
+        Assert.assertEquals("PASS", services.appendMark("Claire", 96));
+        context.close();
+    }
+}

spring-di/src/test/java/com/baeldung/sample/FooServiceIntegrationTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.sample;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = AppConfig.class, loader = AnnotationConfigContextLoader.class)
+public class FooServiceIntegrationTest {
+
+    @Autowired
+    FooService fooService;
+
+    @Test
+    public void whenFooFormatterType_thenReturnFoo() {
+        Assert.assertEquals("foo", fooService.doStuff());
+    }
+}