Сравнение текстовых файлов w/Junit

Ответ 1

junit-addons имеет хорошую поддержку для него: FileAssert

Это дает вам исключения, например:

junitx.framework.ComparisonFailure: aa Line [3] expected: [b] but was:[a]

Ответ 2

Здесь один простой подход для проверки того, являются ли файлы одинаковыми:

assertEquals("The files differ!", 
    FileUtils.readFileToString(file1, "utf-8"), 
    FileUtils.readFileToString(file2, "utf-8"));

Где file1 и file2 - экземпляры File, а FileUtils - это Apache Commons IO.

Не очень собственный код для вас, который всегда является плюсом.:) И очень легко, если вы уже используете Apache Commons в своем проекте. Но никаких приятных подробных сообщений об ошибках, например, в отметить решение.

Edit:
Хех, посмотрев ближе к API FileUtils, существует еще более простой способ:

assertTrue("The files differ!", FileUtils.contentEquals(file1, file2));

В качестве бонуса эта версия работает для всех файлов, а не только для текста.

Ответ 3

Вот более исчерпывающий список файлового компаратора в различных сторонних библиотеках Java:

• org.apache.commons.io.FileUtils
• org.dbunit.util.FileAsserts
• org.fest.assertions.FileAssert
• junitx.framework.FileAssert
• org.springframework.batch.test.AssertFile
• org.netbeans.junit.NbTestCase
• org.assertj.core.api.FileAssert

Ответ 4

С 2015 года я бы пересчитал AssertJ, элегантную и всеобъемлющую библиотеку утверждений. Для файлов вы можете утверждать против другого файла:

@Test
public void file() {
    File actualFile = new File("actual.txt");
    File expectedFile = new File("expected.txt");
    assertThat(actualFile).hasSameContentAs(expectedFile);
}

или против встроенных строк:

@Test
public void inline() {
    File actualFile = new File("actual.txt");
    assertThat(linesOf(actualFile)).containsExactly(
            "foo 1",
            "foo 2",
            "foo 3"
    );
}

Сообщения об отказе также очень информативны. Если строка отличается, вы получаете:

java.lang.AssertionError: 
File:
  <actual.txt>
and file:
  <expected.txt>
do not have equal content:
line:<2>, 
Expected :foo 2
Actual   :foo 20

и если один из файлов имеет больше строк, вы получите:

java.lang.AssertionError:
File:
  <actual.txt>
and file:
  <expected.txt>
do not have equal content:
line:<4>,
Expected :EOF
Actual   :foo 4

Ответ 5

Я бы предложил использовать Assert.assertThat и hamcrest matcher (junit 4.5 или новее - возможно, даже 4.4).

У меня получилось бы что-то вроде:

assertThat(fileUnderTest, containsExactText(expectedFile));

где мой младший:

class FileMatcher {
   static Matcher<File> containsExactText(File expectedFile){
      return new TypeSafeMatcher<File>(){
         String failure;
         public boolean matchesSafely(File underTest){
            //create readers for each/convert to strings
            //Your implementation here, something like:
              String line;
              while ((line = expected.readLine()) != null) {
                 Matcher<?> equalsMatcher = CoreMatchers.equalTo(line);
                 String actualLine = actual.readLine();
                 if (!equalsMatcher.matches(actualLine){
                    failure = equalsMatcher.describeFailure(actualLine);
                    return false;
                 }
              }
              //record failures for uneven lines
         }

         public String describeFailure(File underTest);
             return failure;
         }
      }
   }
}

Матчи профи:

• Состав и повторное использование
• Использование в обычном коде, а также при тестировании
  • Коллекции
  • Используется в mock framework (s)
  • Может использоваться общая предикатная функция
• Действительно хорошая логическая способность
• Можно комбинировать с другими сопоставлениями, описания и описания ошибок точны и точны.

Минусы:

• Ну, это довольно очевидно? Это более подробно, чем assert или junitx (для этого конкретного случая)
• Вам, вероятно, нужно будет включить библиотеки hamcrest, чтобы получить максимальную пользу.

Ответ 6

FileUtils уверен, что это хорошо. Здесь еще один простой подход для проверки того, являются ли файлы одинаковыми.

assertEquals(FileUtils.checksumCRC32(file1), FileUtils.checksumCRC32(file2));

В то время как assertEquals() предоставляет немного больше обратной связи, чем assertTrue(), результат checksumCRC32() является длинным. Таким образом, это может быть неинтересно полезно.

Ответ 7

Если в ожидании будет больше строк, чем фактических, вы не получите assertEquals, прежде чем перейти к assertNull позже.

Это довольно легко исправить:

public static void assertReaders(BufferedReader expected,
    BufferedReader actual) throws IOException {
  String expectedLine;
  while ((expectedLine = expected.readLine()) != null) {
    String actualLine = actual.readLine();
    assertNotNull("Expected had more lines then the actual.", actualLine);
    assertEquals(expectedLine, actualLine);
  }
  assertNull("Actual had more lines then the expected.", actual.readLine());
}

Ответ 8

Simpel сравнение содержимого двух файлов с API java.nio.file.

byte[] file1Bytes = Files.readAllBytes(Paths.get("Path to File 1"));
byte[] file2Bytes = Files.readAllBytes(Paths.get("Path to File 2"));

String file1 = new String(file1Bytes, StandardCharsets.UTF_8);
String file2 = new String(file2Bytes, StandardCharsets.UTF_8);

assertEquals("The content in the strings should match", file1, file2);

Или, если вы хотите сравнить отдельные строки:

List<String> file1 = Files.readAllLines(Paths.get("Path to File 1"));
List<String> file2 = Files.readAllLines(Paths.get("Path to File 2"));

assertEquals(file1.size(), file2.size());

for(int i = 0; i < file1.size(); i++) {
   System.out.println("Comparing line: " + i)
   assertEquals(file1.get(i), file2.get(i));
}

Ответ 9

Это моя собственная реализация equalFiles, не нужно добавлять какую-либо библиотеку в ваш проект.

private static boolean equalFiles(String expectedFileName,
        String resultFileName) {
    boolean equal;
    BufferedReader bExp;
    BufferedReader bRes;
    String expLine ;
    String resLine ;

    equal = false;
    bExp = null ;
    bRes = null ;

    try {
        bExp = new BufferedReader(new FileReader(expectedFileName));
        bRes = new BufferedReader(new FileReader(resultFileName));

        if ((bExp != null) && (bRes != null)) {
            expLine = bExp.readLine() ;
            resLine = bRes.readLine() ;

            equal = ((expLine == null) && (resLine == null)) || ((expLine != null) && expLine.equals(resLine)) ;

            while(equal && expLine != null)
            {
                expLine = bExp.readLine() ;
                resLine = bRes.readLine() ; 
                equal = expLine.equals(resLine) ;
            }
        }
    } catch (Exception e) {

    } finally {
        try {
            if (bExp != null) {
                bExp.close();
            }
            if (bRes != null) {
                bRes.close();
            }
        } catch (Exception e) {
        }

    }

    return equal;

}

И использовать его просто используйте обычный AssertTrue метод JUnit

assertTrue(equalFiles(expected, output)) ;