Relocate projects to spring-boot-project

Move projects to better reflect the way that Spring Boot is released.

The following projects are under `spring-boot-project`:

  - `spring-boot`
  - `spring-boot-autoconfigure`
  - `spring-boot-tools`
  - `spring-boot-starters`
  - `spring-boot-actuator`
  - `spring-boot-actuator-autoconfigure`
  - `spring-boot-test`
  - `spring-boot-test-autoconfigure`
  - `spring-boot-devtools`
  - `spring-boot-cli`
  - `spring-boot-docs`

See gh-9316

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/DefaultLaunchScriptTests.java

@@ -0,0 +1,242 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      http://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.boot.loader.tools;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import org.springframework.util.FileCopyUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link DefaultLaunchScript}.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ * @author Justin Rosenberg
+ */
+public class DefaultLaunchScriptTests {
+
+	@Rule
+	public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+	@Test
+	public void loadsDefaultScript() throws Exception {
+		DefaultLaunchScript script = new DefaultLaunchScript(null, null);
+		String content = new String(script.toByteArray());
+		assertThat(content).contains("Spring Boot Startup Script");
+	}
+
+	@Test
+	public void logFilenameCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("logFilename");
+	}
+
+	@Test
+	public void pidFilenameCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("pidFilename");
+	}
+
+	@Test
+	public void initInfoProvidesCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("initInfoProvides");
+	}
+
+	@Test
+	public void initInfoRequiredStartCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("initInfoRequiredStart");
+	}
+
+	@Test
+	public void initInfoRequiredStopCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("initInfoRequiredStop");
+	}
+
+	@Test
+	public void initInfoDefaultStartCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("initInfoDefaultStart");
+	}
+
+	@Test
+	public void initInfoDefaultStopCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("initInfoDefaultStop");
+	}
+
+	@Test
+	public void initInfoShortDescriptionCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("initInfoShortDescription");
+	}
+
+	@Test
+	public void initInfoDescriptionCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("initInfoDescription");
+	}
+
+	@Test
+	public void initInfoChkconfigCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("initInfoChkconfig");
+	}
+
+	@Test
+	public void modeCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("mode");
+	}
+
+	@Test
+	public void useStartStopDaemonCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("useStartStopDaemon");
+	}
+
+	@Test
+	public void logFolderCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("logFolder");
+	}
+
+	@Test
+	public void pidFolderCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("pidFolder");
+	}
+
+	@Test
+	public void confFolderCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("confFolder");
+	}
+
+	@Test
+	public void stopWaitTimeCanBeReplaced() throws Exception {
+		assertThatPlaceholderCanBeReplaced("stopWaitTime");
+	}
+
+	@Test
+	public void inlinedConfScriptFileLoad() throws IOException {
+		DefaultLaunchScript script = new DefaultLaunchScript(null,
+				createProperties("inlinedConfScript:src/test/resources/example.script"));
+		String content = new String(script.toByteArray());
+		assertThat(content).contains("FOO=BAR");
+	}
+
+	@Test
+	public void defaultForUseStartStopDaemonIsTrue() throws Exception {
+		DefaultLaunchScript script = new DefaultLaunchScript(null, null);
+		String content = new String(script.toByteArray());
+		assertThat(content).contains("USE_START_STOP_DAEMON=\"true\"");
+	}
+
+	@Test
+	public void defaultForModeIsAuto() throws Exception {
+		DefaultLaunchScript script = new DefaultLaunchScript(null, null);
+		String content = new String(script.toByteArray());
+		assertThat(content).contains("MODE=\"auto\"");
+	}
+
+	@Test
+	public void defaultForStopWaitTimeIs60() throws Exception {
+		DefaultLaunchScript script = new DefaultLaunchScript(null, null);
+		String content = new String(script.toByteArray());
+		assertThat(content).contains("STOP_WAIT_TIME=\"60\"");
+	}
+
+	@Test
+	public void loadFromFile() throws Exception {
+		File file = this.temporaryFolder.newFile();
+		FileCopyUtils.copy("ABC".getBytes(), file);
+		DefaultLaunchScript script = new DefaultLaunchScript(file, null);
+		String content = new String(script.toByteArray());
+		assertThat(content).isEqualTo("ABC");
+	}
+
+	@Test
+	public void expandVariables() throws Exception {
+		File file = this.temporaryFolder.newFile();
+		FileCopyUtils.copy("h{{a}}ll{{b}}".getBytes(), file);
+		DefaultLaunchScript script = new DefaultLaunchScript(file,
+				createProperties("a:e", "b:o"));
+		String content = new String(script.toByteArray());
+		assertThat(content).isEqualTo("hello");
+	}
+
+	@Test
+	public void expandVariablesMultiLine() throws Exception {
+		File file = this.temporaryFolder.newFile();
+		FileCopyUtils.copy("h{{a}}l\nl{{b}}".getBytes(), file);
+		DefaultLaunchScript script = new DefaultLaunchScript(file,
+				createProperties("a:e", "b:o"));
+		String content = new String(script.toByteArray());
+		assertThat(content).isEqualTo("hel\nlo");
+	}
+
+	@Test
+	public void expandVariablesWithDefaults() throws Exception {
+		File file = this.temporaryFolder.newFile();
+		FileCopyUtils.copy("h{{a:e}}ll{{b:o}}".getBytes(), file);
+		DefaultLaunchScript script = new DefaultLaunchScript(file, null);
+		String content = new String(script.toByteArray());
+		assertThat(content).isEqualTo("hello");
+	}
+
+	@Test
+	public void expandVariablesCanDefaultToBlank() throws Exception {
+		File file = this.temporaryFolder.newFile();
+		FileCopyUtils.copy("s{{p:}}{{r:}}ing".getBytes(), file);
+		DefaultLaunchScript script = new DefaultLaunchScript(file, null);
+		String content = new String(script.toByteArray());
+		assertThat(content).isEqualTo("sing");
+	}
+
+	@Test
+	public void expandVariablesWithDefaultsOverride() throws Exception {
+		File file = this.temporaryFolder.newFile();
+		FileCopyUtils.copy("h{{a:e}}ll{{b:o}}".getBytes(), file);
+		DefaultLaunchScript script = new DefaultLaunchScript(file,
+				createProperties("a:a"));
+		String content = new String(script.toByteArray());
+		assertThat(content).isEqualTo("hallo");
+	}
+
+	@Test
+	public void expandVariablesMissingAreUnchanged() throws Exception {
+		File file = this.temporaryFolder.newFile();
+		FileCopyUtils.copy("h{{a}}ll{{b}}".getBytes(), file);
+		DefaultLaunchScript script = new DefaultLaunchScript(file, null);
+		String content = new String(script.toByteArray());
+		assertThat(content).isEqualTo("h{{a}}ll{{b}}");
+	}
+
+	private void assertThatPlaceholderCanBeReplaced(String placeholder) throws Exception {
+		DefaultLaunchScript script = new DefaultLaunchScript(null,
+				createProperties(placeholder + ":__test__"));
+		String content = new String(script.toByteArray());
+		assertThat(content).contains("__test__");
+	}
+
+	private Map<?, ?> createProperties(String... pairs) {
+		Map<Object, Object> properties = new HashMap<>();
+		for (String pair : pairs) {
+			String[] keyValue = pair.split(":");
+			properties.put(keyValue[0], keyValue[1]);
+		}
+		return properties;
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/FileUtilsTests.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      http://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.boot.loader.tools;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import org.springframework.util.FileSystemUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link FileUtils}.
+ *
+ * @author Dave Syer
+ * @author Phillip Webb
+ */
+public class FileUtilsTests {
+
+	@Rule
+	public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+	private File outputDirectory;
+
+	private File originDirectory;
+
+	@Before
+	public void init() {
+		this.outputDirectory = new File("target/test/remove");
+		this.originDirectory = new File("target/test/keep");
+		FileSystemUtils.deleteRecursively(this.outputDirectory);
+		FileSystemUtils.deleteRecursively(this.originDirectory);
+		this.outputDirectory.mkdirs();
+		this.originDirectory.mkdirs();
+	}
+
+	@Test
+	public void simpleDuplicateFile() throws IOException {
+		File file = new File(this.outputDirectory, "logback.xml");
+		file.createNewFile();
+		new File(this.originDirectory, "logback.xml").createNewFile();
+		FileUtils.removeDuplicatesFromOutputDirectory(this.outputDirectory,
+				this.originDirectory);
+		assertThat(file.exists()).isFalse();
+	}
+
+	@Test
+	public void nestedDuplicateFile() throws IOException {
+		assertThat(new File(this.outputDirectory, "sub").mkdirs()).isTrue();
+		assertThat(new File(this.originDirectory, "sub").mkdirs()).isTrue();
+		File file = new File(this.outputDirectory, "sub/logback.xml");
+		file.createNewFile();
+		new File(this.originDirectory, "sub/logback.xml").createNewFile();
+		FileUtils.removeDuplicatesFromOutputDirectory(this.outputDirectory,
+				this.originDirectory);
+		assertThat(file.exists()).isFalse();
+	}
+
+	@Test
+	public void nestedNonDuplicateFile() throws IOException {
+		assertThat(new File(this.outputDirectory, "sub").mkdirs()).isTrue();
+		assertThat(new File(this.originDirectory, "sub").mkdirs()).isTrue();
+		File file = new File(this.outputDirectory, "sub/logback.xml");
+		file.createNewFile();
+		new File(this.originDirectory, "sub/different.xml").createNewFile();
+		FileUtils.removeDuplicatesFromOutputDirectory(this.outputDirectory,
+				this.originDirectory);
+		assertThat(file.exists()).isTrue();
+	}
+
+	@Test
+	public void nonDuplicateFile() throws IOException {
+		File file = new File(this.outputDirectory, "logback.xml");
+		file.createNewFile();
+		new File(this.originDirectory, "different.xml").createNewFile();
+		FileUtils.removeDuplicatesFromOutputDirectory(this.outputDirectory,
+				this.originDirectory);
+		assertThat(file.exists()).isTrue();
+	}
+
+	@Test
+	public void hash() throws Exception {
+		File file = this.temporaryFolder.newFile();
+		try (OutputStream outputStream = new FileOutputStream(file)) {
+			outputStream.write(new byte[] { 1, 2, 3 });
+		}
+		assertThat(FileUtils.sha1Hash(file))
+				.isEqualTo("7037807198c22a7d2b0807371d763779a84fdfcf");
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/LayoutsTests.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      http://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.boot.loader.tools;
+
+import java.io.File;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link Layouts}.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ */
+public class LayoutsTests {
+
+	@Rule
+	public ExpectedException thrown = ExpectedException.none();
+
+	@Test
+	public void jarFile() throws Exception {
+		assertThat(Layouts.forFile(new File("test.jar"))).isInstanceOf(Layouts.Jar.class);
+		assertThat(Layouts.forFile(new File("test.JAR"))).isInstanceOf(Layouts.Jar.class);
+		assertThat(Layouts.forFile(new File("test.jAr"))).isInstanceOf(Layouts.Jar.class);
+		assertThat(Layouts.forFile(new File("te.st.jar")))
+				.isInstanceOf(Layouts.Jar.class);
+	}
+
+	@Test
+	public void warFile() throws Exception {
+		assertThat(Layouts.forFile(new File("test.war"))).isInstanceOf(Layouts.War.class);
+		assertThat(Layouts.forFile(new File("test.WAR"))).isInstanceOf(Layouts.War.class);
+		assertThat(Layouts.forFile(new File("test.wAr"))).isInstanceOf(Layouts.War.class);
+		assertThat(Layouts.forFile(new File("te.st.war")))
+				.isInstanceOf(Layouts.War.class);
+	}
+
+	@Test
+	public void unknownFile() throws Exception {
+		this.thrown.expect(IllegalStateException.class);
+		this.thrown.expectMessage("Unable to deduce layout for 'test.txt'");
+		Layouts.forFile(new File("test.txt"));
+	}
+
+	@Test
+	public void jarLayout() throws Exception {
+		Layout layout = new Layouts.Jar();
+		assertThat(layout.getLibraryDestination("lib.jar", LibraryScope.COMPILE))
+				.isEqualTo("BOOT-INF/lib/");
+		assertThat(layout.getLibraryDestination("lib.jar", LibraryScope.CUSTOM))
+				.isEqualTo("BOOT-INF/lib/");
+		assertThat(layout.getLibraryDestination("lib.jar", LibraryScope.PROVIDED))
+				.isEqualTo("BOOT-INF/lib/");
+		assertThat(layout.getLibraryDestination("lib.jar", LibraryScope.RUNTIME))
+				.isEqualTo("BOOT-INF/lib/");
+	}
+
+	@Test
+	public void warLayout() throws Exception {
+		Layout layout = new Layouts.War();
+		assertThat(layout.getLibraryDestination("lib.jar", LibraryScope.COMPILE))
+				.isEqualTo("WEB-INF/lib/");
+		assertThat(layout.getLibraryDestination("lib.jar", LibraryScope.CUSTOM))
+				.isEqualTo("WEB-INF/lib/");
+		assertThat(layout.getLibraryDestination("lib.jar", LibraryScope.PROVIDED))
+				.isEqualTo("WEB-INF/lib-provided/");
+		assertThat(layout.getLibraryDestination("lib.jar", LibraryScope.RUNTIME))
+				.isEqualTo("WEB-INF/lib/");
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/MainClassFinderTests.java

@@ -0,0 +1,195 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      http://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.boot.loader.tools;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.rules.TemporaryFolder;
+
+import org.springframework.boot.loader.tools.MainClassFinder.MainClass;
+import org.springframework.boot.loader.tools.MainClassFinder.MainClassCallback;
+import org.springframework.boot.loader.tools.sample.AnnotatedClassWithMainMethod;
+import org.springframework.boot.loader.tools.sample.ClassWithMainMethod;
+import org.springframework.boot.loader.tools.sample.ClassWithoutMainMethod;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link MainClassFinder}.
+ *
+ * @author Phillip Webb
+ */
+public class MainClassFinderTests {
+
+	@Rule
+	public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+	@Rule
+	public ExpectedException thrown = ExpectedException.none();
+
+	private TestJarFile testJarFile;
+
+	@Before
+	public void setup() throws IOException {
+		this.testJarFile = new TestJarFile(this.temporaryFolder);
+	}
+
+	@Test
+	public void findMainClassInJar() throws Exception {
+		this.testJarFile.addClass("B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("A.class", ClassWithoutMainMethod.class);
+		String actual = MainClassFinder.findMainClass(this.testJarFile.getJarFile(), "");
+		assertThat(actual).isEqualTo("B");
+	}
+
+	@Test
+	public void findMainClassInJarSubFolder() throws Exception {
+		this.testJarFile.addClass("a/b/c/D.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithoutMainMethod.class);
+		this.testJarFile.addClass("a/b/F.class", ClassWithoutMainMethod.class);
+		String actual = MainClassFinder.findMainClass(this.testJarFile.getJarFile(), "");
+		assertThat(actual).isEqualTo("a.b.c.D");
+	}
+
+	@Test
+	public void usesBreadthFirstJarSearch() throws Exception {
+		this.testJarFile.addClass("a/B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithMainMethod.class);
+		String actual = MainClassFinder.findMainClass(this.testJarFile.getJarFile(), "");
+		assertThat(actual).isEqualTo("a.B");
+	}
+
+	@Test
+	public void findSingleJarSearch() throws Exception {
+		this.testJarFile.addClass("a/B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithMainMethod.class);
+		this.thrown.expect(IllegalStateException.class);
+		this.thrown.expectMessage("Unable to find a single main class "
+				+ "from the following candidates [a.B, a.b.c.E]");
+		MainClassFinder.findSingleMainClass(this.testJarFile.getJarFile(), "");
+	}
+
+	@Test
+	public void findSingleJarSearchPrefersAnnotatedMainClass() throws Exception {
+		this.testJarFile.addClass("a/B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", AnnotatedClassWithMainMethod.class);
+		String mainClass = MainClassFinder.findSingleMainClass(
+				this.testJarFile.getJarFile(), "",
+				"org.springframework.boot.loader.tools.sample.SomeApplication");
+		assertThat(mainClass).isEqualTo("a.b.c.E");
+	}
+
+	@Test
+	public void findMainClassInJarSubLocation() throws Exception {
+		this.testJarFile.addClass("a/B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithMainMethod.class);
+		String actual = MainClassFinder.findMainClass(this.testJarFile.getJarFile(),
+				"a/");
+		assertThat(actual).isEqualTo("B");
+
+	}
+
+	@Test
+	public void findMainClassInFolder() throws Exception {
+		this.testJarFile.addClass("B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("A.class", ClassWithoutMainMethod.class);
+		String actual = MainClassFinder.findMainClass(this.testJarFile.getJarSource());
+		assertThat(actual).isEqualTo("B");
+	}
+
+	@Test
+	public void findMainClassInSubFolder() throws Exception {
+		this.testJarFile.addClass("a/b/c/D.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithoutMainMethod.class);
+		this.testJarFile.addClass("a/b/F.class", ClassWithoutMainMethod.class);
+		String actual = MainClassFinder.findMainClass(this.testJarFile.getJarSource());
+		assertThat(actual).isEqualTo("a.b.c.D");
+	}
+
+	@Test
+	public void usesBreadthFirstFolderSearch() throws Exception {
+		this.testJarFile.addClass("a/B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithMainMethod.class);
+		String actual = MainClassFinder.findMainClass(this.testJarFile.getJarSource());
+		assertThat(actual).isEqualTo("a.B");
+	}
+
+	@Test
+	public void findSingleFolderSearch() throws Exception {
+		this.testJarFile.addClass("a/B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithMainMethod.class);
+		this.thrown.expect(IllegalStateException.class);
+		this.thrown.expectMessage("Unable to find a single main class "
+				+ "from the following candidates [a.B, a.b.c.E]");
+		MainClassFinder.findSingleMainClass(this.testJarFile.getJarSource());
+	}
+
+	@Test
+	public void findSingleFolderSearchPrefersAnnotatedMainClass() throws Exception {
+		this.testJarFile.addClass("a/B.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", AnnotatedClassWithMainMethod.class);
+		String mainClass = MainClassFinder.findSingleMainClass(
+				this.testJarFile.getJarSource(),
+				"org.springframework.boot.loader.tools.sample.SomeApplication");
+		assertThat(mainClass).isEqualTo("a.b.c.E");
+	}
+
+	@Test
+	public void doWithFolderMainMethods() throws Exception {
+		this.testJarFile.addClass("a/b/c/D.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithoutMainMethod.class);
+		this.testJarFile.addClass("a/b/F.class", ClassWithoutMainMethod.class);
+		this.testJarFile.addClass("a/b/G.class", ClassWithMainMethod.class);
+		ClassNameCollector callback = new ClassNameCollector();
+		MainClassFinder.doWithMainClasses(this.testJarFile.getJarSource(), callback);
+		assertThat(callback.getClassNames().toString()).isEqualTo("[a.b.G, a.b.c.D]");
+	}
+
+	@Test
+	public void doWithJarMainMethods() throws Exception {
+		this.testJarFile.addClass("a/b/c/D.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/c/E.class", ClassWithoutMainMethod.class);
+		this.testJarFile.addClass("a/b/F.class", ClassWithoutMainMethod.class);
+		this.testJarFile.addClass("a/b/G.class", ClassWithMainMethod.class);
+		ClassNameCollector callback = new ClassNameCollector();
+		MainClassFinder.doWithMainClasses(this.testJarFile.getJarFile(), null, callback);
+		assertThat(callback.getClassNames().toString()).isEqualTo("[a.b.G, a.b.c.D]");
+	}
+
+	private static class ClassNameCollector implements MainClassCallback<Object> {
+
+		private final List<String> classNames = new ArrayList<>();
+
+		@Override
+		public Object doWith(MainClass mainClass) {
+			this.classNames.add(mainClass.getName());
+			return null;
+		}
+
+		public List<String> getClassNames() {
+			return this.classNames;
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/RepackagerTests.java

@@ -0,0 +1,632 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      http://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.boot.loader.tools;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.attribute.PosixFilePermission;
+import java.util.Calendar;
+import java.util.Enumeration;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
+import java.util.zip.ZipEntry;
+
+import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
+import org.apache.commons.compress.archivers.zip.ZipFile;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.rules.TemporaryFolder;
+import org.zeroturnaround.zip.ZipUtil;
+
+import org.springframework.boot.loader.tools.sample.ClassWithMainMethod;
+import org.springframework.boot.loader.tools.sample.ClassWithoutMainMethod;
+import org.springframework.util.FileCopyUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Tests for {@link Repackager}.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ */
+public class RepackagerTests {
+
+	private static final Libraries NO_LIBRARIES = (callback) -> {
+	};
+
+	private static final long JAN_1_1980;
+
+	private static final long JAN_1_1985;
+
+	static {
+		Calendar calendar = Calendar.getInstance();
+		calendar.set(1980, 0, 1, 0, 0, 0);
+		calendar.set(Calendar.MILLISECOND, 0);
+		JAN_1_1980 = calendar.getTime().getTime();
+		calendar.set(Calendar.YEAR, 1985);
+		JAN_1_1985 = calendar.getTime().getTime();
+	}
+
+	@Rule
+	public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+	@Rule
+	public ExpectedException thrown = ExpectedException.none();
+
+	private TestJarFile testJarFile;
+
+	@Before
+	public void setup() throws IOException {
+		this.testJarFile = new TestJarFile(this.temporaryFolder);
+	}
+
+	@Test
+	public void nullSource() throws Exception {
+		this.thrown.expect(IllegalArgumentException.class);
+		new Repackager(null);
+	}
+
+	@Test
+	public void missingSource() throws Exception {
+		this.thrown.expect(IllegalArgumentException.class);
+		new Repackager(new File("missing"));
+	}
+
+	@Test
+	public void directorySource() throws Exception {
+		this.thrown.expect(IllegalArgumentException.class);
+		new Repackager(this.temporaryFolder.getRoot());
+	}
+
+	@Test
+	public void specificMainClass() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.setMainClass("a.b.C");
+		repackager.repackage(NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes().getValue("Main-Class"))
+				.isEqualTo("org.springframework.boot.loader.JarLauncher");
+		assertThat(actualManifest.getMainAttributes().getValue("Start-Class"))
+				.isEqualTo("a.b.C");
+		assertThat(hasLauncherClasses(file)).isTrue();
+	}
+
+	@Test
+	public void mainClassFromManifest() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		Manifest manifest = new Manifest();
+		manifest.getMainAttributes().putValue("Manifest-Version", "1.0");
+		manifest.getMainAttributes().putValue("Main-Class", "a.b.C");
+		this.testJarFile.addManifest(manifest);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.repackage(NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes().getValue("Main-Class"))
+				.isEqualTo("org.springframework.boot.loader.JarLauncher");
+		assertThat(actualManifest.getMainAttributes().getValue("Start-Class"))
+				.isEqualTo("a.b.C");
+		assertThat(hasLauncherClasses(file)).isTrue();
+	}
+
+	@Test
+	public void mainClassFound() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.repackage(NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes().getValue("Main-Class"))
+				.isEqualTo("org.springframework.boot.loader.JarLauncher");
+		assertThat(actualManifest.getMainAttributes().getValue("Start-Class"))
+				.isEqualTo("a.b.C");
+		assertThat(hasLauncherClasses(file)).isTrue();
+	}
+
+	@Test
+	public void jarIsOnlyRepackagedOnce() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.repackage(NO_LIBRARIES);
+		repackager.repackage(NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes().getValue("Main-Class"))
+				.isEqualTo("org.springframework.boot.loader.JarLauncher");
+		assertThat(actualManifest.getMainAttributes().getValue("Start-Class"))
+				.isEqualTo("a.b.C");
+		assertThat(hasLauncherClasses(file)).isTrue();
+	}
+
+	@Test
+	public void multipleMainClassFound() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		this.testJarFile.addClass("a/b/D.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		this.thrown.expect(IllegalStateException.class);
+		this.thrown.expectMessage("Unable to find a single main class "
+				+ "from the following candidates [a.b.C, a.b.D]");
+		repackager.repackage(NO_LIBRARIES);
+	}
+
+	@Test
+	public void noMainClass() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		this.thrown.expect(IllegalStateException.class);
+		this.thrown.expectMessage("Unable to find main class");
+		new Repackager(this.testJarFile.getFile()).repackage(NO_LIBRARIES);
+	}
+
+	@Test
+	public void noMainClassAndLayoutIsNone() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.setLayout(new Layouts.None());
+		repackager.repackage(file, NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes().getValue("Main-Class"))
+				.isEqualTo("a.b.C");
+		assertThat(hasLauncherClasses(file)).isFalse();
+	}
+
+	@Test
+	public void noMainClassAndLayoutIsNoneWithNoMain() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.setLayout(new Layouts.None());
+		repackager.repackage(file, NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes().getValue("Main-Class"))
+				.isEqualTo(null);
+		assertThat(hasLauncherClasses(file)).isFalse();
+	}
+
+	@Test
+	public void sameSourceAndDestinationWithBackup() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.repackage(NO_LIBRARIES);
+		assertThat(new File(file.getParent(), file.getName() + ".original")).exists();
+		assertThat(hasLauncherClasses(file)).isTrue();
+	}
+
+	@Test
+	public void sameSourceAndDestinationWithoutBackup() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.setBackupSource(false);
+		repackager.repackage(NO_LIBRARIES);
+		assertThat(new File(file.getParent(), file.getName() + ".original"))
+				.doesNotExist();
+		assertThat(hasLauncherClasses(file)).isTrue();
+	}
+
+	@Test
+	public void differentDestination() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File source = this.testJarFile.getFile();
+		File dest = this.temporaryFolder.newFile("different.jar");
+		Repackager repackager = new Repackager(source);
+		repackager.repackage(dest, NO_LIBRARIES);
+		assertThat(new File(source.getParent(), source.getName() + ".original"))
+				.doesNotExist();
+		assertThat(hasLauncherClasses(source)).isFalse();
+		assertThat(hasLauncherClasses(dest)).isTrue();
+	}
+
+	@Test
+	public void nullDestination() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		Repackager repackager = new Repackager(this.testJarFile.getFile());
+		this.thrown.expect(IllegalArgumentException.class);
+		this.thrown.expectMessage("Invalid destination");
+		repackager.repackage(null, NO_LIBRARIES);
+	}
+
+	@Test
+	public void destinationIsDirectory() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		Repackager repackager = new Repackager(this.testJarFile.getFile());
+		this.thrown.expect(IllegalArgumentException.class);
+		this.thrown.expectMessage("Invalid destination");
+		repackager.repackage(this.temporaryFolder.getRoot(), NO_LIBRARIES);
+	}
+
+	@Test
+	public void overwriteDestination() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		Repackager repackager = new Repackager(this.testJarFile.getFile());
+		File dest = this.temporaryFolder.newFile("dest.jar");
+		dest.createNewFile();
+		repackager.repackage(dest, NO_LIBRARIES);
+		assertThat(hasLauncherClasses(dest)).isTrue();
+	}
+
+	@Test
+	public void nullLibraries() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		this.thrown.expect(IllegalArgumentException.class);
+		this.thrown.expectMessage("Libraries must not be null");
+		repackager.repackage(file, null);
+	}
+
+	@Test
+	public void libraries() throws Exception {
+		TestJarFile libJar = new TestJarFile(this.temporaryFolder);
+		libJar.addClass("a/b/C.class", ClassWithoutMainMethod.class, JAN_1_1985);
+		final File libJarFile = libJar.getFile();
+		final File libJarFileToUnpack = libJar.getFile();
+		final File libNonJarFile = this.temporaryFolder.newFile();
+		FileCopyUtils.copy(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }, libNonJarFile);
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		this.testJarFile.addFile("BOOT-INF/lib/" + libJarFileToUnpack.getName(),
+				libJarFileToUnpack);
+		File file = this.testJarFile.getFile();
+		libJarFile.setLastModified(JAN_1_1980);
+		Repackager repackager = new Repackager(file);
+		repackager.repackage((callback) -> {
+			callback.library(new Library(libJarFile, LibraryScope.COMPILE));
+			callback.library(new Library(libJarFileToUnpack, LibraryScope.COMPILE, true));
+			callback.library(new Library(libNonJarFile, LibraryScope.COMPILE));
+		});
+		assertThat(hasEntry(file, "BOOT-INF/lib/" + libJarFile.getName())).isTrue();
+		assertThat(hasEntry(file, "BOOT-INF/lib/" + libJarFileToUnpack.getName()))
+				.isTrue();
+		assertThat(hasEntry(file, "BOOT-INF/lib/" + libNonJarFile.getName())).isFalse();
+		JarEntry entry = getEntry(file, "BOOT-INF/lib/" + libJarFile.getName());
+		assertThat(entry.getTime()).isEqualTo(JAN_1_1985);
+		entry = getEntry(file, "BOOT-INF/lib/" + libJarFileToUnpack.getName());
+		assertThat(entry.getComment()).startsWith("UNPACK:");
+		assertThat(entry.getComment().length()).isEqualTo(47);
+	}
+
+	@Test
+	public void duplicateLibraries() throws Exception {
+		TestJarFile libJar = new TestJarFile(this.temporaryFolder);
+		libJar.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		final File libJarFile = libJar.getFile();
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		this.thrown.expect(IllegalStateException.class);
+		this.thrown.expectMessage("Duplicate library");
+		repackager.repackage((callback) -> {
+			callback.library(new Library(libJarFile, LibraryScope.COMPILE, false));
+			callback.library(new Library(libJarFile, LibraryScope.COMPILE, false));
+		});
+	}
+
+	@Test
+	public void customLayout() throws Exception {
+		TestJarFile libJar = new TestJarFile(this.temporaryFolder);
+		libJar.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		final File libJarFile = libJar.getFile();
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		Layout layout = mock(Layout.class);
+		final LibraryScope scope = mock(LibraryScope.class);
+		given(layout.getLauncherClassName()).willReturn("testLauncher");
+		given(layout.getLibraryDestination(anyString(), eq(scope))).willReturn("test/");
+		given(layout.getLibraryDestination(anyString(), eq(LibraryScope.COMPILE)))
+				.willReturn("test-lib/");
+		repackager.setLayout(layout);
+		repackager.repackage(
+				(callback) -> callback.library(new Library(libJarFile, scope)));
+		assertThat(hasEntry(file, "test/" + libJarFile.getName())).isTrue();
+		assertThat(getManifest(file).getMainAttributes().getValue("Spring-Boot-Lib"))
+				.isEqualTo("test-lib/");
+		assertThat(getManifest(file).getMainAttributes().getValue("Main-Class"))
+				.isEqualTo("testLauncher");
+	}
+
+	@Test
+	public void customLayoutNoBootLib() throws Exception {
+		TestJarFile libJar = new TestJarFile(this.temporaryFolder);
+		libJar.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		final File libJarFile = libJar.getFile();
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		Layout layout = mock(Layout.class);
+		final LibraryScope scope = mock(LibraryScope.class);
+		given(layout.getLauncherClassName()).willReturn("testLauncher");
+		repackager.setLayout(layout);
+		repackager.repackage(
+				(callback) -> callback.library(new Library(libJarFile, scope)));
+		assertThat(getManifest(file).getMainAttributes().getValue("Spring-Boot-Lib"))
+				.isNull();
+		assertThat(getManifest(file).getMainAttributes().getValue("Main-Class"))
+				.isEqualTo("testLauncher");
+	}
+
+	@Test
+	public void springBootVersion() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.repackage(NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes())
+				.containsKey(new Attributes.Name("Spring-Boot-Version"));
+	}
+
+	@Test
+	public void executableJarLayoutAttributes() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.repackage(NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes())
+				.containsEntry(new Attributes.Name("Spring-Boot-Lib"), "BOOT-INF/lib/");
+		assertThat(actualManifest.getMainAttributes()).containsEntry(
+				new Attributes.Name("Spring-Boot-Classes"), "BOOT-INF/classes/");
+	}
+
+	@Test
+	public void executableWarLayoutAttributes() throws Exception {
+		this.testJarFile.addClass("WEB-INF/classes/a/b/C.class",
+				ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile("war");
+		Repackager repackager = new Repackager(file);
+		repackager.repackage(NO_LIBRARIES);
+		Manifest actualManifest = getManifest(file);
+		assertThat(actualManifest.getMainAttributes())
+				.containsEntry(new Attributes.Name("Spring-Boot-Lib"), "WEB-INF/lib/");
+		assertThat(actualManifest.getMainAttributes()).containsEntry(
+				new Attributes.Name("Spring-Boot-Classes"), "WEB-INF/classes/");
+	}
+
+	@Test
+	public void nullCustomLayout() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		Repackager repackager = new Repackager(this.testJarFile.getFile());
+		this.thrown.expect(IllegalArgumentException.class);
+		this.thrown.expectMessage("Layout must not be null");
+		repackager.setLayout(null);
+	}
+
+	@Test
+	public void dontRecompressZips() throws Exception {
+		TestJarFile nested = new TestJarFile(this.temporaryFolder);
+		nested.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		File nestedFile = nested.getFile();
+		this.testJarFile.addFile("test/nested.jar", nestedFile);
+		this.testJarFile.addClass("A.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.repackage((callback) -> callback
+				.library(new Library(nestedFile, LibraryScope.COMPILE)));
+
+		try (JarFile jarFile = new JarFile(file)) {
+			assertThat(
+					jarFile.getEntry("BOOT-INF/lib/" + nestedFile.getName()).getMethod())
+							.isEqualTo(ZipEntry.STORED);
+			assertThat(jarFile.getEntry("BOOT-INF/classes/test/nested.jar").getMethod())
+					.isEqualTo(ZipEntry.STORED);
+		}
+	}
+
+	@Test
+	public void addLauncherScript() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File source = this.testJarFile.getFile();
+		File dest = this.temporaryFolder.newFile("dest.jar");
+		Repackager repackager = new Repackager(source);
+		LaunchScript script = new MockLauncherScript("ABC");
+		repackager.repackage(dest, NO_LIBRARIES, script);
+		byte[] bytes = FileCopyUtils.copyToByteArray(dest);
+		assertThat(new String(bytes)).startsWith("ABC");
+		assertThat(hasLauncherClasses(source)).isFalse();
+		assertThat(hasLauncherClasses(dest)).isTrue();
+		try {
+			assertThat(Files.getPosixFilePermissions(dest.toPath()))
+					.contains(PosixFilePermission.OWNER_EXECUTE);
+		}
+		catch (UnsupportedOperationException ex) {
+			// Probably running the test on Windows
+		}
+	}
+
+	@Test
+	public void unpackLibrariesTakePrecedenceOverExistingSourceEntries()
+			throws Exception {
+		TestJarFile nested = new TestJarFile(this.temporaryFolder);
+		nested.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		File nestedFile = nested.getFile();
+		String name = "BOOT-INF/lib/" + nestedFile.getName();
+		this.testJarFile.addFile(name, nested.getFile());
+		this.testJarFile.addClass("A.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		repackager.repackage((callback) -> callback
+				.library(new Library(nestedFile, LibraryScope.COMPILE, true)));
+		try (JarFile jarFile = new JarFile(file)) {
+			assertThat(jarFile.getEntry(name).getComment()).startsWith("UNPACK:");
+		}
+	}
+
+	@Test
+	public void existingSourceEntriesTakePrecedenceOverStandardLibraries()
+			throws Exception {
+		TestJarFile nested = new TestJarFile(this.temporaryFolder);
+		nested.addClass("a/b/C.class", ClassWithoutMainMethod.class);
+		File nestedFile = nested.getFile();
+		this.testJarFile.addFile("BOOT-INF/lib/" + nestedFile.getName(),
+				nested.getFile());
+		this.testJarFile.addClass("A.class", ClassWithMainMethod.class);
+		File file = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(file);
+		long sourceLength = nestedFile.length();
+		repackager.repackage((callback) -> {
+			nestedFile.delete();
+			File toZip = RepackagerTests.this.temporaryFolder.newFile();
+			ZipUtil.packEntry(toZip, nestedFile);
+			callback.library(new Library(nestedFile, LibraryScope.COMPILE));
+		});
+		try (JarFile jarFile = new JarFile(file)) {
+			assertThat(jarFile.getEntry("BOOT-INF/lib/" + nestedFile.getName()).getSize())
+					.isEqualTo(sourceLength);
+		}
+	}
+
+	@Test
+	public void metaInfIndexListIsRemovedFromRepackagedJar() throws Exception {
+		this.testJarFile.addClass("A.class", ClassWithMainMethod.class);
+		this.testJarFile.addFile("META-INF/INDEX.LIST",
+				this.temporaryFolder.newFile("INDEX.LIST"));
+		File source = this.testJarFile.getFile();
+		File dest = this.temporaryFolder.newFile("dest.jar");
+		Repackager repackager = new Repackager(source);
+		repackager.repackage(dest, NO_LIBRARIES);
+		try (JarFile jarFile = new JarFile(dest)) {
+			assertThat(jarFile.getEntry("META-INF/INDEX.LIST")).isNull();
+		}
+	}
+
+	@Test
+	public void customLayoutFactoryWithoutLayout() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File source = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(source, new TestLayoutFactory());
+		repackager.repackage(NO_LIBRARIES);
+		JarFile jarFile = new JarFile(source);
+		assertThat(jarFile.getEntry("test")).isNotNull();
+		jarFile.close();
+	}
+
+	@Test
+	public void customLayoutFactoryWithLayout() throws Exception {
+		this.testJarFile.addClass("a/b/C.class", ClassWithMainMethod.class);
+		File source = this.testJarFile.getFile();
+		Repackager repackager = new Repackager(source, new TestLayoutFactory());
+		repackager.setLayout(new Layouts.Jar());
+		repackager.repackage(NO_LIBRARIES);
+		JarFile jarFile = new JarFile(source);
+		assertThat(jarFile.getEntry("test")).isNull();
+		jarFile.close();
+	}
+
+	@Test
+	public void metaInfAopXmlIsMovedBeneathBootInfClassesWhenRepackaged()
+			throws Exception {
+		this.testJarFile.addClass("A.class", ClassWithMainMethod.class);
+		this.testJarFile.addFile("META-INF/aop.xml",
+				this.temporaryFolder.newFile("aop.xml"));
+		File source = this.testJarFile.getFile();
+		File dest = this.temporaryFolder.newFile("dest.jar");
+		Repackager repackager = new Repackager(source);
+		repackager.repackage(dest, NO_LIBRARIES);
+		try (JarFile jarFile = new JarFile(dest)) {
+			assertThat(jarFile.getEntry("META-INF/aop.xml")).isNull();
+			assertThat(jarFile.getEntry("BOOT-INF/classes/META-INF/aop.xml")).isNotNull();
+		}
+	}
+
+	@Test
+	public void allEntriesUseUnixPlatformAndUtf8NameEncoding() throws IOException {
+		this.testJarFile.addClass("A.class", ClassWithMainMethod.class);
+		File source = this.testJarFile.getFile();
+		File dest = this.temporaryFolder.newFile("dest.jar");
+		Repackager repackager = new Repackager(source);
+		repackager.repackage(dest, NO_LIBRARIES);
+		try (ZipFile zip = new ZipFile(dest)) {
+			Enumeration<ZipArchiveEntry> entries = zip.getEntries();
+			while (entries.hasMoreElements()) {
+				ZipArchiveEntry entry = entries.nextElement();
+				assertThat(entry.getPlatform()).isEqualTo(ZipArchiveEntry.PLATFORM_UNIX);
+				assertThat(entry.getGeneralPurposeBit().usesUTF8ForNames()).isTrue();
+			}
+		}
+	}
+
+	private boolean hasLauncherClasses(File file) throws IOException {
+		return hasEntry(file, "org/springframework/boot/")
+				&& hasEntry(file, "org/springframework/boot/loader/JarLauncher.class");
+	}
+
+	private boolean hasEntry(File file, String name) throws IOException {
+		return getEntry(file, name) != null;
+	}
+
+	private JarEntry getEntry(File file, String name) throws IOException {
+		try (JarFile jarFile = new JarFile(file)) {
+			return jarFile.getJarEntry(name);
+		}
+	}
+
+	private Manifest getManifest(File file) throws IOException {
+		try (JarFile jarFile = new JarFile(file)) {
+			return jarFile.getManifest();
+		}
+	}
+
+	private static class MockLauncherScript implements LaunchScript {
+
+		private final byte[] bytes;
+
+		MockLauncherScript(String script) {
+			this.bytes = script.getBytes();
+		}
+
+		@Override
+		public byte[] toByteArray() {
+			return this.bytes;
+		}
+
+	}
+
+	public static class TestLayoutFactory implements LayoutFactory {
+
+		@Override
+		public Layout getLayout(File source) {
+			return new TestLayout();
+		}
+
+	}
+
+	private static class TestLayout extends Layouts.Jar implements CustomLoaderLayout {
+
+		@Override
+		public void writeLoadedClasses(LoaderClassesWriter writer) throws IOException {
+			writer.writeEntry("test", new ByteArrayInputStream("test".getBytes()));
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/TestJarFile.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      http://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.boot.loader.tools;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.jar.JarFile;
+import java.util.jar.Manifest;
+
+import org.junit.rules.TemporaryFolder;
+import org.zeroturnaround.zip.ZipUtil;
+
+/**
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ */
+public class TestJarFile {
+
+	private final byte[] buffer = new byte[4096];
+
+	private final TemporaryFolder temporaryFolder;
+
+	private final File jarSource;
+
+	public TestJarFile(TemporaryFolder temporaryFolder) throws IOException {
+		this.temporaryFolder = temporaryFolder;
+		this.jarSource = temporaryFolder.newFolder();
+	}
+
+	public void addClass(String filename, Class<?> classToCopy) throws IOException {
+		addClass(filename, classToCopy, null);
+	}
+
+	public void addClass(String filename, Class<?> classToCopy, Long time)
+			throws IOException {
+		File file = getFilePath(filename);
+		file.getParentFile().mkdirs();
+		InputStream inputStream = getClass().getResourceAsStream(
+				"/" + classToCopy.getName().replace('.', '/') + ".class");
+		copyToFile(inputStream, file);
+		if (time != null) {
+			file.setLastModified(time);
+		}
+	}
+
+	public void addFile(String filename, File fileToCopy) throws IOException {
+		File file = getFilePath(filename);
+		file.getParentFile().mkdirs();
+		try (InputStream inputStream = new FileInputStream(fileToCopy)) {
+			copyToFile(inputStream, file);
+		}
+	}
+
+	public void addManifest(Manifest manifest) throws IOException {
+		File manifestFile = new File(this.jarSource, "META-INF/MANIFEST.MF");
+		manifestFile.getParentFile().mkdirs();
+		try (OutputStream outputStream = new FileOutputStream(manifestFile)) {
+			manifest.write(outputStream);
+		}
+	}
+
+	private File getFilePath(String filename) {
+		String[] paths = filename.split("\\/");
+		File file = this.jarSource;
+		for (String path : paths) {
+			file = new File(file, path);
+		}
+		return file;
+	}
+
+	private void copyToFile(InputStream inputStream, File file)
+			throws FileNotFoundException, IOException {
+		try (OutputStream outputStream = new FileOutputStream(file)) {
+			copy(inputStream, outputStream);
+		}
+	}
+
+	private void copy(InputStream in, OutputStream out) throws IOException {
+		int bytesRead = -1;
+		while ((bytesRead = in.read(this.buffer)) != -1) {
+			out.write(this.buffer, 0, bytesRead);
+		}
+	}
+
+	public JarFile getJarFile() throws IOException {
+		return new JarFile(getFile());
+	}
+
+	public File getJarSource() {
+		return this.jarSource;
+	}
+
+	public File getFile() throws IOException {
+		return getFile("jar");
+	}
+
+	public File getFile(String extension) throws IOException {
+		File file = this.temporaryFolder.newFile();
+		file = new File(file.getParent(), file.getName() + "." + extension);
+		ZipUtil.pack(this.jarSource, file);
+		return file;
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/sample/AnnotatedClassWithMainMethod.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2012-2016 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
+ *
+ *      http://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.boot.loader.tools.sample;
+
+/**
+ * Sample annotated class with a main method.
+ *
+ * @author Andy Wilkinson
+ */
+@SomeApplication
+public class AnnotatedClassWithMainMethod {
+
+	public void run() {
+		System.out.println("Hello World");
+	}
+
+	public static void main(String[] args) {
+		new AnnotatedClassWithMainMethod().run();
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/sample/ClassWithMainMethod.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2012-2013 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
+ *
+ *      http://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.boot.loader.tools.sample;
+
+/**
+ * Sample class with a main method.
+ *
+ * @author Phillip Webb
+ */
+public class ClassWithMainMethod {
+
+	public void run() {
+		System.out.println("Hello World");
+	}
+
+	public static void main(String[] args) {
+		new ClassWithMainMethod().run();
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/sample/ClassWithoutMainMethod.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012-2013 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
+ *
+ *      http://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.boot.loader.tools.sample;
+
+/**
+ * Sample class without a main method.
+ *
+ * @author Phillip Webb
+ */
+public class ClassWithoutMainMethod {
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/java/org/springframework/boot/loader/tools/sample/SomeApplication.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2012-2016 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
+ *
+ *      http://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.boot.loader.tools.sample;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Test annotation for a main application class.
+ *
+ * @author Andy Wilkinson
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@interface SomeApplication {
+
+}

spring-boot-project/spring-boot-tools/spring-boot-loader-tools/src/test/resources/example.script

@@ -0,0 +1 @@
+FOO=BAR