{"id":10105,"date":"2018-08-15T04:58:51","date_gmt":"2018-08-15T04:58:51","guid":{"rendered":"http:\/\/abstracta.us\/blog\/?p=10105"},"modified":"2025-05-05T21:23:41","modified_gmt":"2025-05-05T21:23:41","slug":"webinar-summary-use-automation-increase-test-coverage","status":"publish","type":"post","link":"https:\/\/abstracta.us\/blog\/software-testing\/webinar-summary-use-automation-increase-test-coverage\/","title":{"rendered":"Webinar Summary: How to Use Automation to Increase Test Coverage"},"content":{"rendered":"

Testing is like sweeping, it’s better with a Roomba\u00a0<\/span><\/h1>\n

Recently, I had the pleasure of presenting the concept of test coverage and its relationship with automation for a SmartBear <\/span>webinar<\/span><\/a> featuring <\/span>CrossBrowserTesting<\/span><\/a>. <\/span><\/p>\n

If you are someone who would rather read a blog post than watch a video, then this post is for you! As I did in the webinar, I\u2019ll explain the concept and limits of test coverage, present a very simple and useful strategy to increase it over time, and how you can employ automation with tools like CrossBrowserTesting.<\/span><\/p>\n

<\/span>Introduction to Test Coverage<\/span><\/strong><\/span><\/h2>\n

<\/span>What is Test Coverage?<\/span><\/strong><\/span><\/h3>\n

Many people say that test coverage is useful to measure the quality of testing, meaning, to say if the testing was good or bad. In my humble opinion, this way of seeing it creates some confusion. We should be careful with how we measure test coverage and how we interpret it.<\/span><\/p>\n

I prefer to think of the concept of test coverage as a measure of how much we examine a system with our testing based on certain criteria. <\/b><\/p>\n

And then, in a separate track, evaluate if it\u2019s good or not, and if it\u2019s enough or not, but not many people take the time to consider this.<\/span><\/p>\n

\"disk<\/a><\/p>\n

Remember this tool called Disk Defragmenter? A system utility, this tool arranges something in the disk. It moves disk sectors in order to make the disk more efficient and faster. At least, this is what I can recall!<\/span><\/p>\n

For me, this tool is showing coverage visually in a very clear way. You see a model of the disk, where it\u2019s clear what the total is, and how it was decomposed into smaller units. You can also see the percentage of progress, which is according to how many of those units have already been examined, and which ones still need to be examined. But, testers might never ask themselves, \u201cHow\u2019s the quality of the examination, how well are we examining it?\u201d<\/span><\/p>\n

So, back to testing. We need to model our system, and we need a criterion to decompose the system into different types of entities or elements, which will be the units that we are going to try to cover with our testing, and this is what we will be using as a measure of coverage: What is the percentage of units of our model that we test with respect to the total?<\/span><\/p>\n

Here it is clear that this measure can be useful to determine what is the progress, to see what other things still need to be examined (to increase the test coverage based on the chosen criterion), but not directly to say how great our testing is. <\/span><\/p>\n

Test coverage helps us know quantitatively the extent of our tests. It does not talk about testing quality nor system quality either!<\/b><\/p>\n

It\u2019s a great measuring stick, but even with 100% test coverage, the application isn\u2019t guaranteed to be 100% bug free. Even if you only manage to achieve 20% coverage, it may not necessarily be a bad thing. The ideal amount of test coverage to aim for should be based on your priorities and risk analysis.<\/p>\n

<\/span>Test Coverage is Like Sweeping<\/span><\/strong><\/span><\/h3>\n

This is another analogy I typically use to show what coverage means and its purpose. <\/span><\/p>\n

If you told me that you swept your whole house, I would need to know what is your criteria for considering the house covered! If you only included sweeping the bedrooms for your sweep coverage criteria, would the whole house be clean if you swept 100% of the bedrooms? From my point of view, you should also sweep the dining room, living room, and more!<\/span><\/p>\n

\"test<\/a><\/p>\n

Therefore, we must always be careful with test coverage and the associated criteria. We have to decide which criteria is relevant for our context. Talking about criteria helps us to understand what we are covering, and what we are not, which is a very useful thing. <\/span><\/p>\n

Also, how clean is the house if you have 100% coverage? Even if you did cover them, how clean are the bedrooms actually? It\u2019s like \u201crequirement coverage\u201d meaning that we covered all the <\/span>requirements<\/span><\/i> with our tests. But it doesn\u2019t tell us about how well we tested them. Right?<\/span><\/p>\n

I could have different criteria over time: I sweep the kitchen and my bedroom everyday, and once a week I sweep all the bedrooms, the bathroom and the dining room, and maybe spend extra time sweeping those hard to reach spots, because certainly there\u2019s a higher probability (aka risk!) that dust has accumulated in those places. So, I have different strategies for my bedroom, depending on the day, the context and my needs. <\/span><\/p>\n

This is something I can plan in order to have the best results with the optimal use of my energy and time. Can you see where I\u2019m going with this analogy? \ud83d\ude00 <\/span><\/p>\n

Replace the broom for tests and the house for code!<\/strong><\/p>\n

Not only is coverage useful to show progress, but it also gives ideas as to what other \u201cparts of the house need to be swept\u201d (thus expanding coverage). It also helps to know when to stop sweeping (according to the criteria, because I reached the goal defined in the plan).<\/span><\/p>\n

<\/span>Coverage Criteria<\/span><\/strong><\/span><\/h3>\n

As I mentioning since the beginning, the criteria is very important. <\/span><\/p>\n

There are different criteria, from different perspectives, and also we can say that some of them are more exhaustive than others. So we need to understand them in order to understand how deeply something was tested. We can say that certain criteria subsume others when any test set covering the first criterion also covers the second, meaning that it\u2019s deeper.<\/span><\/p>\n

For instance, taking into account the code perspective, covering all branches is deeper than covering all lines of code, because if we cover all branches we also cover all lines. So, the criteria named \u201cbranch coverage\u201d subsumes the one known as \u201cline coverage\u201d.<\/span><\/p>\n

<\/span>Types of Test Coverage<\/span><\/strong><\/span><\/h2>\n

<\/span>Code Coverage<\/span><\/strong><\/span><\/h3>\n

\"example<\/a><\/p>\n

Code coverage is the most popular metric for measuring test coverage for unit testing and there are different levels with different depths. For instance, the most popular one is \u201cline coverage\u201d which measures the number of lines covered by the test cases, reporting the total number of lines in the code and number of lines executed by tests. Essentially, it\u2019s the degree to which the source code of a program is executed when a test suite runs. <\/span><\/p>\n

This measurement can also be broken down into different levels; not only lines of code covered, but there are also branches, decisions inside logic constructors, some others. The criteria should be selected according to the criticality of the unit tested, or according to how frequently it changes. <\/span><\/p>\n

Remember that coverage give us hints of what else could be tested. With code coverage tools integrated with IDEs, it\u2019s easy to see which lines are not covered (the ones colored in red in the image above).<\/span><\/p>\n

Code coverage is very useful, following a white box approach, to add new unit tests to cover those lines or branches.<\/span><\/p>\n

<\/span>Data-Oriented Coverage<\/span><\/strong><\/span><\/h3>\n

With data-oriented coverage, we focus on the input and output parameters, each of them with their own domain (with a different spectrum of possible values that they can have). <\/span><\/p>\n

Applicable to both white and black box approaches, some typical examples are equivalence partition and boundary values and combinatorial testing.<\/span><\/p>\n

If we think about the values of different parameters, and we want to test all the possibilities, we will end up with a cartesian product, testing every possible combination.<\/span><\/p>\n

On the other hand, we can test less and go with \u201ceach choice\u201d coverage, which means that we choose each possible value at least once. There is also all-pairs or pair-wise combination, which is empirically said (according to some studies) to have the best cost-benefit relationship. \u00a0<\/span><\/p>\n

This is a great example to show that we need to plan the test coverage according to the risk levels and how much time we have for testing.<\/span><\/p>\n

<\/span>Others<\/span><\/strong><\/span><\/h3>\n

In addition to those previously mentioned, there are several more ways to cover the product that we are testing such as requirements coverage, different coverage when we model the logic or the behavior of a system with decision tables or decision trees, or with a state-machine. In the latter, we can consider for instance, having tests to cover all the states, or all the transitions, or all combinations of input and output transitions for each state, or maybe more. There is always an error theory behind every test coverage criterion.<\/span><\/p>\n

<\/span>Don’t Forget Platform Related<\/span><\/strong><\/span><\/h3>\n

\"different<\/a><\/p>\n

Additionally, there are other kinds of test coverage that are not related to lines of code or test data. One example is generated by mobile fragmentation, which concerns questions like: are we covering the main mobile devices, operating systems, and screen sizes? <\/span><\/p>\n

This is not only for mobile, but also when it comes to web applications, we should plan the coverage across different browsers, not only thinking about how it will look, but also taking into consideration where the client side logic will run (mainly if developing with a Javascript framework).<\/span><\/p>\n

<\/span>Cross Browser Testing<\/span><\/strong><\/span><\/h2>\n

Let\u2019s consider this first example of cross browser testing:<\/span><\/p>\n

 <\/p>\n

\"cross<\/a><\/p>\n

We could apply combinatorial testing here, adding two new variables to our inputs and outputs, which is the OS and the browser. Imagine for example that we already have 4 test cases (covering the data or logic that we need). <\/span><\/p>\n

Maybe we want to test the cartesian product, which would imply testing all the test cases in all the combinations of browsers and operating systems\u2026in this example, that would mean a total of 36 combinations. <\/span><\/p>\n

In some contexts we could apply only an each-choice combination, reducing the time invested in testing different platforms. This is the most lightweight option, where we would run only 4 combinations, each test case in one browser, in one OS.<\/span><\/p>\n

Or we could have something in the middle, using a tool to design the pairwise combination, we would run 12 combinations in total, covering all possible pairs.<\/span><\/p>\n

As you can see, testing has quite a lot of things to cover\u2026 and I have only mentioned SOME of the criteria to take into account! <\/span><\/p>\n

How can we achieve the desired level of test coverage then? Remember this:<\/p>\n

<\/b>[tweet_box design=”default” float=”none”]It’s impossible to test everything\u2014it’<\/b>s impossible to cover everything.<\/b>[\/tweet_box]<\/b><\/p>\n

 <\/p>\n

So, we need to plan and decide what we are testing, which means, we need to decide what to cover. <\/span><\/p>\n

<\/span>Laying Out a Plan to Optimize Test Coverage Over Time<\/span><\/strong><\/span><\/h2>\n

Here\u2019s a strategy that Abstracta has used that you could take into consideration in order to improve your approach for test coverage, since, as it happens in most teams, there is never enough time to reach the test coverage you need. <\/span><\/p>\n

If this is the case, a good practice is to improve test coverage over multiple test cycles, in the long term.<\/span><\/p>\n

Imagine we have different features to test on different browsers and have organized different test suites with the corresponding test cases, each suite with its own priority. <\/span><\/p>\n

The proposal is to run the most critical test cases against all browsers everytime (this is the first row of the table, in green, the one named \u201cpriority\u201d), but, we can decide to run the rest of the test suites on a single browser. A different browser for each suite, so, we are exercising the system in different browsers. <\/span><\/p>\n

In the following test cycles, we can exchange the \u201ctest suite\/browser\u201d combinations. That way, in each test cycle we do not have perfect coverage, but after multiple test cycles we improve it. <\/span><\/p>\n

Where it says \u201cdate 1\u201d, it could also say \u201csprint 1\u201d, \u201citeration 1\u201d, \u201cday 1\u201d, or even \u201cversion 1.\u201d <\/span><\/p>\n

The goal here is to distinguish which test cases we will run in each iteration in each environment.<\/span><\/p>\n

\"optimize<\/a><\/p>\n

When time is scarce, we have to use it wisely and do our best to reduce risk.<\/b><\/p>\n

Here is another example applied to mobile testing in order to reduce risk related to device fragmentation. It\u2019s the same idea, but different test cycles are running each test case on a different device.<\/span><\/p>\n

\"optimizing<\/a><\/p>\n

After the third execution, you\u2019d have covered all combinations: each test case on each device.<\/span><\/p>\n

\"mobile<\/a><\/p>\n

It\u2019s a very simple strategy, that doesn\u2019t provide perfect coverage, but it\u2019s better than not doing any cross-browser or cross-device testing at all. <\/span><\/p>\n

As I mentioned when discussing pairwise, I believe that this strategy has a better cost-benefit relationship.<\/span><\/p>\n

<\/span>Where Automation Comes Into Play<\/span><\/strong><\/span><\/h2>\n

Following the sweeping analogy, if we chose to use a Roomba (which we can consider to be a tool for \u201csweep automation\u201d), we can use it to cover those high risk spots for us, or those places that we want to sweep everyday, allowing us to focus on cleaning new areas.<\/span><\/p>\n

\"roomba\"<\/a><\/p>\n

To cover different devices or browsers or operating systems, I find it very useful to use tools like <\/span>CrossBrowserTesting<\/span><\/a>, because we can have quick access to different combinations of platforms and browsers. So, once we have our plan for covering different scenarios in different platforms, we can access them easily through our browser. <\/span><\/p>\n

<\/span>Watch a Demo<\/span><\/strong><\/span><\/h3>\n

Here you can watch\u00a0the portion of the webinar in which I give a six-minute demo for using CrossBrowserTesting live<\/span>. You\u2019ll see how the tool helped me uncover a problem with Abstracta\u2019s own website when someone accesses it using Windows 7 and Internet Explorer 8\u2026 whoops!<\/span>
\n