package org.junit.tests.experimental.rules;
   
   import static org.hamcrest.CoreMatchers.hasItem;
   import static org.hamcrest.core.IsNot.not;
   import static org.junit.Assert.assertFalse;
   import static org.junit.Assert.assertThat;
   import static org.junit.Assert.assertTrue;
   import static org.junit.experimental.results.PrintableResult.testResult;
   import static org.junit.experimental.results.ResultMatchers.failureCountIs;
  import static org.junit.experimental.results.ResultMatchers.isSuccessful;
  
  import java.io.File;
  import java.io.IOException;
  import java.lang.reflect.Method;
  import java.util.Arrays;
  
  import org.junit.After;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.TemporaryFolder;
  
  public class TempFolderRuleTest {
      private static File[] createdFiles = new File[20];
  
      public static class HasTempFolder {
          @Rule
          public TemporaryFolder folder = new TemporaryFolder();
  
          @Test
          public void testUsingTempFolder() throws IOException {
              createdFiles[0] = folder.newFile("myfile.txt");
              assertTrue(createdFiles[0].exists());
          }
      }
  
      @Test
      public void tempFolderIsDeleted() {
          assertThat(testResult(HasTempFolder.class), isSuccessful());
          assertFalse(createdFiles[0].exists());
      }
  
      public static class CreatesSubFolder {
          @Rule
          public TemporaryFolder folder = new TemporaryFolder();
  
          @Test
          public void testUsingTempFolderStringReflection() throws Exception {
              String subfolder = "subfolder";
              String filename = "a.txt";
              // force usage of folder.newFolder(String),
              // check is available and works, to avoid a potential NoSuchMethodError with non-recompiled code.
              Method method = folder.getClass().getMethod("newFolder", new Class<?>[]{String.class});
              createdFiles[0] = (File) method.invoke(folder, subfolder);
              new File(createdFiles[0], filename).createNewFile();
  
              File expectedFile = new File(folder.getRoot(), join(subfolder, filename));
  
              assertTrue(expectedFile.exists());
          }
  
          @Test
          public void testUsingTempFolderString() throws IOException {
              String subfolder = "subfolder";
              String filename = "a.txt";
              // this uses newFolder(String), ensure that a single String works
              createdFiles[0] = folder.newFolder(subfolder);
              new File(createdFiles[0], filename).createNewFile();
  
              File expectedFile = new File(folder.getRoot(), join(subfolder, filename));
  
              assertTrue(expectedFile.exists());
          }
  
          @Test
          public void testUsingTempTreeFolders() throws IOException {
              String subfolder = "subfolder";
              String anotherfolder = "anotherfolder";
              String filename = "a.txt";
  
              createdFiles[0] = folder.newFolder(subfolder, anotherfolder);
              new File(createdFiles[0], filename).createNewFile();
  
              File expectedFile = new File(folder.getRoot(), join(subfolder, anotherfolder, filename));
  
              assertTrue(expectedFile.exists());
          }
  
          private String join(String... folderNames) {
              StringBuilder path = new StringBuilder();
              for (String folderName : folderNames) {
                  path.append(File.separator).append(folderName);
              }
              return path.toString();
          }
      }
  
      @Test
      public void subFolderIsDeleted() {
          assertThat(testResult(CreatesSubFolder.class), isSuccessful());
         assertFalse(createdFiles[0].exists());
     }
 
     public static class CreatesRandomSubFolders {
         @Rule
         public TemporaryFolder folder = new TemporaryFolder();
 
         @Test
         public void testUsingRandomTempFolders() throws IOException {
             for (int i = 0; i < 20; i++) {
                 File newFolder = folder.newFolder();
                 assertThat(Arrays.asList(createdFiles), not(hasItem(newFolder)));
                 createdFiles[i] = newFolder;
                 new File(newFolder, "a.txt").createNewFile();
                 assertTrue(newFolder.exists());
             }
         }
     }
 
     @Test
     public void randomSubFoldersAreDeleted() {
         assertThat(testResult(CreatesRandomSubFolders.class), isSuccessful());
         for (File f : createdFiles) {
             assertFalse(f.exists());
         }
     }
 
     public static class CreatesRandomFiles {
         @Rule
         public TemporaryFolder folder = new TemporaryFolder();
 
         @Test
         public void testUsingRandomTempFiles() throws IOException {
             for (int i = 0; i < 20; i++) {
                 File newFile = folder.newFile();
                 assertThat(Arrays.asList(createdFiles), not(hasItem(newFile)));
                 createdFiles[i] = newFile;
                 assertTrue(newFile.exists());
             }
         }
     }
 
     @Test
     public void randomFilesAreDeleted() {
         assertThat(testResult(CreatesRandomFiles.class), isSuccessful());
         for (File f : createdFiles) {
             assertFalse(f.exists());
         }
     }
 
     @Test
     public void recursiveDeleteFolderWithOneElement() throws IOException {
         TemporaryFolder folder = new TemporaryFolder();
         folder.create();
         File file = folder.newFile("a");
         folder.delete();
         assertFalse(file.exists());
         assertFalse(folder.getRoot().exists());
     }
 
     @Test
     public void recursiveDeleteFolderWithOneRandomElement() throws IOException {
         TemporaryFolder folder = new TemporaryFolder();
         folder.create();
         File file = folder.newFile();
         folder.delete();
         assertFalse(file.exists());
         assertFalse(folder.getRoot().exists());
     }
 
     @Test
     public void recursiveDeleteFolderWithZeroElements() throws IOException {
         TemporaryFolder folder = new TemporaryFolder();
         folder.create();
         folder.delete();
         assertFalse(folder.getRoot().exists());
     }
 
     public static class NameClashes {
         @Rule
         public TemporaryFolder folder = new TemporaryFolder();
 
         @Test
         public void fileWithFileClash() throws IOException {
             folder.newFile("something.txt");
             folder.newFile("something.txt");
         }
 
         @Test
         public void fileWithFolderTest() throws IOException {
             folder.newFolder("dummy");
             folder.newFile("dummy");
         }
     }
 
     @Test
     public void nameClashesResultInTestFailures() {
         assertThat(testResult(NameClashes.class), failureCountIs(2));
     }
 
     private static final String GET_ROOT_DUMMY = "dummy-getRoot";
 
     private static final String NEW_FILE_DUMMY = "dummy-newFile";
 
     private static final String NEW_FOLDER_DUMMY = "dummy-newFolder";
 
     public static class IncorrectUsage {
         public TemporaryFolder folder = new TemporaryFolder();
 
         @Test
         public void testGetRoot() throws IOException {
             new File(folder.getRoot(), GET_ROOT_DUMMY).createNewFile();
         }
 
         @Test
         public void testNewFile() throws IOException {
             folder.newFile(NEW_FILE_DUMMY);
         }
 
         @Test
         public void testNewFolder() throws IOException {
             folder.newFolder(NEW_FOLDER_DUMMY);
         }
     }
 
     @Test
     public void incorrectUsageWithoutApplyingTheRuleShouldNotPolluteTheCurrentWorkingDirectory() {
         assertThat(testResult(IncorrectUsage.class), failureCountIs(3));
         assertFalse("getRoot should have failed early", new File(GET_ROOT_DUMMY).exists());
         assertFalse("newFile should have failed early", new File(NEW_FILE_DUMMY).exists());
         assertFalse("newFolder should have failed early", new File(NEW_FOLDER_DUMMY).exists());
     }
 
     @After
     public void cleanCurrentWorkingDirectory() {
         new File(GET_ROOT_DUMMY).delete();
         new File(NEW_FILE_DUMMY).delete();
         new File(NEW_FOLDER_DUMMY).delete();
     }
 }