Support @TestPropertySource as a repeatable annotation

Prior to this commit, @TestPropertySource could not be declared as a
repeatable annotation. In addition, a local declaration of
@TestPropertySource would silently override a meta-present
@TestPropertySource.

This commit addresses this issue by introducing @TestPropertySources as
a container for @TestPropertySource. This commit also updates the
search and algorithms within TestPropertySourceUtils.

Closes gh-23320

spring-test/src/test/java/org/springframework/test/context/env/repeatable/AnnotationWithTestProperty.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.test.context.TestPropertySource;
+
+/**
+ * A custom annotation with properties defined by the {@link TestPropertySource}.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@TestPropertySource(properties = "meta = value from meta-annotation")
+public @interface AnnotationWithTestProperty {
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/AnnotationWithTestPropertyInPropertiesFile.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.test.context.TestPropertySource;
+
+/**
+ * A custom annotation which defined properties file in the {@link TestPropertySource}.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@TestPropertySource("meta.properties")
+public @interface AnnotationWithTestPropertyInPropertiesFile {
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/FooTestProperty.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.test.context.TestPropertySource;
+
+/**
+ * A custom annotation with foo property defined by the {@link TestPropertySource}.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@TestPropertySource(properties = "foo = value from meta-annotation")
+public @interface FooTestProperty {
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/FooTestPropertyDeclaration.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.springframework.test.context.TestPropertySource;
+
+/**
+ * Abstract parent class with foo property definition for tests.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@TestPropertySource(properties = "foo = value from parent class")
+public abstract class FooTestPropertyDeclaration {
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/ParentClassWithMultipleTestProperties.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.springframework.test.context.TestPropertySource;
+
+/**
+ * Abstract parent class with multiple properties definition for tests.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@TestPropertySource(properties = "first = value from parent class")
+@TestPropertySource(properties = "second = value from parent class")
+public abstract class ParentClassWithMultipleTestProperties {
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/ParentClassWithTestProperties.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.springframework.test.context.TestPropertySource;
+
+
+/**
+ * Base class which declare a property by the {@link TestPropertySource} annotation.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@TestPropertySource(properties = "inherited = 12345")
+public abstract class ParentClassWithTestProperties {
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceInheritTests.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * Test a property definition by the using of {@link TestPropertySource} both in the
+ * parent class and locally.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource(properties = "key = 051187")
+public class TestPropertySourceInheritTests extends ParentClassWithTestProperties {
+
+	@Autowired
+	Environment env;
+
+	@Value("${key}")
+	String key;
+
+	@Value("${inherited}")
+	String inherited;
+
+
+	@Test
+	public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
+		assertThat(env.getProperty("key")).isEqualTo("051187");
+		assertThat(this.key).isEqualTo("051187");
+
+		assertThat(env.getProperty("inherited")).isEqualTo("12345");
+		assertThat(inherited).isEqualTo("12345");
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceInheritedFromMetaAnnotationOverridesLocallyTests.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * This test verifies an overriding of the property value which declared in the
+ * meta-annotation by the {@link TestPropertySource} when this property is also defined
+ * locally in {@link TestPropertySource}.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource(properties = "meta = local value")
+@AnnotationWithTestProperty
+public class TestPropertySourceInheritedFromMetaAnnotationOverridesLocallyTests {
+
+	@Autowired
+	Environment env;
+
+	@Value("${meta}")
+	String meta;
+
+
+	@Test
+	public void inlineLocalPropertyAndPropertyFromMetaAnnotation() {
+		assertThat(env.getProperty("meta")).isEqualTo("local value");
+		assertThat(meta).isEqualTo("local value");
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceInheritedFromMetaAnnotationTests.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * This test verifies a declaration of properties by the {@link TestPropertySource} both
+ * locally and in the custom meta-annotation.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource(properties = "key = 051187")
+@AnnotationWithTestProperty
+public class TestPropertySourceInheritedFromMetaAnnotationTests {
+
+	@Autowired
+	Environment env;
+
+	@Value("${key}")
+	String key;
+
+	@Value("${meta}")
+	String meta;
+
+
+	@Test
+	public void inlineLocalPropertyAndPropertyFromMetaAnnotation() {
+		// local inlined:
+		assertThat(env.getProperty("key")).isEqualTo("051187");
+		assertThat(this.key).isEqualTo("051187");
+		// inlined from meta-annotation:
+		assertThat(env.getProperty("meta")).isEqualTo("value from meta-annotation");
+		assertThat(meta).isEqualTo("value from meta-annotation");
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceInheritedFromMetaAnnotationWithPropertiesFileTests.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * Verify a property value defined both in the properties file which declared in the
+ * custom annotation {@link AnnotationWithTestPropertyInPropertiesFile} and a definition
+ * of property by the local usage of {@link TestPropertySource} with a properties file
+ * name.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource("local.properties")
+@AnnotationWithTestPropertyInPropertiesFile
+public class TestPropertySourceInheritedFromMetaAnnotationWithPropertiesFileTests {
+
+	@Autowired
+	Environment env;
+
+	@Value("${key}")
+	String key;
+
+	@Value("${meta}")
+	String meta;
+
+
+	@Test
+	public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
+		assertPropertyValue("key", key, "local value");
+		assertPropertyValue("meta", meta, "a value from file in the meta-annotation");
+	}
+
+	private void assertPropertyValue(String name, String value, String expectedValue) {
+		assertThat(env.getProperty(name)).isEqualTo(expectedValue);
+		assertThat(value).isEqualTo(expectedValue);
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceOverridesInheritedPropertyTests.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * Verify the overriding of property which defined both in the parent class and locally in
+ * the {@link TestPropertySource} annotation.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource(properties = "inherited = local value")
+public class TestPropertySourceOverridesInheritedPropertyTests extends ParentClassWithTestProperties {
+
+	@Autowired
+	Environment env;
+
+	@Value("${inherited}")
+	String inherited;
+
+
+	@Test
+	public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
+		assertThat(env.getProperty("inherited")).isEqualTo("local value");
+		assertThat(inherited).isEqualTo("local value");
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourcePartialOverridesInheritedPropertyTests.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * Verify the overriding of property which defined both in the parent class and locally in
+ * the {@link TestPropertySource} annotation. Also, verify that the value of not
+ * conflicted properties is applied from the parent class.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource(properties = "second = local value")
+public class TestPropertySourcePartialOverridesInheritedPropertyTests extends ParentClassWithMultipleTestProperties {
+
+	@Value("${first}")
+	String first;
+
+	@Value("${second}")
+	String second;
+
+
+	@Test
+	public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
+		assertThat(first).isEqualTo("value from parent class");
+		assertThat(second).isEqualTo("local value");
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceRepeatableOverridesTests.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * Verify an overriding of a property value which defined both in custom annotation
+ * and in the parent class, when this property declares locally by the
+ * {@link TestPropertySource}.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@FooTestProperty
+@TestPropertySource(properties = "foo = local value")
+public class TestPropertySourceRepeatableOverridesTests extends FooTestPropertyDeclaration {
+
+	@Value("${foo}")
+	String foo;
+
+	@Test
+	public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
+		assertThat(foo).isEqualTo("local value");
+	}
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceRepeatableTests.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * Test multiple test property declarations by the using of {@link TestPropertySource} as
+ * a repeatable annotation.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource(properties = "first = 1111")
+@TestPropertySource(properties = "second = 2222")
+public class TestPropertySourceRepeatableTests {
+
+	@Autowired
+	Environment env;
+
+	@Value("${first}")
+	String first;
+
+	@Value("${second}")
+	String second;
+
+
+	@Test
+	public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
+		assertPropertyValue("first", first, "1111");
+		assertPropertyValue("second", second, "2222");
+	}
+
+	private void assertPropertyValue(String name, String value, String expectedValue) {
+		assertThat(env.getProperty(name)).isEqualTo(expectedValue);
+		assertThat(value).isEqualTo(expectedValue);
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceRepeatableWithDefaultPropertiesFileTests.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * Verify a repeatable usage of {@link TestPropertySource} both with a default value of
+ * properties file and with a specified properties file name in the
+ * {@link TestPropertySource} annotation.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource
+@TestPropertySource("local.properties")
+public class TestPropertySourceRepeatableWithDefaultPropertiesFileTests {
+
+	@Autowired
+	Environment env;
+
+	@Value("${key}")
+	String key;
+
+	@Value("${default.value}")
+	String defaultValue;
+
+	@Test
+	public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
+		assertPropertyValue("key", key, "local value");
+		assertPropertyValue("default.value", defaultValue, "a value from default properties file");
+	}
+
+	private void assertPropertyValue(String name, String value, String expectedValue) {
+		assertThat(env.getProperty(name)).isEqualTo(expectedValue);
+		assertThat(value).isEqualTo(expectedValue);
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}

spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceRepeatableWithPropertiesFileTests.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.env.repeatable;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for support {@link TestPropertySource @TestPropertySource} as a
+ * repeatable annotation.
+ *
+ * Test multiple test properties file declarations by the using of {@link TestPropertySource} as
+ * a repeatable annotation.
+ *
+ * @author Anatoliy Korovin
+ * @since 5.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+@TestPropertySource("first.properties")
+@TestPropertySource("second.properties")
+public class TestPropertySourceRepeatableWithPropertiesFileTests {
+
+	@Autowired
+	Environment env;
+
+	@Value("${first}")
+	String first;
+
+	@Value("${second}")
+	String second;
+
+
+	@Test
+	public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
+		assertPropertyValue("first", first, "1111");
+		assertPropertyValue("second", second, "2222");
+	}
+
+	private void assertPropertyValue(String name, String value, String expectedValue) {
+		assertThat(env.getProperty(name)).isEqualTo(expectedValue);
+		assertThat(value).isEqualTo(expectedValue);
+	}
+
+
+	@Configuration
+	static class Config {
+	}
+}