Let me give you some tips on writing property-based tests.
Category: Uncategorized
Creating complex domain objects
Building more complex objects may come in handy when testing business systems. This can be done using jqwik’s Combinators feature, which we’ll use in the following listing. Imagine that we have the following Book class, and we need to generate different books for a property-based test. Listing 5.21 A simple Book class One way to do this would be to have a… Continue reading Creating complex domain objects
Testing the Basket Class
Let’s explore one last example that revisits the Basket class. The class offers two methods: an add() method that receives a product and adds it a quantity of times to the basket, and a remove() method that removes a product completely from the cart. Let’s start with the add method. Listing 5.12 Implementation of Baskets add method ❶ Checks all the pre-conditions ❷ Stores the old value so we can check the post-condition later ❸ If the product… Continue reading Testing the Basket Class
Testing the indexOf method
The Apache Commons Lang has an interesting method called indexOf() with the following documentation, adapted from its Javadoc: Finds the index of the given value in the array starting at the given index. This method returns –1 for a null input array. A negative startIndex is treated as zero. A startIndex larger than the array length will return –1. Input… Continue reading Testing the indexOf method
Testing the unique method
The Apache Commons Lang offers the unique method. Following is its adapted Javadoc: Returns an array consisting of the unique values in data. The return array is sorted in descending order. Empty arrays are allowed, but null arrays result in a NullPointerException. Infinities are allowed. Parameters: The method returns a descending list of values included in the input array.… Continue reading Testing the unique method
The passing grade program
Consider the following requirement, inspired by a similar problem in Kaner et al.’s book (2013): A student passes an exam if they get a grade >= 5.0. Grades below that are a fail. Grades fall in the range [1.0, 10.0]. A simple implementation for this program is shown in the following listing. Listing 5.1 Implementation… Continue reading The passing grade program
Introduction
So far, we have been doing example-based testing. We judiciously divide the input space of a program (into partitions), pick one concrete example from all the possible ones, and write the test case. What if we did not have to pick one concrete example out of many? What if we could express the property we are trying to exercise… Continue reading Introduction
Tooling support
There is more and more support for pre- and post-condition checks, even in languages like Java. For instance, IntelliJ, a famous Java IDE, offers the @Nullable and @NotNull annotations. You can annotate your methods, attributes, or return values with them, and IntelliJ will alert you about possible violations. IntelliJ can even transform those annotations into proper assert checks at compile time. In addition,… Continue reading Tooling support
Should we write tests for pre-conditions, post-conditions, and invariants?
In a way, assertions, pre-conditions, post-conditions, and invariant checks test the production code from the inside. Do we also need to write (unit) tests for them? To answer this question, let me again discuss the difference between validation and pre-conditions. Validation is what you do to ensure that the data is valid. Pre-conditions explicitly state… Continue reading Should we write tests for pre-conditions, post-conditions, and invariants?
When not to use design-by-contract
Understanding when not to use a practice is as important as knowing when to use it. In this case, I may disappoint you, as I cannot see a single good reason not to use the design-by-contract ideas presented. The development of object-oriented systems is all about ensuring that objects can communicate and collaborate properly. Experience… Continue reading When not to use design-by-contract