Как делают Вас модульный тест?

Я использую модульные тесты в качестве инструмента, чтобы иметь размеры, работает ли что-то все еще или нет, после того, как я сделал некоторые изменения в коде (например, рефакторинг, исправив ошибку, добавив улучшение). Так как я использую Java, модульные тесты в основном автоматизированы с помощью JUnit. Ijust вызывают один сценарий командной строки, и он запускает сотни тестов, чтобы проверить, что код не взломан.

я тестовые функции единицы, не отдельные методы или классы. Издержки записи и поддержания модульных тестов являются весьма значительными, и в целом я не рекомендую писать модульные тесты на каждый немного кода. Функции поблочного тестирования, однако, стоят, потому что функции - то, что клиент платит Вам.

Это универсальные инструкции, которые я нахожу полезными для поблочного тестирования:

1) Определите Граничные Объекты (Победа/Веб-формы, CustomControls и т.д.).

2) Определите Объекты управления (Бизнес-расположенные на слое объекты)

3) Удостоверьтесь, что Записали Модульные тесты, по крайней мере, на открытые методы объектов управления, вызванные граничными объектами.

Таким образом, Вы будете уверены, что покрываете основные функциональные аспекты (функции) Вашего приложения, и Вы не рискуете микротестировать (если Вы не хотите).

Я тестирую такой большой открытый интерфейс, как я могу (я использовать C++, но язык действительно не имеет значения). Самый важный аспект пишет тесты при написании кода (сразу прежде или после). На основе опыта я уверяю Вас, что разработка таким образом приведет к более надежному коду. и поможет поддержать (как изменения, которые повреждаются, тесты будут, очевидно, сразу).

Для всех проектов я рекомендую принять тестирование во внимание с самого начала - если Вы пишете класс, который зависит от другого сложного класса, затем используйте интерфейс, таким образом, можно 'дразнить' более сложные объекты при тестировании (доступ к базе данных, доступ к сети, и т.д.).

Запись большого количества тестов, будет казаться, замедлит Вас, но в действительности, за время жизни проекта, Вы потратите ошибки исправляющего меньшего количества времени.

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

Я - довольно неаккуратный тестер единицы, но затем я - академик, таким образом, большинство моих программ является сценариями для моего собственного использования или большим количеством мощных программ для моего исследования. Большая моя работа находится на компиляторах, таким образом, классическое поблочное тестирование, трудный---, например, это не настолько легко к модульному тесту средство выделения регистра, если Вы компилятор для переноса его, и в той точке Вы не можете также просто перейти к регрессионному тестированию.

Но существуют некоторые большие исключения. Я делаю огромное среди сценариев в Lua, который разделен на модули (исходный файл может быть и часто является модулем). Если я буду работать над новым материалом, как скажем, утилиты для взаимодействия с оболочкой, то я просто отброшу некоторые модульные тесты в самом модуле. куда они выполняются каждый раз, когда модуль загружается. Lua так быстр, что обычно это не имеет значения. Вот некоторые примеры:

assert(os.quote [[three]] == [[three]])
assert(os.quote [[three"]] == [['three"']])
assert(os.quote [[your mama]] == [['your mama']])
assert(os.quote [[$i]] == [['$i']])

Если я - хорошая собака, я пишу некоторые простые тесты как они, прежде чем я запишу функцию.

Другая вещь, которую я делаю с поблочным тестированием, состоит в том, что, если это - что-нибудь трудно, я тестирую алгебраическое использование законов QuickCheck, который является случайным инструментом тестирования, которому, как должно замечаться, верят. Это - единственный инструмент, который я когда-либо использовал, который делает забаву поблочного тестирования. Ссылка там свисает, но можно найти историю Tom Moertel о ICFP, программирующем конкурс на его блоге.

Надеюсь, что Вы находите это полезным. QuickCheck много раз убирался подобру-поздорову. Последний раз я протестировал код на дискретное косинусное преобразование с помощью точной рациональной арифметики---, затем портировал его к C!

Мы обычно программа в библиотеках Java для машин. Программа обычно формируется более чем двадцатью библиотеками поэтому, что мы делаем модульный тест каждая библиотека. Это не легкая задача, так как много раз библиотеки являются очень двойными друг между другом, и это не много раз возможно.

Наш код не является столь модульным, как мы хотели бы, чтобы он был всего лишь, мы должны жить с ним для проблем совместимости, и связь повреждения означает повреждать совместимость во многих случаях также.

Это - недостаточно только к модульному тесту класс. Классы сотрудничают, и это должно быть протестировано также.

Существует больше единиц, чем просто классы:

• модули,
• слои,
• платформы.

И существуют, конечно, различные формы тестирования, например, интеграция и принятие.

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

Просто, потому что это компилирует, не означает, что это работает! Это - сущность поблочного тестирования. Испытайте код. Удостоверьтесь, что это делает то, что Вы думали, что это делало.

Позволяет стоят перед ним, если Вы приносите по матричному преобразованию от matlab, легко испортить плюс или знак "минус" где-нибудь. Такую вещь трудно видеть. Не испытывая его, Вы просто не знаете, будет ли это работать правильно. Отладка 100 строк кода намного легче, чем отладка 100 000 строк кода.

Некоторые люди берут это к экстремальным значениям. Они пытаются протестировать каждую мыслимую вещь. Тестирование становится концом к себе.

Это может быть полезно позже в течение этапов технического обслуживания. Можно быстро проверить, чтобы удостовериться, что обновления ничего не повредили.

Но включенные издержки могут нанести вред разработке продукта! И будущие изменения, которые изменяют функциональность, могут включить обширное обновление теста наверху.

(Это может также стать грязным относительно порядка незаконной казни и многопоточности.)

В конечном счете, если не направлено иначе, мои тесты пытаются поразить второй план.

Я обращаюсь к тесту при больших гранулярностях, обеспечивая средство проверки основной общей функциональности. Я не волнуюсь так о каждом возможном fencepost сценарии. (Это - то, что УТВЕРЖДАЕТ, что макросы для.)

Например: Когда я написал код для отправления/получения сообщений по UDP, я бросил вместе быстрый тест для отправления/получения данных с помощью того класса через петлевой интерфейс.Ничего особенного. Быстрый, быстро, и грязный код. Я просто хотел испытать его. Удостоверяться, что это на самом деле работало, прежде чем я создал что-то сверху его.

Другой пример: Чтение при закрытых дверях отображает от камеры Firewire. Я бросил вместе quick&dirty GTK приложение, чтобы прочитать изображения, обработать их и отобразить их в в реальном времени. Другие люди называют то интеграционное тестирование. Но я могу использовать его для проверки моего интерфейса Firewire, моего класса Изображения, мой RGGB-Байера>, RGB преобразовывает, моя ориентация изображения и выравнивание, даже была ли камера смонтирована вверх тормашками снова. Более подробное тестирование было бы только гарантировано, если бы это оказалось недостаточным.

С другой стороны, даже для чего-то столь же простого как:

template<class TYPE> inline TYPE MIN(const TYPE & x, const TYPE & y) { return x > y ? y : x; }
template<class TYPE> inline TYPE MAX(const TYPE & x, const TYPE & y) { return x < y ? y : x; }

Я записал, что 1 строка ПОКАЗЫВАЕТ макрос, чтобы удостовериться, что я не испортил знак:

  SHOW(MIN(3,4));  SHOW(MAX(3,4));

Все, что я хотел сделать, должно было проверить, что делало то, что это должно делать в общем случае. Я волнуюсь меньше о том, как это обрабатывает NaN / + - Бесконечность / (дважды, интервал), чем, решил ли один из коллег изменить порядок аргументов и попал впросак.

Мудрый инструмент, существует много материала поблочного тестирования там. Если это помогает Вам, большему количеству питания Вам. В противном случае хорошо Вы не должны действительно становиться слишком необычными.

Я буду часто писать тестовую программу, которая выводит данные в и из класса и затем распечатывает все это с ВЫСТАВОЧНЫМ макросом:

#define SHOW(X)  std::cout << # X " = " << (X) << std::endl

(С другой стороны, многие мои классы могут самораспечатать использование встроенного оператора <<(ostream&) метод. Это - удивительно полезная техника для отладки, а также для тестирования!)

Make-файлы могут быть тривиально расширены, чтобы автоматически генерировать выходные файлы от тестовых программ и автоматически сравнить (разность) эти выходные файлы с ранее известными (рассмотренными) результатами.

Не необычный, возможно, несколько менее, чем изящный, но поскольку методы идут, это очень эффективно, быстро для реализации, и очень низко наверху. (Который имеет его преимущества, когда Ваш менеджер относится неодобрительно к тому, чтобы напрасно тратить время на том материале тестирования.)

Одна последняя мысль я оставлю Вас с. Это собирается отметить меня, не делайте этого!

Некоторое время назад мне была нужна программа тестирования. Это был необходимый поставляемый компонент. Сама программа должна была проверить, что другой класс работал правильно. Но это не могло получить доступ к внешним файлам данных. (Мы не могли полагаться, где программа будет расположена относительно чего-либо еще. Никакие полные пути также.) Платформа поблочного тестирования для проекта была несовместимой с компилятором, который я был обязан использовать. Это также должно было быть в одном файле. Система make-файла проекта не поддерживала соединение нескольких файлов для непритязательной тестовой программы. (Прикладные программы, уверенные. Они могли пользоваться библиотеками. Но только единственный файл для каждой тестовой программы.)

Так, Бог прощают мне, я "нарушил правила"...

<смущенный>
Я использовал макросы. Когда #define макрос был установлен, данные были записаны во второй.c файл как инициализатор для массива структур. Впоследствии, когда программное обеспечение было перекомпилировано, и что второй.c файл (с массивом структур) был #included, и #define макрос не был установлен, это сравнило новые результаты с ранее хранившими данными. Да, я #included.c файл. O' затруднение всего этого.
</смущенный>

Но это может быть сделано...