So let's look at how this will work with an example.
I'm going to use this simple program that takes two inputs. The
first input is a string, str, and the second one is
an integer, size. And the problem is called split. And as
the name says what it does is to take this string,
str, and split it into sub string, into chunks of size
characters each. So how do we identify some possible partitions for
this program? If we consider the input size, we can identify
three neutral partitions which are size less than 0. For example,
we want to test how the program behaves. But if we pass an
incorrect size, size equal to 0, which is also a partition. In
this case, a partition with a single element. And the third case
is size greater than 0, which I will consider to be
kind of the standard case. And actually let me do a, you
know, slight aggression so when I was talking about designer bias. So
this is a case in which designer bias might not make you
think of using size less than 0 because you read the
spec. And you sort of assume that the size will be positive.
Whereas the right thing to do when we test is to consider
the complete domain rather than just parts of it. So now let's
look at string, str, and let's see what kind of sub
domains we could identify for this
parameter. And notice another important aspect
here is that we treat each different part of the input independently,
which also helps breaking down the problem. One interesting sub domain is
the domain that includes all the strings whose length is less than
size. So all the strings that will not be displayed. Another subdomain
is all the strings with length which is between the value of
size and twice the value of size. A third subdomain is the one
including all the strings whose length is greater than twice the value
of size. And we can continue and identify more and more subdomain.
The key thing here is that we have to do that based
on the domain. So we need to adapt what we just did here
based on, on the specific domain involved and on the type
of data in this domain. So at this point we said that
there were two steps. One was to identify the subdomains and
the second one was to pick values in this subdomain. The values
that we'll actually use for the testing. In this case, we
do not want to just pick any value. Rather we want to
pick values that are particularly
interesting, particularly representative. So what does
that mean? Well, we're going to do that based on an intuitive idea.