Подтвердить что ты не робот

Как вы unit test a unit test?

Я смотрел веб-трансляции Rob Connerys в приложении MVCStoreFront, и я заметил, что он был модульным тестированием даже самых мирских вещей, таких как:

public Decimal DiscountPrice
{
   get
   {
       return this.Price - this.Discount;
   }
}

Будет тест вроде:

[TestMethod]
public void Test_DiscountPrice
{
    Product p = new Product();
    p.Price = 100;
    p.Discount = 20;
    Assert.IsEqual(p.DiscountPrice,80);
}

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

Если в этом случае ваш unit test ничего не значит для вас.

Кроме того, ваш unit test является еще одной ошибкой:

[TestMethod]
public void Test_DiscountPrice
{
    Product p = new Product();
    p.Price = 100;
    p.Discount = 20;
    Assert.IsEqual(p.DiscountPrice,90);
}

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

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

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

Что мне здесь не хватает? Пожалуйста, научите меня любить TDD, поскольку я с трудом принимаю его как полезный до сих пор. Я тоже хочу, потому что хочу оставаться прогрессивным, но для меня это просто не имеет смысла.

РЕДАКТИРОВАТЬ: пара людей продолжает упоминать, что тестирование помогает обеспечить соответствие спецификации. По моему опыту, спецификация также ошибалась, чаще всего, но, возможно, я обречена работать в организации, где спецификации написаны людьми, которые не должны писать спецификации.

4b9b3361

Ответ 1

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

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

В-третьих, некоторые утверждают, что TDD рассматривает эту проблему. То есть, если вы просто напишете 20 тестов, и они пройдут, вы не полностью уверены, что они на самом деле ничего не тестируют. Но если каждый тест, который вы написали первоначально, не удался, а затем вы его исправили, тогда вы гораздо увереннее, что он действительно тестирует ваш код. ИМХО это back-and-forth занимает больше времени, чем стоит, но это процесс, который пытается решить вашу проблему.

Ответ 2

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

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

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

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

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

[Что касается редактирования: я считаю неизбежным, что неправильная спецификация является точкой отказа. Если вы не знаете, что приложение должно делать, то, скорее всего, он этого не сделает. Но писать тесты, чтобы отразить спецификацию, не увеличивает эту проблему, она просто не может ее решить. Таким образом, вы не добавляете новые точки сбоя, вы просто представляете существующие ошибки в коде вместо документации waffle.]

Ответ 3

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

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

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

Наконец, ответ на ваш титульный вопрос " Как вы unit test a unit test?" это то, что вам не нужно. Каждый unit test должен быть просто мертв мозгом. Вызовите метод с определенным входом и сравните его с ожидаемым результатом. Если спецификация метода изменяется, вы можете ожидать, что некоторые из модульных тестов для этого метода также должны будут измениться. Это одна из причин, по которой вы выполняете модульное тестирование при таком низком уровне детализации, поэтому только некоторые из модульных тестов должны измениться. Если вы обнаружите, что тесты для многих разных методов изменяются для одного изменения требования, то вы не можете тестировать на достаточно высоком уровне детализации.

Ответ 4

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

Единичные тесты должны отражать бизнес-правила. Конечно, в коде могут быть ошибки, но сначала запись теста позволяет вам написать его с точки зрения бизнес-правила до того, как будет написан какой-либо код. Написание теста впоследствии, я думаю, с большей вероятностью приведет к ошибке, которую вы описываете, потому что вы знаете, как код реализует ее, и соблазняются просто убедиться, что реализация верна, а не то, что намерение верное.

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

[EDIT]

Еще одна вещь, которую я нашел с помощью TDD. По умолчанию он практически создает хороший дизайн. Это связано с тем, что конструкции с высокой степенью сцепления практически не могут быть unit test изолированы. Для TDD не требуется очень много времени, чтобы понять, что использование интерфейсов, инверсия управления и инъекции зависимостей - все шаблоны, которые улучшат ваш дизайн и уменьшают сцепление, действительно важны для тестируемого кода.

Ответ 5

Как проверить тест? Мутационные тесты - это ценный метод, который я лично использовал для удивительно хорошего эффекта. Прочтите связанную статью для получения более подробной информации и ссылок на еще более академические ссылки, но в целом она "проверяет ваши тесты", изменяя исходный код (например, "x + = 1" на "x - = 1" ), а затем повторное тестирование ваших тестов, гарантируя, что по крайней мере один тест не удастся. Любые мутации, которые не приводят к сбоям теста, помечены для последующего исследования.

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

Ответ 6

При применении Test-Driven Development (TDD) один начинается с теста с ошибкой. Этот шаг, который может показаться ненужным, на самом деле здесь, чтобы проверить, что unit test что-то тестирует. Действительно, если тест никогда не терпит неудачу, это не приносит никакой пользы и еще хуже, приводит к неправильной уверенности, поскольку вы будете полагаться на положительный результат, который ничего не доказывает.

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

Assert.IsEqual(p.DiscountPrice,90);

Нет причин, по которым тест развивается в этом направлении - или я что-то пропустил в своих рассуждениях. Когда цена равна 100 и скидка 20, скидка - 80. Это похоже на инвариант.

Теперь представьте себе, что вашему программному обеспечению необходимо поддерживать другой вид скидки, основанный на проценте, возможно, в зависимости от купленного объема, метод Product:: DiscountPrice() может усложняться. И возможно, что введение этих изменений нарушает простое правило скидок, которое мы изначально использовали. Затем вы увидите значение этого теста, которое немедленно обнаружит регрессию.


Красный - Зеленый - Рефактор - это нужно помнить о сути процесса TDD.

Красный относится к красной полосе JUnit при неудачных тестах.

Зеленый - это цвет индикатора выполнения JUnit, когда все тесты проходят.

Рефакторинг в зеленом состоянии: удалите любое дублирование, улучшите читаемость.


Теперь, чтобы ответить на ваш вопрос о "3-4 слоях выше кода", это верно в традиционном (водоподобном) процессе, а не в процессе разработки. И подвижный - это мир, откуда приходит TDD; TDD является краеугольным камнем eXtreme Programming.

Agile - это прямое сообщение, а не документы с требованием о перегрузке.

Ответ 7

Пока я все для модульного тестирования, я иногда задаются вопросом, является ли эта форма теста первая разработка действительно выгодна...

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

Например, подумайте о тривиальном испытании, которое будет установлено, чтобы узнать, как использовать API, с которым вы не знакомы. Если этот тест имеет какое-либо отношение к тому, что вы делаете в коде, который использует API "для реального", полезно поддерживать этот тест. Когда API выпускает новую версию, вам необходимо обновить ее. Теперь у вас есть свои предположения о том, как вы ожидаете, что API будет вести себя записанным в исполняемом формате, который вы можете использовать для захвата регрессий.

... [I] n реальный процесс, у вас 3-4 над вашим кодом (бизнес Запрос, Документ требований, Архитектурный документ), где фактическое определенное бизнес-правило (скидка Цена - цена - скидка) может быть misdefined. Если эта ситуация, ваш unit test ничего не значит для вас.

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

Вам не обязательно быть "первым испытанием" для этого мышления, но это, как правило, самый эффективный способ добраться туда. Когда вы делаете TDD, вы блокируете себя в течение двух-трех минут цикла Red Green Refactor. Ни в коем случае вы не можете остановиться и уйти, и у вас будет полный беспорядок на руках, что займет час, чтобы отладить и вернуть обратно.

Кроме того, ваш unit test является другим точка отказа...

Успешный тест - это тот, который демонстрирует сбой в системе. Пробный тест предупредит вас об ошибке в логике теста или в логике вашей системы. Цель ваших тестов - сломать ваш код или доказать, что работает один сценарий.

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

Что мы получаем здесь?

Конечно, есть определенная польза для этого. Michael Feathers определяет "устаревший код" как "непроверенный код". Когда вы примете такой подход, вы узакониваете каждое изменение, которое вы делаете на свою кодовую базу. Это более строгое, чем использование тестов, но когда дело доходит до поддержания большой базы кода, оно платит за себя.

Говоря о Перьях, есть два больших ресурса, которые вы должны проверить в отношении этого:

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

[I] f цена скидки неверна, тестовая группа все равно найдет проблему, как тестирование модулей сохраняло какую-либо работу?

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

Что мне здесь не хватает? Пожалуйста, научите мне нравится TDD, поскольку у меня тяжелая время, принимающее его как полезное до сих пор. я хочу тоже, потому что я хочу остаться прогрессивный, но он просто не делает смысл для меня.

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

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

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

Клавиатура разработчика - это место, где резина встречает дорогу. Если спецификация ошибочна, и вы не поднимаете на ней флаг, тогда весьма вероятно, что вас обвинят в этом. Или, по крайней мере, ваш код будет. Трудно придерживаться дисциплины и строгости, связанные с тестированием. Это совсем не легко. Это требует практики, много обучения и много ошибок. Но в конце концов он окупится. В быстро развивающемся, быстро меняющемся проекте это единственный способ, которым вы можете спать по ночам, независимо от того, замедляет ли он вас.

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

Ответ 8

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

Как тестирование будет стоить усилий? По моему опыту, по крайней мере, четыре способа, по крайней мере, при разработке, основанном на тестах:

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

Ответ 9

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

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

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

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

Ответ 10

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

Ответ 11

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

Ответ 12

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

Что обычно легче увидеть с чем-то более чем тривиальным примером... и с тривиальными примерами, ну, если вы каким-то образом испортите unit test, человек, просматривающий его, поймает ошибку в тесте или ошибку в кода или обоих. (Они проверяются, правда?) Поскольку указывает tvanfosson, модульное тестирование - это всего лишь одна часть плана SQA.

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

Ответ 13

Я вижу вашу точку зрения, но она явно завышена.

Ваш аргумент в основном: тесты вводят неудачу. Поэтому тесты плохо/тратят время.

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

TDD предполагает: Больше тестов = Меньшая ошибка.

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

Ответ 14

Здесь может помочь еще больше автоматизации! Да, для написания модульных тестов может быть много работы, поэтому используйте некоторые инструменты, чтобы помочь вам. Посмотрите на что-то вроде Pex, от Microsoft, если вы используете .Net Он автоматически создаст для вас комплекты модульных тестов, изучив ваш код. Он придумает тесты, которые дают хороший охват, пытаясь охватить все пути через ваш код.

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

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

Ответ 15

Я немного подумал о хорошем способе ответить на этот вопрос и хотел бы провести параллель с научным методом. ИМО, вы можете перефразировать этот вопрос: "Как вы экспериментируете?"

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

Итак, как эксперименты, мы не описываем справедливость a unit test в зависимости от того, проходит ли она сам unit test. Наряду с другими модульными тестами он описывает предположения, которые мы делаем о тестируемой системе. Кроме того, как и эксперименты, мы пытаемся удалить столько сложностей, сколько можем, из того, что мы тестируем. "Как можно проще, но не проще".

В отличие от экспериментов, у нас есть трюк в нашем рукаве, чтобы проверить, что наши тесты действительны, а не только сходящаяся валидность. Мы можем искусно представить ошибку, которую, как мы знаем, должны быть пойманы тестом и посмотреть, действительно ли тест действительно терпит неудачу. (Если бы мы могли сделать это в реальном мире, мы бы гораздо меньше зависели от этой конвергентной действительности!). Более эффективным способом сделать это является то, что ваш тест завершился неудачей перед его внедрением (красный шаг в Red, Green, Refactor).

Ответ 16

При написании тестов вам нужно использовать правильную парадигму.

  • Начните с начала написания тестов.
  • Удостоверьтесь, что они не могут начать с.
  • Получить их.
  • Проверка кода перед тем, как вы проверите свой код (убедитесь, что тесты проверены.)

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

Ответ 17

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

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