Tip:
Highlight text to annotate it
X
To recap a little bit, we have our software under test,
and it provides some APIs.
Each API's collection of functions and most of the work that we have during testing
is going to be calling these functions with various values and looking at the results.
Additionally, the software under test is going to use APIs provided by, for example,
the operating system or the programming language runtime,
and a separate kind of testing is looking at how the software under test
responds to return codes and similar given to it by the APIs that it uses.
That would be great if both of these kinds of testing
represented a complete picture of everything that we need to test,
but in fact, that's not the case, and there are some added complications
that we're going to talk about now.
The issue is that the overt explicit interfaces that we see here
don't represent all the possible inputs and outputs that we might care about.
For example, on the input side it's completely possible that our software under test
cares about the time at which inputs arrive.
So it might be the case that our software responds differently
if 2 inputs arrive very close together
than it does if 2 inputs arrive separated by a large amount of time.
And if this seems silly, just consider, for example,
the software that processes mouse clicks.
Two clicks very close together represent a double click,
and that's interpreted very differently from 2 mouse clicks that occur farther apart in time
which count as 2 single mouse clicks.
Another example is something like a web browser
where if the data corresponding to a web page is returned in a short window of time,
this data will get rendered as a web page.
But if the data that comes from the network is scattered across too much time,
this is going to result in some sort of a time-out--
that is to say, the software under test, which is our web browser,
will render some sort of an error page
instead of actually rendering the data if it comes too slowly.
Both of these examples that we just looked at are fairly easy to test
because in each case, we have this sort of binary distinction
between, in one case, the data arriving quickly--
that is to say, a double click or a complete web page arriving before the time-out--
and in the other case, we have data arriving too slowly--
that is to say, 2 single clicks or a web page that takes so long to arrive that we time out.
In other cases, the timing-dependent input can make our lives significantly more complicated.