2 Why We Need Model-Based Testing

264 Reactive Systems
16.3 Asynchronous stepping
Recall that testing requires a test harness called a stepper (Sections 8.3 and 12.2.3).
In order to test a reactive IUT, the IUT has to support the asynchronous stepper
interface IAsyncStepper that is declared in the NModel.Conformance namespace.
The interface derives from the IStepper interface (see Section 12.2.3) and has
one additional method called SetObserver. The SetObserver method is invoked
initially by the conformance tester to set a callback function that enters observable
actions into an observation queue. The observation queue is monitored by the conformance
tester during test execution, as explained in Section 16.5.
namespace NModel.Conformance
{
public delegate void ObserverDelegate(Action action);
}
public interface IAsyncStepper : IStepper
{
void SetObserver(ObserverDelegate observer);
}
When implementing an (asynchronous) stepper, the basic stepping functionality
has not changed. The difference is that the stepper can now, in addition, implement a
mechanism that directs asynchronous or spontaneous events produced by the IUT to
the conformance tester. In other words, the job of the stepper is to map those events
to observable actions that the model program understands and invoke the observer.
By invoking the observer, the observable actions are entered into the observation
queue to be processed by the conformance tester.
Consider the SP protocol from Chapter 14. Figure 16.4 shows a mock implementation
of an SP server. The server has a method Request that starts processing of
requests, and an event ResponseEvent that is raised with feedback about finished
requests to subscribers of the event. The server also has a Boolean property IsBusy
that returns true if the server is not idle. To process a request, the server simply starts
a worker thread that, after a short random delay, produces a response where the
number of granted credits is a random number not more than the requested number
of credits. This server is faulty, because it may grant no credits to the client even
when the client has no pending requests and no more unused message ids.
An asynchronous stepper for the server is shown in Figure 16.5. A call to
SetObserver with an observer delegate subscribes a response handler (responder)
to the response event of the server. The responder maps concrete responses from
the server to observable actions and invokes the observer delegate that will enqueue
more free ebooks download links at:
http://www.ebook-x.com