| package org.junit.rules; |
| |
| import java.io.File; |
| import java.io.IOException; |
| |
| import org.junit.Rule; |
| |
| /** |
| * The TemporaryFolder Rule allows creation of files and folders that should |
| * be deleted when the test method finishes (whether it passes or |
| * fails). Whether the deletion is successful or not is not checked by this rule. |
| * No exception will be thrown in case the deletion fails. |
| * |
| * <p>Example of usage: |
| * <pre> |
| * public static class HasTempFolder { |
| * @Rule |
| * public TemporaryFolder folder= new TemporaryFolder(); |
| * |
| * @Test |
| * public void testUsingTempFolder() throws IOException { |
| * File createdFile= folder.newFile("myfile.txt"); |
| * File createdFolder= folder.newFolder("subfolder"); |
| * // ... |
| * } |
| * } |
| * </pre> |
| * |
| * @since 4.7 |
| */ |
| public class TemporaryFolder extends ExternalResource { |
| private final File parentFolder; |
| private File folder; |
| |
| public TemporaryFolder() { |
| this(null); |
| } |
| |
| public TemporaryFolder(File parentFolder) { |
| this.parentFolder = parentFolder; |
| } |
| |
| @Override |
| protected void before() throws Throwable { |
| create(); |
| } |
| |
| @Override |
| protected void after() { |
| delete(); |
| } |
| |
| // testing purposes only |
| |
| /** |
| * for testing purposes only. Do not use. |
| */ |
| public void create() throws IOException { |
| folder = createTemporaryFolderIn(parentFolder); |
| } |
| |
| /** |
| * Returns a new fresh file with the given name under the temporary folder. |
| */ |
| public File newFile(String fileName) throws IOException { |
| File file = new File(getRoot(), fileName); |
| if (!file.createNewFile()) { |
| throw new IOException( |
| "a file with the name \'" + fileName + "\' already exists in the test folder"); |
| } |
| return file; |
| } |
| |
| /** |
| * Returns a new fresh file with a random name under the temporary folder. |
| */ |
| public File newFile() throws IOException { |
| return File.createTempFile("junit", null, getRoot()); |
| } |
| |
| /** |
| * Returns a new fresh folder with the given name under the temporary |
| * folder. |
| */ |
| public File newFolder(String folder) throws IOException { |
| return newFolder(new String[]{folder}); |
| } |
| |
| /** |
| * Returns a new fresh folder with the given name(s) under the temporary |
| * folder. |
| */ |
| public File newFolder(String... folderNames) throws IOException { |
| File file = getRoot(); |
| for (int i = 0; i < folderNames.length; i++) { |
| String folderName = folderNames[i]; |
| validateFolderName(folderName); |
| file = new File(file, folderName); |
| if (!file.mkdir() && isLastElementInArray(i, folderNames)) { |
| throw new IOException( |
| "a folder with the name \'" + folderName + "\' already exists"); |
| } |
| } |
| return file; |
| } |
| |
| /** |
| * Validates if multiple path components were used while creating a folder. |
| * |
| * @param folderName |
| * Name of the folder being created |
| */ |
| private void validateFolderName(String folderName) throws IOException { |
| File tempFile = new File(folderName); |
| if (tempFile.getParent() != null) { |
| String errorMsg = "Folder name cannot consist of multiple path components separated by a file separator." |
| + " Please use newFolder('MyParentFolder','MyFolder') to create hierarchies of folders"; |
| throw new IOException(errorMsg); |
| } |
| } |
| |
| private boolean isLastElementInArray(int index, String[] array) { |
| return index == array.length - 1; |
| } |
| |
| /** |
| * Returns a new fresh folder with a random name under the temporary folder. |
| */ |
| public File newFolder() throws IOException { |
| return createTemporaryFolderIn(getRoot()); |
| } |
| |
| private File createTemporaryFolderIn(File parentFolder) throws IOException { |
| File createdFolder = File.createTempFile("junit", "", parentFolder); |
| createdFolder.delete(); |
| createdFolder.mkdir(); |
| return createdFolder; |
| } |
| |
| /** |
| * @return the location of this temporary folder. |
| */ |
| public File getRoot() { |
| if (folder == null) { |
| throw new IllegalStateException( |
| "the temporary folder has not yet been created"); |
| } |
| return folder; |
| } |
| |
| /** |
| * Delete all files and folders under the temporary folder. Usually not |
| * called directly, since it is automatically applied by the {@link Rule} |
| */ |
| public void delete() { |
| if (folder != null) { |
| recursiveDelete(folder); |
| } |
| } |
| |
| private void recursiveDelete(File file) { |
| File[] files = file.listFiles(); |
| if (files != null) { |
| for (File each : files) { |
| recursiveDelete(each); |
| } |
| } |
| file.delete(); |
| } |
| } |