Esiste un Corrispondente per il confronto ricorsivo di directory?

Question

Sto scrivendo unit test per IM- ed esportazione di file. Ho bisogno di testare la directory risultante in modo ricorsivo byte per byte. Ho implementato una routine per directory flat da solo e so come farlo anche in modo ricorsivo. Ma non voglio reinventare la ruota.

Quindi c'è qualcosa come i seguenti esempi?

Matchers.matches(Path actual, equalsRecursive(Path value)); 

o

FileAssertions.equalsRecursive(Path actual, Path value); 

Answer 1

Non sono a conoscenza di una tale Matcher. Quindi, IMO dovrai farlo da solo. 2 opzioni ho potuto pensare sono i seguenti:

1. utilizzare Apache Commons FileUtils al fine di

   1.1. assicurati che ogni file/sottodirectory (la chiamata ricorsiva vada qui) esista all'interno della directory attualmente in fase di test. Per ogni sottodiretto, ottenere una raccolta di file, iterare e utilizzare il metodo directoryContains per la sottodir corrispondente.

   1.2 assicurarsi che il contenuto di 2 file corrispondenti siano uguali utilizzando il metodo contentEquals. Non sono sicuro di cosa succede se passi a 2 directory con questo metodo.

2. Seconda opzione: se si eseguono i test su Linux box è possibile eseguire un comando Linux da Java utilizzando Runtime.exec() documenti sono here. L'unico comando è necessario eseguire è diff -r <directory1> <directory2>

Buona fortuna!

Answer 2

Non trovato nulla. Così l'ho programmato da solo. Non è molto sofisticato e lento per file di grandi dimensioni, ma sembra funzionare.

import java.io.IOException; 
import java.nio.file.FileVisitResult; 
import java.nio.file.FileVisitor; 
import java.nio.file.Files; 
import java.nio.file.Path; 
import java.nio.file.attribute.BasicFileAttributes; 

import org.junit.Assert; 

/** 
* Assertion for recursively testing directories. 
* 
* @author andreas 
*/ 
public class AssertFile { 

private AssertFile() { 
    throw new RuntimeException("This class should not be instantiated"); 
} 

/** 
* Asserts that two directories are recursively equal. If they are not, an {@link AssertionError} is thrown with the 
* given message.<br/> 
* There will be a binary comparison of all files under expected with all files under actual. File attributes will 
* not be considered.<br/> 
* Missing or additional files are considered an error.<br/> 
* 
* @param expected 
*   Path expected directory 
* @param actual 
*   Path actual directory 
*/ 
public static final void assertPathEqualsRecursively(final Path expected, final Path actual) { 
    Assert.assertNotNull(expected); 
    Assert.assertNotNull(actual); 
    final Path absoluteExpected = expected.toAbsolutePath(); 
    final Path absoluteActual = actual.toAbsolutePath(); 
    try { 
     Files.walkFileTree(expected, new FileVisitor<Path>() { 

      @Override 
      public FileVisitResult preVisitDirectory(Path expectedDir, BasicFileAttributes attrs) 
        throws IOException { 
       Path relativeExpectedDir = absoluteExpected.relativize(expectedDir.toAbsolutePath()); 
       Path actualDir = absoluteActual.resolve(relativeExpectedDir); 

       if (!Files.exists(actualDir)) { 
        Assert.fail(String.format("Directory \'%s\' missing in target.", expectedDir.getFileName())); 
       } 

       Assert.assertEquals(String.format("Directory size of \'%s\' differ. ", relativeExpectedDir), 
         expectedDir.toFile().list().length, actualDir.toFile().list().length); 

       return FileVisitResult.CONTINUE; 
      } 

      @Override 
      public FileVisitResult visitFile(Path expectedFile, BasicFileAttributes attrs) throws IOException { 
       Path relativeExpectedFile = absoluteExpected.relativize(expectedFile.toAbsolutePath()); 
       Path actualFile = absoluteActual.resolve(relativeExpectedFile); 

       if (!Files.exists(actualFile)) { 
        Assert.fail(String.format("File \'%s\' missing in target.", expectedFile.getFileName())); 
       } 
       Assert.assertEquals(String.format("File size of \'%s\' differ. ", relativeExpectedFile), 
         Files.size(expectedFile), Files.size(actualFile)); 
       Assert.assertArrayEquals(String.format("File content of \'%s\' differ. ", relativeExpectedFile), 
         Files.readAllBytes(expectedFile), Files.readAllBytes(actualFile)); 

       return FileVisitResult.CONTINUE; 
      } 

      @Override 
      public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException { 
       Assert.fail(exc.getMessage()); 
       return FileVisitResult.TERMINATE; 
      } 

      @Override 
      public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { 
       return FileVisitResult.CONTINUE; 
      } 

     }); 
    } catch (IOException e) { 
     Assert.fail(e.getMessage()); 
    } 
} 

}