Охват кода тестирования подразделения - У вас есть 100% покрытие? -- unit-testing поле с участием code-coverage пол Связанный проблема

Unit testing code coverage - do you have 100% coverage?


46
vote

проблема

русский

Произобрали ли тесты устройства 100% Code Coverage? Да или нет, а почему или почему нет.

Английский оригинал

Do your unit tests constitute 100% code coverage? Yes or no, and why or why not.

</div
     
   
   

Список ответов

60
 
vote

Нет по нескольким причинам:

    .
  • Это действительно дорого достичь 100% охвата, по сравнению с 90% или 95% за выгоду, которое не очевидно.
  • Даже с 100% покрытия, ваш код <сильный> не идеальный. Взгляните на этот метод (на самом деле это зависит от того, о каком виде покрытия вы говорите о - Охват филиала , Line Castage ...):


 <код> public static String foo(boolean someCondition) {     String bar = null;     if (someCondition) {         bar = "blabla";     }     return bar.trim(); }   

и тест на единицу:

 <код> assertEquals("blabla", foo(true));   

Тест добится успеха, и вашему покрытию кода на 100%. Однако, если вы добавите еще один тест:

 <код> assertEquals("blabla", foo(false));   

Тогда вы получите <код> NullPointerException . И как вы были на 100% с первым тестом, вы бы не обязательно написали второй!

Как правило, я считаю, что критический код должен быть покрыт почти на 100%, а другой код может быть покрыт при 85-90%

 

No for several reasons :

  • It is really expensive to reach the 100% coverage, compared to the 90% or 95% for a benefit that is not obvious.
  • Even with 100% of coverage, your code is not perfect. Take a look at this method (in fact it depends on which type of coverage you are talking about - branch coverage, line coverage...):


public static String foo(boolean someCondition) {     String bar = null;     if (someCondition) {         bar = "blabla";     }     return bar.trim(); } 

and the unit test:

assertEquals("blabla", foo(true)); 

The test will succeed, and your code coverage is 100%. However, if you add another test:

assertEquals("blabla", foo(false)); 

then you will get a NullPointerException. And as you were at 100% with the first test, you would have not necessarily write the second one!

Generally, I consider that the critical code must be covered at almost 100%, while the other code can be covered at 85-90%

</div
 
 
         
         
37
 
vote

Для всех 90% покрытия тестера:

Проблема с этим, так это то, что на 10% сложно для тестирования код также является не тривиальным кодом, который содержит 90% ошибок! Это заключение, которое я получил эмпирически после многих лет TDD.

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

Но также:

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

To all the 90% coverage tester:

The problem with doing so is that the 10% hard to test code is also the not-trivial code that contains 90% of the bug! This is the conclusion I got empirically after many years of TDD.

And after all this is pretty straightforward conclusion. This 10% hard to test code, is hard to test because it reflect tricky business problem or tricky design flaw or both. These exact reasons that often leads to buggy code.

But also:

  • 100% covered code that decreases with time to less than 100% covered often pinpoints a bug or at least a flaw.
  • 100% covered code used in conjunction with contracts, is the ultimate weapon to lead to live close to bug-free code. Code Contracts and Automated Testing are pretty much the same thing
  • When a bug is discovered in 100% covered code, it is easier to fix. Since the code responsible for the bug is already covered by tests, it shouldn't be hard to write new tests to cover the bug fix.
</div
 
 
23
 
vote

Нет, потому что есть практическое компромисс между идеальными тестами на единицу и фактически заканчивая проектом :)

 

No, because there is a practical trade-off between perfect unit tests and actually finishing a project :)

</div
 
 
15
 
vote

Редко практично, чтобы получить 100% кодовое покрытие в нетривиальной системе. Большинство разработчиков, которые пишут тесты подразделения, стреляют в середину до высоких 90-х годов.

Автоматизированный инструмент тестирования, как PEX может помочь увеличить покрытие кода. Он работает, поиск труднодоступных краев.

 

It is seldom practical to get 100% code coverage in a non-trivial system. Most developers who write unit tests shoot for the mid to high 90's.

An automated testing tool like Pex can help increase code coverage. It works by searching for hard-to-find edge cases.

</div
 
 
 
 
10
 
vote

Да, мы делаем.

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

Мы используем Ruby на рельсах для моего текущего проекта. Ruby - это очень "Tmockable" в том, что вы можете заглушить / издеваться от больших кусков вашего кода, без необходимости создавать чрезмерное сложное состав класса и конструкции строительства, которые вам придется делать на других языках.

.

, который сказал, у нас есть только 100%, линия покрытия (в основном то, что rcov дает вам). Вы все еще должны подумать о тестировании всех необходимых ветвей.

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

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

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

делает это ценность add? Сначала я был скептически скептически, но я могу честно сказать, что да, это делает. Не в первую очередь, потому что вы полностью проверены код (хотя это, безусловно, выгодно), но больше с точки зрения написания простого кода, который легко проверить и разум. Если вы знаете, что вы есть , чтобы иметь 100% тестовое покрытие, вы перестаете написать чрезмерно сложное, если / else / while / попробуйте / поймать чудовищности и держать его простой глупым.

 

Yes we do.

It depends on what language and framework you're using as to how easy that is to achieve though.

We're using Ruby on Rails for my current project. Ruby is very "mockable" in that you can stub/mock out large chunks of your code without having to build in overly complicated class composition and construction designs that you would have to do in other languages.

That said, we only have 100% line coverage (basically what rcov gives you). You still have to think about testing all the required branches.

This is only really possible if you include it from the start as part of your continuous integration build, and break the build if coverage drops below 100% - prompting developers to immediately fix it. Of course you could choose some other number as a target, but if you're starting fresh, there isn't much difference for the effort to get from 90% to 100%

We've also got a bunch of other metrics that break the build if they cross a given threshold as well (cyclomatic complexity, duplication for example) these all go together and help reinforce each other.

Again, you really have to have this stuff in place from the start to keep working at a strict level - either that or set some target you can hit, and gradually ratchet it up till you get to a level you're happy with.

Does doing this add value? I was skeptical at first, but I can honestly say that yes it does. Not primarily because you have thoroughly tested code (although that is definitely a benefit), but more in terms of writing simple code that is easy to test and reason about. If you know you have to have 100% test coverage, you stop writing overly complex if/else/while/try/catch monstrosities and Keep It Simple Stupid.

</div
 
 
 
 
9
 
vote

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

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

Поскольку он был в VC6 (C ++ + MFC), я определил два макроса:

 <код> #define TCOV ASSERT(FALSE) #define _COV ASSERT(TRUE)   

, а затем я посыпал

 <код> TCOV;   

На протяжении всего кода на каждом отдельном пути я мог найти, а в каждой рутине. Затем я пробежал программу под отладчиком, и каждый раз он ударил <код> TCOV , он остановился бы. Я бы посмотрел на код для каких-либо очевидных проблем, а затем редактировать его на <код> _COV , затем продолжить. Код будет перекомпирован на лету и перейти к следующему <код> TCOV . Таким образом, я медленно, трубопрочно, устраняет достаточно <код> TCOV утверждений, поэтому он будет работать «нормально».

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

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

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

 

What I do when I get the chance is to insert statements on every branch of the code that can be grepped for and that record if they've been hit, so that I can do some sort of comparison to see which statements have not been hit. This is a bit of a chore, so I'm not always good about it.

I just built a small UI app to use in charity auctions, that uses MySQL as its DB. Since I really, really didn't want it to break in the middle of an auction, I tried something new.

Since it was in VC6 (C++ + MFC) I defined two macros:

#define TCOV ASSERT(FALSE) #define _COV ASSERT(TRUE) 

and then I sprinkled

TCOV; 

throughout the code, on every separate path I could find, and in every routine. Then I ran the program under the debugger, and every time it hit a TCOV, it would halt. I would look at the code for any obvious problems, and then edit it to _COV, then continue. The code would recompile on the fly and move on to the next TCOV. In this way, I slowly, laboriously, eliminated enough TCOV statements so it would run "normally".

After a while, I grepped the code for TCOV, and that showed what code I had not tested. Then I went back and ran it again, making sure to test more branches I had not tried earlier. I kept doing this until there were no TCOV statements left in the code.

This took a few hours, but in the process I found and fixed several bugs. There is no way I could have had the discipline to make and follow a test plan that would have been that thorough. Not only did I know I had covered all branches, but it had made me look at every branch while it was running - a very good kind of code review.

So, whether or not you use a coverage tool, this is a good way to root out bugs that would otherwise lurk in the code until a more embarrasing time.

</div
 
 
     
     
6
 
vote

Я лично нахожу 100% тестовое покрытие, чтобы быть проблематичным на нескольких уровнях. Прежде всего, вы должны убедиться, что вы набираете ощутимый, экономия стоимостью от модульных тестов, которые вы пишете. Кроме того, тесты единиц, как и любой другой код, являются кодом. Это означает, что он, как и любой другой код, должен быть проверен для правильности и поддерживается. Это дополнительное время проверки дополнительного кода для правильности и поддержания его и сохранения этих тестов, действующих в ответ на изменения в бизнес-коде, добавляет стоимость. Достижение 100% тестового покрытия и обеспечение того, чтобы вы тестировали, что ваш код так же тщательно, насколько это возможно, является похвалым усилением, но достижение его на любой стоимости ... Ну, часто слишком дорого.

Есть много раз при охватывании ошибок и достоверности проверки, которые находятся для покрытия бахрома или чрезвычайно редко, но, безусловно, возможные, исключительные случаи, являются примером кода, который не обязательно должен быть покрыт. Количество time , <сильные> усилие (и, в конечном счете деньги ), которые должны быть инвестированы в достижение освещения такой редкой бахрома Случаи часто расточительны в свете других потребностей бизнеса. Свойства часто являются частью кода, которые, особенно с C # 3.0, не нужно тестировать как большинство, если не все, свойствам ведут себя точно так же, и чрезмерно просты (возвращается или устанавливает одно утверждение.) Инвестирование огромных количеств Тесты на упаковку временной упаковки около тысяч свойств вполне вероятно, что лучше инвестировать где-то еще, где больше, более ценный ощутимый возврат этой инвестиции может быть реализован.

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

Конечная цель с тестированием не должна быть действительно добиться максимального покрытия кода. Конечная цель должна быть достижения наибольшей ценности на единицу времени, вложенного в тесты в письменном виде, при этом как можно больше охватывало в то время как можно больше. Лучший способ достичь этого - это взять подход BDD: укажите ваши проблемы, определите свой контекст, и проверить ожидаемые результаты для любого элемента «Поведение» ... не единица.)

 

I personally find 100% test coverage to be problematic on multiple levels. First and foremost, you have to make sure you are gaining a tangible, cost-saving benefit from the unit tests you write. In addition, unit tests, like any other code, are CODE. That means it, just like any other code, must be verified for correctness and maintained. That additional time verifying additional code for correctness, and maintaining it and keeping those tests valid in response to changes to business code, adds cost. Achieving 100% test coverage and ensuring you test you're code as thoroughly as possible is a laudable endeavor, but achieving it at any cost...well, is often too costly.

There are many times when covering error and validity checks that are in place to cover fringe or extremely rare, but definitely possible, exceptional cases are an example of code that does not necessarily need to be covered. The amount of time, effort (and ultimately money) that must be invested to achieve coverage of such rare fringe cases is often wasteful in light of other business needs. Properties are often a part of code that, especially with C# 3.0, do not need to be tested as most, if not all, properties behave exactly the same way, and are excessively simple (single-statement return or set.) Investing tremendous amounts of time wrapping unit tests around thousands of properties could quite likely be better invested somewhere else where a greater, more valuable tangible return on that investment can be realized.

Beyond simply achieving 100% test coverage, there are similar problems with trying to set up the "perfect" unit. Mocking frameworks have progressed to an amazing degree these days, and almost anything can be mocked (if you are willing to pay money, TypeMock can actually mock anything and everything, but it does cost a lot.) However, there are often times when dependencies of your code were not written in a mock-able way (this is actually a core problem with the vast bulk of the .NET framework itself.) Investing time to achieve the proper scope of a test is useful, but putting in excessive amounts of time to mock away everything and anything under the face of the sun, adding layers of abstraction and interfaces to make it possible, is again most often a waste of time, effort, and ultimately money.

The ultimate goal with testing shouldn't really be to achieve the ultimate in code coverage. The ultimate goal should be achieving the greatest value per unit time invested in writing unit tests, while covering as much as possible in that time. The best way to achieve this is to take the BDD approach: Specify your concerns, define your context, and verify the expected outcomes occur for any piece of behavior being developed (behavior...not unit.)

</div
 
 
5
 
vote

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

 

No because I spent my time adding new features that help the users rather than tricky to write obscure tests that deliver little value. I say unit test the big things, subtle things and things that are fragile.

</div
 
 
5
 
vote

На новом проекте I практикую TDD и поддерживать 100% линии покрытия. Это в основном происходит естественно через TDD. Охват пробелы обычно стоит внимания и легко заполнены. Если инструмент покрытия, который я использую, при условии, что охват ветви или что-то еще, что я обратил внимание на это, хотя я никогда не видел, что я никогда не видел, что покрытие ветви, скажи мне что-нибудь, вероятно, потому что TDD попал там первым.

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

Мое отношение определенно поддерживается, работая в Ruby в течение некоторого времени, где есть отличные тестовые рамки и простые двойные разум. 100% покрытие также легко в Python. Возможно, мне придется снизить свои стандарты в среде с меньшими подданными инструментами.

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

 

On a new project I practice TDD and maintain 100% line coverage. It mostly occurs naturally through TDD. Coverage gaps are usually worth the attention and are easily filled. If the coverage tool I'm using provided branch coverage or something else I'd pay attention to that, although I've never seen branch coverage tell me anything, probably because TDD got there first.

My strongest argument for maintaining 100% coverage (if you care about coverage at all) is that it's much easier to maintain 100% coverage than to manage less than 100% coverage. If you have 100% coverage and it drops, you immediately know why and can easily fix it, because the drop is in code you've just been working on. But if you settle for 95% or whatever, it's easy to miss coverage regressions and you're forever re-reviewing known gaps. It's the exact reason why current best practice requires one's test suite to pass completely. Anything less is harder, not easier, to manage.

My attitude is definitely bolstered by having worked in Ruby for some time, where there are excellent test frameworks and test doubles are easy. 100% coverage is also easy in Python. I might have to lower my standards in an environment with less amenable tools.

I would love to have the same standards on legacy projects, but I've never found it practical to bring a large application with mediocre coverage up to 100% coverage; I've had to settle for 95-99%. It's always been just too much work to go back and cover all the old code. This does not contradict my argument that it's easy to keep a codebase at 100%; it's much easier when you maintain that standard from the beginning.

</div
 
 
4
 
vote

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

 

I generally write unit tests just as a regression-prevention method. When a bug is reported that I have to fix, I create a unit test to ensure that it doesn't re-surface in the future. I may create a few tests for sections of functionality I have to make sure stay intact (or for complex inter-part interactions), but I usually want for the bug fix to tell me one is necessary.

</div
 
 
4
 
vote

Мне обычно удается ударить 93 .. 100% с моим покрытием, но я больше не стремимся на 100%. Раньше я делал это, и хотя он выполнен, это не стоит больше усилий за определенным моментом, потому что тестирование слепо очевидно, как обычно не нужно. Хороший пример этого может быть истинная ветвь оценки следующего кода reft

 <код> public void method(boolean someBoolean) {     if (someBoolean) {         return;     } else {         /* do lots of stuff */      } }   

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

 

I usually manage to hit 93..100% with my coverage but I don't aim for 100% anymore. I used to do that and while it's doable, it's not worth the effort beyond a certain point because testing blindly obvious usually isn't needed. Good example of this could be the true evaluation branch of the following code snipped

public void method(boolean someBoolean) {     if (someBoolean) {         return;     } else {         /* do lots of stuff */      } } 

However what's important to achieve is to as close to 100% coverage on functional parts of the class as possible since those are the dangerous waters of your application, the misty bog of creeping bugs and undefined behaviour and of course the money-making flea circus.

</div
 
 
       
       
4
 
vote

from TED Neward Блог .

К этому моменту вовремя большинство разработчиков, по крайней мере, слышали, если не считают принятие мазохистского тестирования мема. Партнеры Nfjs'ers Stuart Halloway и Justin Gehtland создали консультационную фирму, релевантность, которые устанавливают высокий бар в качестве корпоративного культурного стандарта: 100% тестовое покрытие их кода.

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

Если вы нацелете свою стрелку на солнце, она будет летать выше и дальше, чем если вы нацелете на землю.

 

From Ted Neward blog.

By this point in time, most developers have at least heard of, if not considered adoption of, the Masochistic Testing meme. Fellow NFJS'ers Stuart Halloway and Justin Gehtland have founded a consultancy firm, Relevance, that sets a high bar as a corporate cultural standard: 100% test coverage of their code.

Neal Ford has reported that ThoughtWorks makes similar statements, though it's my understanding that clients sometimes put accidental obstacles in their way of achieving said goal. It's ambitious, but as the ancient American Indian proverb is said to state,

If you aim your arrow at the sun, it will fly higher and farther than if you aim it at the ground.

</div
 
 
2
 
vote

У меня есть только 100% покрытие на новых кусках кода, которые были написаны с помощью em> firetability . С надлежащей инкапсуляцией каждый класс и функция могут иметь функциональные тесты единиц, которые одновременно дают около 100% покрытия. Тогда просто вопрос добавления дополнительных тестов, которые охватывают некоторые краевые случаи, чтобы получить вам на 100%.

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

 

I only have 100% coverage on new pieces of code that have been written with testability in mind. With proper encapsulation, each class and function can have functional unit tests that simultaneously give close to 100% coverage. It's then just a matter of adding some additional tests that cover some edge cases to get you to 100%.

You shouldn't write tests just to get coverage. You should be writing functional tests that test correctness/compliance. By a good functional specification that covers all grounds and a good software design, you can get good coverage for free.

</div
 
 
2
 
vote

Да, у меня были проекты, которые имели 100% покрытие линии. Смотрите мой ответ на подобное подобное Вопрос.

Вы CAN Получите 100% Line Castage, но, поскольку другие указали здесь, так и в других местах в Интернете, возможно, только минимум. Когда вы рассматриваете путь и охват филиала, есть намного больше работы.

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

 

Yes, I have had projects that have had 100% line coverage. See my answer to a similar question.

You can get 100% line coverage, but as others have pointed out here on SO and elsewhere on the internet its maybe only a minimum. When you consider path and branch coverage, there's a lot more work to do.

The other way of looking at it is to try to make your code so simple that its easy to get 100% line coverage.

</div
 
 
2
 
vote

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

Ключевой вопрос, который нужно спросить: «Какое влияние влияние, если программное обеспечение не удается (производит неправильный результат)?». В большинстве случаев воздействие ошибки относительно низкое. Например, может быть, вам нужно исправить код в течение нескольких дней и повторить что-то. Однако, если бы воздействие «Кто-то может умереть за 120 секунд», то это огромное влияние, и у вас должно быть много тестового покрытия больше, чем всего 100% отчет о раскрытии.

Я веду Основная инфраструктура Инициатива лучших практик для фундамента Linux. Мы DO имеют 100% охвату заявления, но я бы не сказал, что это было строго необходимо. Долгое время мы были очень близки к 100%, и просто решили сделать это последний маленький процент. Мы не могли оправдать последние несколько процентов на инженерных основаниях, хотя; Эти последние несколько процентов были добавлены исключительно как «гордость изготовления». Я получаю очень небольшую дополнительную часть ума от 100% покрытия, но на самом деле это не было необходимости. Мы были более чем на 90% заявления о постановлении только от обычных испытаний, и это было хорошо для наших целей. Тем не менее, мы хотим, чтобы программное обеспечение было рок -плохо, и имея 100% охват заявления, помогло нам туда добраться. Также было легче получить 100% охват заявления сегодня.

Все еще полезно для измерения покрытия, даже если вам не нужно 100%. Если ваши тесты не имеют достойного покрытия, вы должны быть обеспокоены. Плохой тестовый люкс может иметь хорошее покрытие выписки, но если у вас нет хорошего освещения операторов, то по определению у вас есть плохой тестовый люкс. Насколько вам нужно компромисс: каковы риски (вероятность и воздействие) из программного обеспечения, которое полностью непроверено? По определению, это более вероятно, имеет ошибки (вы не проверили его!), Но если вы и ваши пользователи могут жить с этими рисками (вероятность и воздействие), все в порядке. Для многих проектов по снижению воздействия, я думаю, что 80% -90% покрытие утверждения в порядке, с лучшего лучше быть лучше.

С другой стороны, если люди могут умереть от ошибок в вашем программном обеспечении, то 100% покрытие оператора недостаточно. Я, по крайней мере, добавит охват филиала, и, возможно, больше, чтобы проверить качество ваших тестов. Стандарты, такие как do-178c (для воздушных систем). Возьмите этот подход - если неудача Незначительное, нет большого значения, но если неудача может быть катастрофической, то требуется гораздо более строгое тестирование. Например, DO-178C требует MC / DC Castage для наиболее важнейшего программного обеспечения ( Программное обеспечение, которое может быстро убить людей, если это ошибается). MC / DC намного более напряженно, чем охват от оператора или даже покрытие филиала.

 

In many cases it's not worth getting 100% statement coverage, but in some cases, it is worth it. In some cases 100% statement coverage is far too lax a requirement.

The key question to ask is, "what's the impact if the software fails (produces the wrong result)?". In most cases, the impact of a bug is relatively low. For example, maybe you have to go fix the code within a few days and rerun something. However, if the impact is "someone might die in 120 seconds", then that's a huge impact, and you should have a lot more test coverage than just 100% statement coverage.

I lead the Core Infrastructure Initiative Best Practices Badge for the Linux Foundation. We do have 100% statement coverage, but I wouldn't say it was strictly necessary. For a long time we were very close to 100%, and just decided to do that last little percent. We couldn't really justify the last few percent on engineering grounds, though; those last few percent were added purely as "pride of workmanship". I do get a very small extra piece of mind from having 100% coverage, but really it wasn't needed. We were over 90% statement coverage just from normal tests, and that was fine for our purposes. That said, we want the software to be rock-solid, and having 100% statement coverage has helped us get there. It's also easier to get 100% statement coverage today.

It's still useful to measure coverage, even if you don't need 100%. If your tests don't have decent coverage, you should be concerned. A bad test suite can have good statement coverage, but if you don't have good statement coverage, then by definition you have a bad test suite. How much you need is a trade-off: what are the risks (probability and impact) from the software that is totally untested? By definition it's more likely to have errors (you didn't test it!), but if you and your users can live with those risks (probability and impact), it's okay. For many lower-impact projects, I think 80%-90% statement coverage is okay, with better being better.

On the other hand, if people might die from errors in your software, then 100% statement coverage isn't enough. I would at least add branch coverage, and maybe more, to check on the quality of your tests. Standards like DO-178C (for airborne systems) take this approach - if a failure is minor, no big deal, but if a failure could be catastrophic, then much more rigorous testing is required. For example, DO-178C requires MC/DC coverage for the most critical software (the software that can quickly kill people if it makes a mistake). MC/DC is way more strenuous than statement coverage or even branch coverage.

</div
 
 
0
 
vote

Здесь есть много хорошей информации, я просто хотел добавить еще несколько преимуществ, которые я нашел при нацелении на 100% кодовое покрытие в прошлом

    .
  • это помогает уменьшить сложность кода

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

    .
  • это помогает развить хорошую тестовую гранулярность

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

 

There's a lot of good information here, I just wanted to add a few more benefits that I've found when aiming for 100% code coverage in the past

  • It helps reduce code complexity

Since it is easier to remove a line than it is to write a test case, aiming for 100% coverage forces you to justify every line, every branch, every if statement, often leading you to discover a much simpler way to do things that requires fewer tests

  • It helps develop good test granularity

You can achieve high test coverage by writing lots of small tests testing tiny bits of implementation as you go. This can be useful for tricky bits of logic but doing it for every piece of code no matter how trivial can be tedious, slow you down and become a real maintenance burden also making your code harder to refactor. On the other hand, it is very hard to achieve good test coverage with very high level end to end behavioural tests because typically the thing you are testing involves many components interacting in complicated ways and the permutations of possible cases become very large very quickly. Therefore if you are practical and also want to aim for 100% test coverage, you quickly learn to find a level of granularity for your tests where you can achieve a high level of coverage with a few good tests. You can achieve this by testing components at a level where they are simple enough that you can reasonably cover all the edge cases but also complicated enough that you can test meaningful behaviour. Such tests end up being simple, meaningful and useful for identifying and fixing bugs. I think this is a good skill and improves code quality and maintainability.

</div
 
 
0
 
vote

Некоторое время назад я сделал небольшой анализ охват В реализации JUNIT , код написан и проверены, среди прочего, Кент Бек и Дэвид Сафф.

Из выводов:

Применение охвата линии к одному из лучших проверенных проектов в мире, вот что мы узнали:

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

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

  3. нет причин иметь методы с более чем 2-3 непроверенными линиями кода.

  4. Обычные подозреваемые (простой код, мертвый код, плохое поведение погоды, ...) соответствуют около 5% неокрытого кода.

Таким образом, следует следить за освещением линии? Не все команды развития не делают, и даже в проекте JUnit не станет стандартной практикой. Однако, если вы хотите быть такими же хорошими, как разработчики Junit, нет причин, почему ваше покрытие линии будет ниже 95%. И мониторинг покрытия - это простой первый шаг, чтобы проверить только что.

 

A while ago I did a little analysis of coverage in the JUnit implementation, code written and tested by, among others, Kent Beck and David Saff.

From the conclusions:

Applying line coverage to one of the best tested projects in the world, here is what we learned:

  1. Carefully analyzing coverage of code affected by your pull request is more useful than monitoring overall coverage trends against thresholds.

  2. It may be OK to lower your testing standards for deprecated code, but do not let this affect the rest of the code. If you use coverage thresholds on a continuous integration server, consider setting them differently for deprecated code.

  3. There is no reason to have methods with more than 2-3 untested lines of code.

  4. The usual suspects (simple code, dead code, bad weather behavior, …) correspond to around 5% of uncovered code.

In summary, should you monitor line coverage? Not all development teams do, and even in the JUnit project it does not seem to be a standard practice. However, if you want to be as good as the JUnit developers, there is no reason why your line coverage would be below 95%. And monitoring coverage is a simple first step to verify just that.

</div
 
 

Связанный проблема

1  Проблемы PHPUNIT Setup и PHP  ( Phpunit setup and php directory issues ) 
Я знаю, что это, вероятно, больше спрашивает, но я не использовал PHP в действительно долгое время, и я вновь борюсь со своим поведением пути и включает в себ...

2  Неспособность создавать «монгомаксиновую боб», когда тестирование единицы с FOGO  ( Failing to create mongomappingcontext bean when unit testing with fongo ) 
Я в настоящее время устанавливаю тест подразделения для проекта, на котором я работаю, и я бегаю в немного стены. Проект, на котором я работаю, использует Mon...

7  Ошибка тестирования блока - адаптер теста устройства не удалось подключиться к источнику данных или для чтения данных  ( Unit testing error the unit test adapter failed to connect to the data source ) 
Я использую VSTS 2K8, и я настроил модульный тестовый проект. В нем у меня есть тестовый класс с методом, который делает простое утверждение. Я использую элек...

1  Остановите ошибки Debug MSVC ++ от блокировки текущего процесса?  ( Stop msvc debug errors from blocking the current process ) 
Любые неудачные утверждения Assert в Windows приводят к появлению подразделения ниже и замораживают выполнение приложений. Я понимаю, что это ожидаемое поведе...

3  ClassnotfoundException с Junit при использовании класса. Формушка (..). GetInstance в то время как новые () работает нормально  ( Classnotfoundexception with junit when using class forname getinstance while ) 
Я получаю <код> ClassNotFoundException при запуске тестов с JUNIT: У меня есть куча тестов, которые тестируют класс основной. Основным классом имеет метод,...

8  Python Unittest, сделай что-то только в случае неудачно  ( Python unittest do something only if test fails ) 
При использовании unittest Библиотека из Python 3 Я хотел бы выполнить некоторые действия, только если тест не удается (но это должно быть на уровне класса,...

1  Затмение - не в состоянии запустить тесты Testng  ( Eclipse not able to run testng tests ) 
Я использую Eclipse kepler 4.3.2 и установил Testng Plug-in для него, но не могу запускать программу Testng, поскольку консоль Testng отображается ниже ошибки...

4  Использование делегатов вместо интерфейсов для развязки. Хорошая идея?  ( Using delegates instead of interfaces for decoupling good idea ) 
При написании приложений GUI я использую класс верхнего уровня, который «Controls» или «координирует» приложение. Класс верхнего уровня будет нести ответствен...

1  N Установление алфавитного заказа  ( N unit alphabetical order assertion ) 
У меня есть поле поиска на веб-сайте, который возвращает результаты поиска, на основе ключевого слова (хранение их в виде списка в C #) Есть параметры фильт...

4  Тест на единицу с файлами Система зависимости - скрытые файлы  ( Unit test with files system dependency hidden files ) 
Я пишу «Total Commander», как приложение в Java. Здесь вполне очевидная зависимость файловой системы здесь. Я хочу установить тестирование его. Я создал стр...

0  Проверьте плоский файл содержимого и формат в Java  ( Test flat file content and format in java ) 
Я должен отправить плоский файл во внешнюю систему. Содержание файла пример приведено ниже: <код> START 20150602 HEADER 100.00USD PRODUCT TEST1 ...

24  Visual Studio Build Tests работает медленнее на TFS  ( Visual studio unit tests running slower on tfs build ) 
Мой проект имеет 1000+ узлов, которые, в локальной машине, все запускаются менее чем за 10 секунд. Но когда они работают по сборке TFS, некоторые тесты проход...

0  Агрегатное тестовое утверждение от конечного результата или проверки того, были ли параметры называются с помощью MOQ  ( Unit test assert against end result or verifying whether the parameters were cal ) 
Ниже приведен класс (Class1), который я хочу проверить, но я не полностью удовлетворен своим тестом монтажа. Пожалуйста, смотрите ниже образцы кода. Система...

1  Как использовать дженерики, содержащие частные типы с тестами визуальных студийных единиц  ( How to use generics containing private types with visual studio unit tests ) 
У меня есть проблема с классом, который я пытаюсь проверить. Я объявил частный Enum, и я использую это в общем словаре в коде. Этот Enum не имеет значения за ...

0  CXXTESTESTGEN.PY бросить синтаксисную ошибку  ( Cxxtestgen py throw a syntax error ) 
Я следую по учебнику на Интеграция CXXTEST Visual Studio и я посмотрел на Google, но ничего не нашел. Когда я пытаюсь обедать базовый тест с CXXTEST и Vis...

Связанный проблема

1  Проблемы PHPUNIT Setup и PHP 
2  Неспособность создавать «монгомаксиновую боб», когда тестирование единицы с FOGO 
7  Ошибка тестирования блока - адаптер теста устройства не удалось подключиться к источнику данных или для чтения данных 
1  Остановите ошибки Debug MSVC ++ от блокировки текущего процесса? 
3  ClassnotfoundException с Junit при использовании класса. Формушка (..). GetInstance в то время как новые () работает нормально 
8  Python Unittest, сделай что-то только в случае неудачно 
1  Затмение - не в состоянии запустить тесты Testng 
4  Использование делегатов вместо интерфейсов для развязки. Хорошая идея? 
1  N Установление алфавитного заказа 
4  Тест на единицу с файлами Система зависимости - скрытые файлы 
0  Проверьте плоский файл содержимого и формат в Java 
24  Visual Studio Build Tests работает медленнее на TFS 
0  Агрегатное тестовое утверждение от конечного результата или проверки того, были ли параметры называются с помощью MOQ 
1  Как использовать дженерики, содержащие частные типы с тестами визуальных студийных единиц 
0  CXXTESTESTGEN.PY бросить синтаксисную ошибку