2 Why We Need Model-Based Testing

Overview 15
method calls coded by developers, not the actual messages that travel over the
network. In this protocol, the server starts first, and waits for a connection from a
client. The client connects to the server and sends a command: the string T to request
a temperature measurement. The server responds by sending back the temperature,
expressed in a string such as 72.1. Then the client may send another command, or
it may close the connection and exit. If the client closes, the server may wait for
another client to connect, or it may also exit. The server can only accommodate one
client connection at a time.
2.3 Sockets
We implement our protocol using sockets, anapplication programming interface
(API) for communicating over TCP/IP networks. The socket API is one of the
fundamental technologies of the Internet and is familiar to many developers. The
.NET framework provides an implementation of this API in the Socket class in the
System.Net.Sockets namespace.
Establishing a connection requires several steps, where each partner calls methods
in the socket API in a particular sequence (Figure 2.2). In the Server, Socket creates
a listener socket, Bind associates it with an IP address and a port number, and Listen
prepares for a connection. Accept makes the connection and creates a connection
socket to use for that connection. In the Client, Socket creates a socket and Connect
makes the connection. Once the connection is made, both partners call Send and
Receive to exchange messages. In our protocol, the client sends first. Both partners
call Close to finish the connection. In our protocol, the client closes first. Finally,
the server calls Close on its listener socket.
2.4 Libraries
Like most applications, our Monitor and Logger programs use libraries. They do
not call the .NET sockets API directly. Instead, they call methods in Client and
Server classes that we wrote (Figures 2.3–2.5). These classes are wrappers for
.NET sockets that provide a similar but simplified API that is specialized for remote
instrument applications. Each wrapper method Socket, Bind, and so on, calls the
.NET socket method with the same name, but uses fewer parameters, or more
convenient parameters. For example, the client’s Receive and the server’s Send
methods handle floating point numbers (the temperature samples) rather than arrays
of bytes, as the .NET socket API does. Although these classes are more specialized
than the .NET Socket class, they still support other applications and protocols
besides the ones described here (Exercise 1).
more free ebooks download links at:
http://www.ebook-x.com