Tidy up compiler warnings

spring-cloud-context/src/main/java/org/springframework/cloud/autoconfigure/LifecycleMvcEndpointAutoConfiguration.java

@@ -21,7 +21,6 @@ import org.springframework.boot.actuate.endpoint.mvc.MvcEndpoint;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
 import org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration;
 import org.springframework.cloud.context.environment.EnvironmentManager;

spring-cloud-context/src/main/java/org/springframework/cloud/autoconfigure/RefreshEndpointAutoConfiguration.java

@@ -26,7 +26,6 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.cloud.bootstrap.config.PropertySourceBootstrapConfiguration;
 import org.springframework.cloud.context.properties.ConfigurationPropertiesRebinder;
 import org.springframework.cloud.context.refresh.ContextRefresher;
@@ -93,14 +92,16 @@ public class RefreshEndpointAutoConfiguration {
 		@Bean
 		@ConditionalOnMissingBean
 		@ConditionalOnEnabledEndpoint("pause")
-		public RestartEndpoint.PauseEndpoint pauseEndpoint(RestartEndpoint restartEndpoint) {
+		public RestartEndpoint.PauseEndpoint pauseEndpoint(
+				RestartEndpoint restartEndpoint) {
 			return restartEndpoint.getPauseEndpoint();
 		}
 
 		@Bean
 		@ConditionalOnMissingBean
 		@ConditionalOnEnabledEndpoint("resume")
-		public RestartEndpoint.ResumeEndpoint resumeEndpoint(RestartEndpoint restartEndpoint) {
+		public RestartEndpoint.ResumeEndpoint resumeEndpoint(
+				RestartEndpoint restartEndpoint) {
 			return restartEndpoint.getResumeEndpoint();
 		}
 

spring-cloud-context/src/main/java/org/springframework/cloud/context/environment/EnvironmentManager.java

@@ -18,7 +18,6 @@ package org.springframework.cloud.context.environment;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.Set;
 
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.context.ApplicationEventPublisherAware;
@@ -53,8 +52,8 @@ public class EnvironmentManager implements ApplicationEventPublisherAware {
 		MutablePropertySources sources = environment.getPropertySources();
 		if (sources.contains(MANAGER_PROPERTY_SOURCE)) {
 			@SuppressWarnings("unchecked")
-			Map<String, Object> map = (Map<String, Object>) sources.get(
+			Map<String, Object> map = (Map<String, Object>) sources
-					MANAGER_PROPERTY_SOURCE).getSource();
+					.get(MANAGER_PROPERTY_SOURCE).getSource();
 			this.map = map;
 		}
 	}

spring-cloud-context/src/main/java/org/springframework/cloud/endpoint/event/RefreshEvent.java

@@ -7,6 +7,7 @@ import org.springframework.context.ApplicationEvent;
  * Event that triggers a call to {@link RefreshEndpoint#refresh()}
  * @author Spencer Gibb
  */
+@SuppressWarnings("serial")
 public class RefreshEvent extends ApplicationEvent {
 
 	private Object event;

spring-cloud-context/src/test/java/org/springframework/cloud/bootstrap/BootstrapSourcesOrderingTests.java

@@ -2,12 +2,11 @@ package org.springframework.cloud.bootstrap;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.springframework.beans.factory.annotation.Autowired;
+
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.cloud.bootstrap.BootstrapOrderingSpringApplicationJsonIntegrationTests.Application;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.test.context.junit4.SpringRunner;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -17,13 +16,11 @@ import static org.springframework.cloud.bootstrap.TestHigherPriorityBootstrapCon
 @SpringBootTest(classes = Application.class)
 public class BootstrapSourcesOrderingTests {
 
-	@Autowired
-	private ConfigurableEnvironment environment;
-
 	@Test
 	public void sourcesAreOrderedCorrectly() {
 		Class<?> firstConstructedClass = firstToBeCreated.get();
-		assertThat(firstConstructedClass).as("bootstrap sources not ordered correctly").isEqualTo(TestHigherPriorityBootstrapConfiguration.class);
+		assertThat(firstConstructedClass).as("bootstrap sources not ordered correctly")
+				.isEqualTo(TestHigherPriorityBootstrapConfiguration.class);
 	}
 
 	@EnableAutoConfiguration

spring-cloud-context/src/test/java/org/springframework/cloud/bootstrap/encrypt/EnvironmentDecryptApplicationInitializerTests.java

@@ -19,6 +19,7 @@ import java.util.Collections;
 import java.util.Map;
 
 import org.junit.Test;
+
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@@ -65,9 +66,9 @@ public class EnvironmentDecryptApplicationInitializerTests {
 	public void propertySourcesOrderedCorrectly() {
 		ConfigurableApplicationContext context = new AnnotationConfigApplicationContext();
 		addEnvironment(context, "foo: {cipher}bar");
-		context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
+		context.getEnvironment().getPropertySources()
-				"test_override",
+				.addFirst(new MapPropertySource("test_override",
-				Collections.<String, Object> singletonMap("foo", "{cipher}spam")));
+						Collections.<String, Object>singletonMap("foo", "{cipher}spam")));
 		this.listener.initialize(context);
 		assertEquals("spam", context.getEnvironment().getProperty("foo"));
 	}
@@ -98,8 +99,10 @@ public class EnvironmentDecryptApplicationInitializerTests {
 	@SuppressWarnings("unchecked")
 	public void indexedPropertiesCopied() {
 		ConfigurableApplicationContext context = new AnnotationConfigApplicationContext();
-		// tests that collections in another property source don't get copied into "decrypted" property source
+		// tests that collections in another property source don't get copied into
-		addEnvironment(context, "yours[0].someValue: yourFoo", "yours[1].someValue: yourBar");
+		// "decrypted" property source
+		addEnvironment(context, "yours[0].someValue: yourFoo",
+				"yours[1].someValue: yourBar");
 
 		// collection with some encrypted keys and some not encrypted
 		addEnvironment("combinedTest", context.getEnvironment(), "mine[0].someValue: Foo",
@@ -107,27 +110,31 @@ public class EnvironmentDecryptApplicationInitializerTests {
 				"mine[1].someKey: {cipher}Bar1", "nonindexed: nonindexval");
 		this.listener.initialize(context);
 
-		assertEquals("Foo",  context.getEnvironment().getProperty("mine[0].someValue"));
+		assertEquals("Foo", context.getEnvironment().getProperty("mine[0].someValue"));
 		assertEquals("Foo0", context.getEnvironment().getProperty("mine[0].someKey"));
-		assertEquals("Bar",  context.getEnvironment().getProperty("mine[1].someValue"));
+		assertEquals("Bar", context.getEnvironment().getProperty("mine[1].someValue"));
 		assertEquals("Bar1", context.getEnvironment().getProperty("mine[1].someKey"));
-		assertEquals("yourFoo",  context.getEnvironment().getProperty("yours[0].someValue"));
+		assertEquals("yourFoo",
-		assertEquals("yourBar",  context.getEnvironment().getProperty("yours[1].someValue"));
+				context.getEnvironment().getProperty("yours[0].someValue"));
-
+		assertEquals("yourBar",
-		MutablePropertySources propertySources = context.getEnvironment().getPropertySources();
+				context.getEnvironment().getProperty("yours[1].someValue"));
-		PropertySource<Map> decrypted = (PropertySource<Map>) propertySources.get(DECRYPTED_PROPERTY_SOURCE_NAME);
+
-		assertThat("decrypted property source had wrong size", decrypted.getSource().size(), is(4));
+		MutablePropertySources propertySources = context.getEnvironment()
+				.getPropertySources();
+		PropertySource<Map<?, ?>> decrypted = (PropertySource<Map<?, ?>>) propertySources
+				.get(DECRYPTED_PROPERTY_SOURCE_NAME);
+		assertThat("decrypted property source had wrong size",
+				decrypted.getSource().size(), is(4));
 	}
 
 	@Test
 	public void testDecryptNonStandardParent() {
 		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
-		EnvironmentDecryptApplicationInitializer initializer =
+		EnvironmentDecryptApplicationInitializer initializer = new EnvironmentDecryptApplicationInitializer(
-				new EnvironmentDecryptApplicationInitializer(Encryptors.noOpText());
+				Encryptors.noOpText());
 
 		addEnvironment(ctx, "key:{cipher}value");
 
-
 		ApplicationContext ctxParent = mock(ApplicationContext.class);
 		when(ctxParent.getEnvironment()).thenReturn(mock(Environment.class));
 

spring-cloud-context/src/test/java/org/springframework/cloud/context/environment/EnvironmentManagerTest.java

@@ -1,45 +1,45 @@
 package org.springframework.cloud.context.environment;
 
-
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
+
 import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.mock.env.MockEnvironment;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 public class EnvironmentManagerTest {
 
-    @Test
+	@Test
-    public void testCorrectEvents() {
+	public void testCorrectEvents() {
-        MockEnvironment environment = new MockEnvironment();
+		MockEnvironment environment = new MockEnvironment();
-        ApplicationEventPublisher publisher = mock(ApplicationEventPublisher.class);
+		ApplicationEventPublisher publisher = mock(ApplicationEventPublisher.class);
-        EnvironmentManager environmentManager = new EnvironmentManager(environment);
+		EnvironmentManager environmentManager = new EnvironmentManager(environment);
-        environmentManager.setApplicationEventPublisher(publisher);
+		environmentManager.setApplicationEventPublisher(publisher);
-
+
-        environmentManager.setProperty("foo", "bar");
+		environmentManager.setProperty("foo", "bar");
-
+
-        assertThat(environment.getProperty("foo")).isEqualTo("bar");
+		assertThat(environment.getProperty("foo")).isEqualTo("bar");
-        ArgumentCaptor<ApplicationEvent> eventCaptor = ArgumentCaptor.forClass(ApplicationEvent.class);
+		ArgumentCaptor<ApplicationEvent> eventCaptor = ArgumentCaptor
-        verify(publisher, times(1)).publishEvent(eventCaptor.capture());
+				.forClass(ApplicationEvent.class);
-        assertThat(eventCaptor.getValue()).isInstanceOf(EnvironmentChangeEvent.class);
+		verify(publisher, times(1)).publishEvent(eventCaptor.capture());
-        EnvironmentChangeEvent event = (EnvironmentChangeEvent) eventCaptor.getValue();
+		assertThat(eventCaptor.getValue()).isInstanceOf(EnvironmentChangeEvent.class);
-        assertThat(event.getKeys()).containsExactly("foo");
+		EnvironmentChangeEvent event = (EnvironmentChangeEvent) eventCaptor.getValue();
-
+		assertThat(event.getKeys()).containsExactly("foo");
-        reset(publisher);
+
-
+		reset(publisher);
-        environmentManager.reset();
+
-        assertThat(environment.getProperty("foo")).isNull();
+		environmentManager.reset();
-        verify(publisher, times(1)).publishEvent(eventCaptor.capture());
+		assertThat(environment.getProperty("foo")).isNull();
-        assertThat(eventCaptor.getValue()).isInstanceOf(EnvironmentChangeEvent.class);
+		verify(publisher, times(1)).publishEvent(eventCaptor.capture());
-        event = (EnvironmentChangeEvent) eventCaptor.getValue();
+		assertThat(eventCaptor.getValue()).isInstanceOf(EnvironmentChangeEvent.class);
-        assertThat(event.getKeys()).containsExactly("foo");
+		event = (EnvironmentChangeEvent) eventCaptor.getValue();
-    }
+		assertThat(event.getKeys()).containsExactly("foo");
+	}
 
 }

spring-cloud-context/src/test/java/org/springframework/cloud/context/scope/refresh/RefreshScopeListBindingIntegrationTests.java

@@ -22,6 +22,7 @@ import java.util.Map;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
+
 import org.springframework.aop.framework.Advised;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration;
@@ -40,14 +41,12 @@ import org.springframework.core.env.PropertySource;
 import org.springframework.jmx.export.annotation.ManagedResource;
 import org.springframework.test.annotation.DirtiesContext;
 import org.springframework.test.context.junit4.SpringRunner;
-import org.springframework.test.context.junit4.SpringRunner;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 @RunWith(SpringRunner.class)
-@SpringBootTest(classes = TestConfiguration.class,
+@SpringBootTest(classes = TestConfiguration.class, properties = "messages=one,two")
-		properties = "messages=one,two")
 public class RefreshScopeListBindingIntegrationTests {
 
 	@Autowired