При нахождении себя переопределяющими (неабстрактными) методами очень часто Вы, вероятно, хотите смотреть на свой дизайн. Очень полезно, когда компилятор иначе не зафиксировал бы ошибку. Например, пытаясь переопределить initValue () в ThreadLocal, который я сделал.
Используя @Override при реализации методов интерфейса (1.6 + функция) кажется небольшим излишеством для меня. Если у Вас есть загрузки методов, некоторые из которых переопределяют и некоторые не делают, это, вероятно, плохой дизайн снова (и Ваш редактор, вероятно, покажет, который является который, если Вы не знаете).
Конечно, это ценно, потому что тогда это полезный регрессионный тест . На мой взгляд, регрессионные тесты более важны, чем тестирование недавно разработанного кода.
Сказать, что они всегда должны терпеть неудачу в первую очередь, означает взять правило, выходящее за рамки практического.
TDD для меня больше инструмент дизайна, а не второстепенная мысль. Так что другого пути нет, тест не пройдет просто потому, что еще нет кода, чтобы он прошел, только после того, как я его создам, тест может пройти.
Да, тесты TDD должны завершиться неудачно, прежде чем они станут зелеными (работают). В противном случае вы не знаете, действительный ли у вас тест.
На самом деле вы спрашиваете, как можно протестировать тест , чтобы убедиться, что он действителен и проверяет то, что вы намереваетесь.
Сделать его неудачным. сначала это нормально, но обратите внимание, что даже если он потерпит неудачу, когда вы планируете его потерпеть неудачу, и преуспеет после рефакторинга кода, чтобы сделать его успешным, по-прежнему не означает, что ваш тест действительно проверял то, что вы хотели ... Конечно, вы можете написать несколько других классов, которые будут вести себя по-другому, чтобы протестировать ваш тест ... Но на самом деле это тест, который проверяет ваш исходный тест - как вы узнаете, что новый тест действителен ? : -)
Таким образом, отказ от теста - это хорошая идея, но она все же небезопасна.
Я думаю, что смысл «провалиться первым» состоит в том, чтобы не обмануть себя, что тест сработал. Если у вас есть набор тестов, проверяющих один и тот же метод с разными параметрами, один (или несколько) из них, скорее всего, с самого начала пройдет успешно. Рассмотрим этот пример:
public String doFoo(int param) {
//TODO implement me
return null;
}
Тесты будут выглядеть примерно так:
public void testDoFoo_matches() {
assertEquals("Geoff Hurst", createBar().doFoo(1966));
}
public void testDoFoo_validNoMatch() {
assertEquals("no match", createBar().doFoo(1));
}
public void testDoFoo_outOfRange() {
assertEquals(null, createBar().doFoo(-1));
}
public void testDoFoo_tryAgain() {
assertEquals("try again", createBar().doFoo(0));
}
Один из этих тестов будет пройден, но, очевидно, другие нет, поэтому вы должны правильно реализовать код, чтобы набор тестов прошел. Я думаю, что это истинное требование. Суть правила состоит в том, чтобы убедиться, что вы обдумали ожидаемый результат, прежде чем приступить к взлому.
ИМХО, важность провала в первую очередь заключается в том, чтобы убедиться, что созданный вами тест не имеет недостатков. Вы можете, например, забыть Assert в своем тесте, и, возможно, вы никогда этого не узнаете.
Аналогичный случай возникает, когда вы выполняете граничные тесты, вы уже создали код, который его покрывает, но он рекомендуется проверить это.
Я думаю, что это не большая проблема, чтобы ваш тест не провалился, но вы должны убедиться, что он действительно проверяет то, что должен (возможно, отладка).