Chapter 8 - Testing

Question 1

test pyramid

Answer 1

pyramid partitions the tests according to their granularity.

Question 2

Unit tests

Answer 2

check small parts of the code, usually a single class.

They form the base of the pyramid, meaning most tests fall into this category. Unit tests are simple, easier to implement, and fast to run.

Question 3

integration tests or service tests

Answer 3

verify a system’s functionality or transaction

These tests involve multiple classes from different packages and may include external components like databases. They require more time to implement and are slower to run.

Question 4

end-to-end tests, also referred to as user interface tests or system tests

Answer 4

simulate a user session on the system as authentically as possible.

They are more complex, time-consuming, and fewer in number. End-to-end tests also tend to be brittle, meaning minor alterations in the user interface might require changes in these tests.

Question 5

Automated test percentage breakdown

Answer 5

A generic recommendation suggests that automated tests should be implemented in the following proportion: 70% as unit tests; 20% as integration tests; and 10% as end-to-end tests

Question 6

defect (bug)

Answer 6

when a piece of code does not comply with its specification

Question 7

failure

Answer 7

If defective code is executed and causes the program to produce an incorrect result or behavior

Question 8

fixture

Answer 8

create the test context

This involves instantiating the objects we intend to test and, if necessary, initializing them

The program state verified by one or more test methods, including data, objects, etc. In the context of unit testing, the function of a fixture is to fix the state, i.e., set up the data and objects to be verified by the test.

Question 9

Test Method

Answer 9

A method that implements a test and is annotated with the @Test annotation

Question 10

Test Case

Answer 10

In JUnit, the term refers to a class containing test methods. The name originates from the first versions of JUnit, where the test methods were implemented in classes that inherited from a TestCase class.

Question 11

Test Suite

Answer 11

A set of test cases typically executed together by the unit testing framework, which in our case is JUnit.

Question 12

System Under Test (SUT)

Answer 12

The system being tested. It’s a generic term, also used in other types of tests, not limited to unit tests. The term production code is also sometimes used to refer to the SUT.

Question 13

Test-Driven Development

Answer 13

Development style: you can write the tests first, before any production code. Initially, these tests will fail. Thus, you start with code that only compiles but whose tests fail. Then you implement the production code and test again. At this point, the tests should pass.

Question 14

regressions

Answer 14

occurs when a modification in one part of the code—whether to fix a bug, implement a new feature, or perform a refactoring—inadvertently introduces a bug in another part.

Question 15

FIRST

Answer 15

Fast
Independent
Repeatable
Self-checking
Timely

Question 16

Fast

Answer 16

Developers must run unit tests frequently to receive feedback about bugs and regressions. Therefore, it’s important that these tests execute quickly, ideally in milliseconds.

Question 17

Independent

Answer 17

The order of execution of unit tests should not matter. For any two tests T1 and T2, running T1 followed by T2 must produce the same result as running T2 and then T1. Indeed, T1 and T2 could also be executed concurrently. For the tests to be independent, T1 should not change any part of the global state that is later used by T2, and vice versa.

Question 18

Repeatable

Answer 18

Unit tests should always provide the same result. This means that if a test T is called n times, the result should be the same in all n executions. Therefore, T should either pass in every execution or fail in every execution.

Question 19

Self-checking

Answer 19

The result of unit tests should be easily verifiable. Developers should not have to open and analyze an output file or manually provide input data to interpret the test result. Instead, the results should be displayed in the IDE

Question 20

Timely

Answer 20

Tests should be written as early as possible, ideally even before the code that needs to be tested.

Question 21

Flaky Tests or Erratic Tests

Answer 21

Tests with non-deterministic results

Concurrency is one of the main causes of flaky behavior

Question 22

Test Smells

Answer 22

represent sub-optimal implementation decisions in test code, which, in principle, should be avoided

Includes:
Obscure Test
Tests with Conditional Logic
Code Duplication

Question 23

Obscure Test

Answer 23

a long, complex, and difficult-to-understand test

Question 24

Tests with Conditional Logic

Answer 24

include code that may not be executed.

Question 25

Code Duplication

Answer 25

occurs when there are repeated blocks of code in several test methods

Question 26

Test coverage

Answer 26

a metric that helps determine the number of tests we need to write for a program. It measures the percentage of statements in a program executed by the existing tests, calculated as: Test coverage = (Number of statements executed by the tests) / (Total number of statements in the program)

Question 27

function coverage

Answer 27

percentage of functions executed by the tests

Question 28

function call coverage

Answer 28

among all the statements in a program that call functions, the percentage exercised by the tests

Question 29

branch coverage

Answer 29

percentage of branches in a program executed by the tests; an if always generates two branches: one when the condition is true and another when it is false C1 Coverage

Question 30

C0 Coverage vs C1 Coverage

Answer 30

C0 Coverage: Statement coverages C1 Coverage: branch coverages

Question 31

Testability

Answer 31

describes how easy it is to test a program

Question 32

mock (or stub)

Answer 32

we can create an object that emulates the real object, but only for testing purposes.

Question 33

behavioral test

Answer 33

checks for events (e.g., method calls) that occur during the execution of the tests

Question 34

Dummy Objects

Answer 34

passed as arguments to a method but they are not used in the method’s body. Their primary purpose is to bypass the language’s type system

Question 35

Fake Objects

Answer 35

have a simpler implementation than a real object. For example, they can simulate a database in main memory.

Question 36

test doubles

Answer 36

mocks and stubs Dummy Objects Fake Objects

Question 37

service tests (or integration tests)

Answer 37

These tests aim to exercise a complete service, or a complete feature of the system, rather than testing a small unit of code involve more classes, sometimes from distinct packages. They also test dependencies and real systems, such as databases and remote services.

Question 38

system tests or interface tests (end-to-end tests)

Answer 38

These tests simulate the use of a system by a real user. They are the most resource-intensive automated tests, requiring more effort to implement and taking the longest to execute.

Question 39

black-box technique

Answer 39

tests are written considering only the interface of the code under test. functional tests

Question 40

white-box technique

Answer 40

test implementation takes into account information about the code and its structure structural tests

Question 41

Equivalence Classes

Answer 41

recommends dividing the inputs of a program into sets of values that have the same likelihood of presenting a bug

Question 42

Boundary Value Analysis

Answer 42

testing with the boundary values of each equivalence class and with the values that immediately precede or succeed such boundaries.

Question 43

exhaustive testing

Answer 43

testing a program with all possible inputs

Question 44

Random testing

Answer 44

the test data is chosen randomly

Question 45

Acceptance Tests

Answer 45

tests carried out by the customers, using their own data. The results determine whether or not the customers will accept the implemented software.

Question 46

Alpha tests

Answer 46

conducted with customers, but in a controlled environment, such as the developer’s workstation

Question 47

beta tests

Answer 47

If the system passes the alpha tests, a test with a larger customer group can be conducted, no longer in a controlled environment

Question 48

performance tests

Answer 48

to assess the system’s behavior under specific load conditions

Question 49

Usability tests

Answer 49

used to evaluate the system’s user interface and often involve the observation of real users interacting with the system

Question 50

Failure tests

Answer 50

simulate abnormal events in a system, such as the failure of specific services or even an entire data center.