Automated test harness

Abstract

An apparatus and method for temporarily slaving and configuring a plurality of hardware resources such as computers, microprocessor-based devices, and the like, over a network, and then emancipating the resources to operate independently. Resources or targets may be enslaved at an operating system level. A controller may configure a plurality of hardware resources such as computers, microprocessor-based devices, and the like, to operate autonomously over a network. Resources or targets may be enslaved at an operating system level, configured with commands from a controller, and emancipated to operate independently. Emancipated resources may download applications, read and write files, communicate with other devices, and otherwise operate as independent computers. Data corresponding to test instructions may be downloaded from, and data corresponding to results may be recorded and saved on, a network server by a resource operating independently. Upon completion of a test or a series of tests, a resource may again report back to a controller, be enslaved and reconfigured, and be emancipated to operate other test software.

Claims

What is claimed and desired to be secured by United States Letters Patent is:

1. An apparatus for running test software, the apparatus comprising:

a network for communicating data;

a target operably connected to the network, the target comprising:

a first network interface operably connected to the network,

a first processor connected to the first network interface and provided with a first operating system,

a first memory device operably connected to a store data transferred to and from the first processor; and

a controller operably connected to a network to communicate data with the target over the network, the controller comprising:

a second network interface operably connected to the network to communicate data between the controller and the network,

a second processor operably connected to the second network interface for selectively, based on resource information received from the target and temporarily providing operating system command line instructions for controlling the operating system of the target, while the operating system of the target is continuously operating, to configure the target,

a second memory device for storing data communicated to and from the second processor, and

a storage device connected to the network for storing files of data.

2. The apparatus of claim 1 wherein the controller is further provided with a launcher for communicating with the target, and for enslaving and controlling the operating system of the target during a setup operation to configure the target.

3. The apparatus of claim 2 wherein the second processor is programmed to emancipate the target to operate independently after the setup operation, and the target is configured to load and run an application independently of the controller.

4. The apparatus of claim 1 wherein the controller is further provided with a resource manager for managing data corresponding to identification and performance characteristics of the target, and to availability of the target to run applications.

5. The apparatus of claim 1 wherein the controller further comprises a server for storing and retrieving files.

6. The apparatus of claim 5 wherein the files comprise datafiles selected from applications for running on the first processor, control applications containing executables for controlling loading and running of the applications, application datafiles containing data corresponding to parameters used by the first processor in running the applications, and result datafiles containing data corresponding to results output by the first processor while running the applications.

7. The apparatus of claim 1 wherein the controller is further provided with a database manager for storing and retrieving application datafiles and result datafiles communicated between the first processor and the storage device.

8. The apparatus of claim 1 wherein the controller is further provided with a scheduler for acquiring data corresponding to a queue of applications to be run, scheduling to run an application associated with the queue, confirming that all data needed to run the application has been assembled, and monitoring the target to determine completion of running of the application.

9. The apparatus of claim 8 further comprising a database manager for storing, and for retrieving over the network, application datafiles and result datafiles.

10. The apparatus of claim 9 further comprising a resource manager for acquiring and storing data corresponding to identification and characteristics of the target, and to availability of the target to run applications.

11. The apparatus of claim 10 further comprising a launcher for communicating commands to the operating system of the target for configuring the target prior to emancipation of the target to operate independently.

12. The apparatus of claim 11 further comprising a server for transferring files communicated over the network to and from the storage device.

13. The apparatus of claim 1 further comprising a plurality of targets, the target being a first target of the plurality of targets.

14. The apparatus of claim 13 wherein a second target of the plurality of targets is provided with a second operating system different from the first operating system.

15. The apparatus of claim 1 wherein the target further comprises a storage device operably connected to the first processor for storing application datafiles, result datafiles, and applications.

16. The apparatus of claim 1 wherein the target is provided with an operating system for downloading an executable to be run on the first processor.

17. The apparatus of claim 16 wherein the executable is selected from a command file, an interpretable language file, a batch file, and an instruction file written in machine code.

18. The apparatus of claim 1 wherein the target is provided with an operating system for receiving executables downloaded by the controller to be run on the first processor.

19. The apparatus of claim 1 further comprising a second target operably connected to the network and having a second operating system different from the first operating system.

20. The apparatus of claim 1 wherein the second memory device is provided with a plurality of queues for receiving operational codes communicated by a plurality of processes running on the second processor, each operational code being readable by a process of the plurality of processes for controlling an operation of the process.

21. The apparatus of claim 1 wherein the second processor is programmed to run simultaneously a plurality of software modules, the plurality of software modules comprising:

a database manager for storing and retrieving application datafiles to be used as inputs for applications executable by the second processor, and result datafiles containing outputs of the applications;

a resource manager for storing data corresponding to identification, characteristics, and availability of the target to run the applications;

a launcher for communicating with the operating system of the target and for configuring the target to operate independently of the controller in running applications and uploading result files to the server, and for selectively downloading applications to the target and instructing the target to download applications to the target result datafiles to the server; and

a scheduler for acquiring data corresponding to applications to be run, selecting applications to be identified to the target for downloading to the target, and for spawning instantiations of the launcher.

22. A method of running software on a plurality of computers, the method comprising:

connecting a target to a network, the target comprising:

a first processor having a first operating system, and

a first network interface operably connected to the processor to communicate data between the processor and the network,

connecting a controller to the network to communicate over the network with the first operating system, the controller comprising:

a second network interface operably connected to the network to communicate data between the controller and the network,

a second processor having a second operating system and operably connected to the second network interface for selectively, based on resource information received from the target, and temporarily provide operating system command line instructions for controlling the first operating system of the target, and

a memory device for storing data communicated to and from the second processor;

connecting a server, containing a storage device, to the network for storing and retrieving files transferred over the network;

enslaving the first operating system of the target to be controlled by the controller;

transmitting operating system command line instructions from the controller to the first operating system of the target to be executed by the first operating system of the target to configure the target;

emancipating the first operating system of the target to operate independently of the controller; and

loading by the target, independently of the controller, a file from the server onto the target.

23. The method of claim 22 wherein the first operating system and the second operating system are different from each other.

24. The method of claim 22 further comprising running an application of the applications on the first processor.

25. The method of claim 24, further comprising creating by the target a result datafile containing data corresponding to results obtained by the first processor while running the applications.

26. The method of claim 25, further comprising independently uploading by the target the result datafile to the server.

27. The method of claim 22 wherein the file is selected from applications containing instructions executable by the first processor, control applications containing instructions executable by the first processor for controlling running of applications, a batch file interpretable by the first operating system, and application datafiles containing data corresponding to parameters used by the first processor in running applications.

Description

BACKGROUND

1. The Field of the Invention

This invention relates to computer networks and, more particularly, to novel systems and methods for temporarily slaving operating systems of a plurality of processors for configuration purposes or for downloading software, and then later emancipating these slaved devices (e.g. computers, microprocessor-based devices, instruments, etc.) to operate independently, including running software, downloading files, and uploading files over the network.

2. The Background Art

Networking typically involves several microprocessor-based devices (nodes) exchanging data with one another over a transmission medium, a communication link such as, for example, a hard wire, fiberoptic cable, radio frequency transmitter/receiver, or other physical communication mechanism. A link between a node and a network or between routers of a wide area network (WAN) may be wireless. Network cards provide a mechanical and data connection between the communication link (e.g. fiberoptic, wire, or wireless) and the processor of the node or device to be connected to the network. Communication may occur by various protocols (rules), with steps (activities) executed by devices satisfying those protocols.

Networks may be defined at several levels of grouping and communication. For convenience, the terms primary, secondary and tertiary network are used here to indicate the extent and complexity of a network. A primary network is the most fundamental connecting of two nodes in some manner. A local area network (LAN) may be thought of as a primary network. A secondary network is a routed network, one including at least two primary networks connected by a router for forwarding messages between the primary networks. A tertiary network (sometimes called an internetwork) is one including two primary or secondary networks, a router in one being separated by an intermediate network from a router in the other. Thus, as the name network implies, a tertiary network can extend from router to router to router via intervening primary networks virtually forever, within the constraints of the laws of electrophysics and communications protocols.

A server is a computer connected to a network via a network card and programmed to act as a traffic manager and storage device for files of data being transmitted over the network by the various connected nodes. A hard wire interconnected to a group of network cards with attached computers, with one of those computers acting as a server, is a typical network. In other networks, every device may be a server.

Computer networks are capable of facilitating many functions, but not certain other functions. For example, as computer network technology has grown, so has the need to pass information over the networks.

Likewise, a user at each node, typically, must configure the node, from physically connecting hardware and loading an operating system of the processor to loading an application and instructing the application how to store and retrieve data representing information. A high degree of automation of tasks normally done by users is not typically available between devices (nodes) across networks. One command line at a time is typically required to be sent and responded to.

Unfortunately, a user logging a controller computer on to a network cannot automatically download executables to a remote, general-purpose, computer for execution. The remote computer must be logged on and configured by the user just as any other computer.

Similarly, a slaved computer may be logged on to a network, configured, loaded with an application and then enslaved to communicate with a master to receive information from a master for use by an application previously launched on the slave computer. Instructions and responses are typically on a command-by-command basis.

Configuration may be thought of as programming a slave with executable codes, and providing information for establishing connections and protocols, identifying other devices to be addressed, identifying a server and possibly a router, providing the address of the slave to the network server, and so forth. Thus, once configured, a node (e.g. computer or other processor-based device on a network) may send and receive messages. Also, once an application has been launched (loaded and instructed to run), the slave may send and receive information related to the application. However, if a slave is basically a general purpose processor with an operating system and memory, or optionally including a storage device, it must be manually loaded with software and instructed to run by a user before communicating with a master.

What is needed is a system that enables a controller to act as a user or otherwise take control of a processor to instruct it. For example, a processor needs to be controlled long enough to be instructed to download "executables," (files containing a coded instruction capable of being "understood" by an operating system of a processor to result in an operable instruction executable by the processor), and to launch (run) the executables. Slaving an operating system and configuring the host (remote computer) need to be followed by a high degree of independent operation by the remote computer.

A scheme is needed for slaving and configuring, followed by downloading entire executables to a general purpose computer, that is, a target, located remotely from a controller, particularly over a network. For example, a controller may need to automatically perform all tasks normally required of a user seated at a keyboard associated with the target. For example, a user boots up a computer with some operating system, logs on to a network, navigates through a hierarchy of directories, locates and loads an executable file, and runs the "executable." For systems having an input/output (I/O) interface for dealing with humans, great utility may be obtained by providing for a remote computer to replace the user, thus providing automation of many manual tasks associated with setting up a computer, running software, and managing files.

Similarly, for processor-based apparatus having I/O interfaces embedded, without user interfaces as monitors and keyboards, great utility could be obtained by providing for automatic access to the operating system by a remote computer across a network. For example, automatic loading of executables from a remote computer, automatic upgrading, and any similar task accessing the operating system of a microprocessor-based device on a network could make management and upgrading of such devices tractable on a large scale.

Likewise, the need may be for downloading information to the memory of a device by which the device may operate a resident executable. For example, when a single computer connects to several peripheral devices, the single computer typically may control those various devices directly. Also, a controlling computer may simply provide data corresponding to responses, commands, or information needed by an application running on a slaved computer. However a need exists for autonomous devices to be temporarily accessed remotely with data for controlling or supporting resident executables, after which the devices return to their autonomous operating condition. The need, when compared with the conventional term "slaved computer" is for an "emancipated computer" that may be temporarily and remotely enslaved at an operating system level, configured, and emancipated to operate independently over the network. The emancipated computer or other device needs to be able to access files of input information or load itself with an executable, or launch an executable, after which it may report back to a master to be enslaved again, and reconfigured to operate again as an emancipated device.

A system is needed that is transparent to a user for tracking large numbers of such emancipated slave computers. Thus, a system is needed that will facilitate a controller accessing numerous resources (computers), monitoring their capabilities, taking temporary control of any available one, commanding the selected resource to configure itself, load and run software, and pass input and output information properly, and report to the controller when it is again available to be assigned another project. Again, single commands with reporting back for another command are not the intention. What is needed is true emancipation, maximizing the use of the emancipated slave resource, with minimum necessity for control by the controller, while at the same time permitting the controller to communicate with the resource at an operating system level when needed. Thus a general purpose computer may be commanded to completely re-configure itself as needed without human intervention.

Thus maximum utility of all resources may be achieved by simply programming the logical options, defaults, backups for failed options, and the like, in order to keep all resources operating all the time with tasks that each can complete. Thus, regardless of processor, speed, memory, architecture or operating system, each resource needs to be able to be put to work effectively for every minute that it is available, without waiting for a user to monitor, schedule, and program the resource manually. All this capability over network can make possible testing systems having great speed, throughput, and flexibility from an assembly of any number of available resources of virtually any type. Moreover, human intervention may be only required at some minimal degree, yet a human operator could access the controller for information on the system status, results, and the like at any time.

BRIEF SUMMARY AND OBJECTS OF THE INVENTION

In view of the foregoing, it is a primary object of the present invention to provide a system for commanding resource computers to download test software and parametric data from a computer server (central repository) to the resource (test) computer or device selected from a plurality of resource computers over a primary, secondary, or tertiary network.

It is an object of the invention to provide a system for uploading and storing test result data from a test computer to a central repository on the network.

It is an object of the invention to automatically, according to a method transparent to a user, without requiring intervention by a user, manage a plurality of resource computers, over a network from a controlling computer, the startup and configuration of one or more test computers selected from the plurality of resource computers, transfer software files and parametric data files to the test computer or cause the test computer to download those files, provide surrogate commands to the test computers as if from a user or programming computer, and emancipate the test computer to operate the software of the software files and return result data corresponding to test data to a system database repository remote from the test computer.

It is an object of the invention to permit transfer of data by bit streams, files, fields, or entire databases.

It is an object of the invention to transfer data to a controller, or to a remote processor operating as a database manager, or directly to a database in a storage device, over a network, without requiring synchronous communication as in conventional master/slave systems, for example, without requiring that a master send an instruction to obtain each packet of information from a slave, or without requiring a master to do anything to enable a resource to complete a function and store data for access later by other computers, such as the controller.

It is an object of the invention to provide a system for tracking and scheduling of available resource computers connected in a network, including monitoring such parameters as, for example, the location, name, operating system, memory, speed, processor characteristics, memory capacity and other operational characteristics, of each resource computer, and using that information to allocate those resource computers to run applications, such as for example, test applications and collect data, such as test data.

It is an object of the invention to provide over a network a server (whether having a separate central processor, or time-sharing with the controller) for storing and retrieving files to be used temporarily by a controlling computer on the network and files to be loaded to and from a selected test (resource) computer of a plurality of resource computers connected to the network.

It is an object of the invention to provide database management, including an information format and designated fields to be stored in a database, for application, such as test applications, datafiles of parameters for controlling the test applications, and datafiles of test results obtained by running the test applications, all to be uploadable and downloadable over a network between a plurality of resource computers, a server, and a controller connected in a network.

It is an object of the invention to provide scheduling and queuing for a plurality of resource computers connected in a network, the resource computers being general purpose, program inable, digital computers, wherein application files of testing software, and parametric datafiles for operating the testing software are not required to be resident, but may be made available or downloaded by each selected, available, resource computer as prompted by a controlling computer connected to the network to communicate with the individual operating systems of the resource computers.

It is an object of the invention to provide resource management of a plurality of resource computers connected in a network according to the performance parameters of each resource, such as, for example, its memory, speed, processor characteristics, memory capacity and other operational characteristics.

It is an object of the invention to provide selection of a resource computer by a controller, loading and launching of applications by the resource computer under limited prompting or direction from the controller.

It is an object of the invention to provide a scheduler for selecting a test, having an application, from a queue of tests, selecting criteria for choosing a resource computer, and passing to a resource manager such criteria, and to provide a resource manager to track performance characteristics of a plurality of resource computers connected to a network, and to select a suitable resource computer for running the application based on the criteria, for example, by tracking each resource, and matching each resource at any given time with a selected application to run on that resource, the application being selected from a plurality of applications identified by the scheduler from the launch queue.

It is an object of the invention to provide a method for a resource manager to catalog and track a plurality of resource computers, for a launcher to configure a selected resource of the plurality of resource computers, for emancipating the selected resource to run alone, for the selected resource to load or have loaded on it an application, for receiving therefrom (such as by a controller or a server) data corresponding to test results generated by a test application in a suitable format for storing and retrieval.

It is an object of the invention to provide a method for configuring a plurality of resource computers remotely over a network by a controlling computer to load and run application software and create data corresponding to results generated by the application software for storage in a storage device, such as, for example, by transfer of a datafile from the application software to a server, or by transfer of data from the processor to the controller for logging into a database on a server, which may have a database manager operably connected thereto for managing datafiles.

It is an object of the invention to communicate over a network with the operating system of a general purpose computer, temporarily control the general purpose computer to configure it for running application software selected and downloaded by a controlling computer, and then emancipate the general purpose computer to operate substantially independently.

It is an object of the invention to provide for monitoring by a controller the availability and abilities of a plurality of resource computers, and for communication by the controller with the operating systems of individual resource computers over a network for configuring the resource computers, providing for loading and launching of application software thereon.

Consistent with the foregoing objects, and in accordance with the invention as embodied and broadly described herein, a test harness may include a controller, a slave or target, and a network interconnecting the master and one or more slaves. A test harness may also be thought of as a system of related software modules for controlling and managing the resources of a system of hardware components (such as computers) to render one processor a controller and another processor a slave at an operating system level.

A resource or target may be a computer controlled across a network as a slave during a setup procedure controlled by commands from the controller. The slave is thereafter emancipated to operate independently, capable of downloading and running software, reading and writing files, and the like, without direction or control from the controller. A computer may include a processor capable of hosting an operating system, with memory for temporary storage of data and instructions used by the processor during operation.

An operating environment, or simply environment, may be an operating system, such as, for example DOS, OS/2.TM., Windows.TM., and so forth. However, an environment may be another executable program operating within or under the operating environment hosted by a processor. By a "different" operating system is meant not a copy of an operating system running on a different processor, but an operating system using a programming structure, command system, protocol, combination of the foregoing, or the like, different from that of another operating system. For example DOS by Microsoft.TM. and Windows by Microsoft.TM., OS/2.TM., Macintosh.TM., Next Step.TM., are all separate, distinct, "different," operating systems for communicating with and controlling a processor, its associated memory, and possibly other devices such as a storage device over a bus of a computer.

A method and apparatus are disclosed in one embodiment of the present invention as including a network having a controller and a plurality of resources. An apparatus made in accordance with one embodiment of the invention may include a server, a database manager, a scheduler, a resource manager, a launcher, and a plurality of resources, each resource containing a processor and memory for hosting an application.

A method practiced in accordance with an embodiment of the invention may include tracking a plurality of resources, scheduling a plurality of applications having executables for controlling a processor and for providing data corresponding to operations of the processor, selecting a resource to host an application selected from the plurality of applications, configuring remotely over a network the selected resource, launching the application on the resource, running by the resource the application, providing output data from the resource, recording in a database for later retrieval the output data, and managing the database for identification and selection of the output data.

In one embodiment of an apparatus made in accordance with the invention, an apparatus for running test software may include a network for communicating data. A target may be operably connected to the network, the target comprising a first network interface, a first processor and a first memory device. The first processor may be programmable to host an operating system to communicate instructions to the first processor and to communicate data to and from the memory device. The first network interface may be operably connected to the first processor to communicate data between the first processor and the network;

A controller may be operably connected to the network to communicate data with the target over the network. The controller may include a second network interface and may be operably connected to the network to communicate data between the controller and the network. Likewise the controller may include a second processor operably connected to the second network interface for controlling the first processor's operating system.

The controller may include a second memory device for storing data communicated to and from the second processor, and a storage device for storing files. The files may include test applications containing instructions executable by the first processor, control applications containing instructions executable by the second processor, test datafiles containing data corresponding to test parameters used by the first processor in running the test applications, and result datafiles containing data corresponding to results obtained by the first processor while running test applications.

The apparatus may include software modules hosted on the controller. Modules may include a resource manager operable on the second processor for accumulating, tracking, and controlling storage of data corresponding to identification, performance characteristics, and availability of the target to run test applications. The resource manager may also service likewise a plurality of such targets.

The apparatus may include a server for storing and retrieving files, and a database manager for storing to and retrieving from a database records corresponding to data communicated between the first processor and the second processor. The apparatus may include a plurality of databases accessible by the database manager.

The controller may include a launcher in one or more instantiations for communicating with the operating system of the target. The launcher, or the target after configuration, may download selected applications and application (test) datafiles to the target. In general, another type of application may be substituted for a test application, an application datafile for a test datafile of inputs, and a result datafile for test result datafile. The controller may include a scheduler for acquiring data corresponding to a queue of tests to be run, selecting test applications to be loaded onto the target, and controlling matching of the test applications to the target.

The apparatus may include a plurality of targets, wherein each target of the plurality of targets may host an operating system different from the operating system of any or all other targets of the plurality of targets. The target (or each target of a plurality of targets) may include a storage device operably connected to the first processor for temporarily storing test datafiles, result datafiles, and test applications while running tests. The target may be programmed to host an operating system, and an environment operating under the operating system, (or on top of the operating system).

In general, when the term "test application" is used herein, the word "application" may be substituted. Although in one preferred embodiment, the apparatus and method may be used to automate the execution of software testing applications, the method and apparatus are equally valid for other software applications.

The apparatus may be arranged to have the second processor programmed with a plurality of software modules. For example, the plurality of software modules may include a server for storing and retrieving files, a database manager for storing and retrieving records from a plurality of databases corresponding to tests, suites of tests, groups of tests, suites, or other groups, target performance characteristics, test results, system parameters and errors, launchers and launches, status of targets, and the like communicated between the first processor and the second processor. Other modules may include a resource manager for tracking identification, characteristics, and availability of the target to run test applications, a launcher for communicating with the target and for initiating downloading, by the controller or the target, of selected test applications and test datafiles to the target, and a scheduler for acquiring data corresponding to a queue of tests to be run, selecting test applications to be loaded by the target, under direction of the launcher, and for spawning launchers as needed.

An apparatus may use processes and operational codes (opcodes) to provide a logical flow between processes, each process operating according to opcodes placed in a queue of the process by another process. Each process may be hosted on an individual device (computer, processor) alone, or several processes may be hosted on a single processor, timesharing the processor. This is one benefit of a multi-tasking operating system. An entire system (automated test harness) may be queue driven. Processes simply pass opcodes to queues of other processes. Each process may simply keep checking certain queues to determine whether anything needs to be done. When a process finds information in a queue, the process executes itself based upon the opcode found in the queue.

In general, an opcode may be a small data structure that may be passed from one process to a queue to be picked up by another process. Alternatively, an opcode may similarly pass from one thread to another thread of the same process. An opcode may include a block of memory allocated to contain a name, a pointer to identify other data structures needed by the particular opcode. For example, an opcode may invoke certain steps within a process. Those steps may expect certain information to be provided. That information may be provided in the data structure to which a pointer is pointing, addressing. In general, a data structure may be configured in a variety of ways.

A process may operate on data contained in a data structure, and then pass to another process (by means of an opcode) a pointer indicating that data structure. Thereafter, the other process may access the same data structure operating on, using, adding to, or deleting the information, or the like. Thus, an opcode may pass a pointer and data between multiple processes or threads during the running of an application.

Pointers may be chained. That is, a series of pointers may identify a series of next data structures. A data structure identified by a first pointer may in turn contain information interpreted as pointers. These pointers in the data structure, then, may point at, and thus chain to other data structures.

In an opcode as implemented in one preferred embodiment of an automated test harness in accordance with the invention, a generic first pointer may exist without practical limitation as to the nature of the data structure to which it points. By contrast, a second pointer may introduce a certain efficiency by pointing at a single, specific type of data structure. For example, the second pointer, by its very location in an opcode, may be bound to specific data that identifies its function. This may save process steps, and create processes by chaining opcodes, each data structure containing a pointer to the following data structure.

A method practiced in accordance with the invention may include a method of running test software on a plurality of targets, also called resources, processors, or computers. One may think of resources as hardware resources having the capability to host an operating system. The operating system may be enslaved and then emancipated by a master or controller. Emancipated means that a formerly enslaved resource's operating system is again rendered autonomous to operate independently of the master or controller.

The method may include operably connecting a target or resource to a network, the target comprising a first network interface, a first processor and a first memory device, the processor being programmable to host an operating system to communicate instructions to the processor and to communicate data to and from the memory device. The target's first network interface may be operably connected to the processor to communicate data between the processor and the network.

The method may include operably connecting a controller to the network to communicate with the target over the network. The controller may include a second network interface operably connected to the network to communicate data between the controller and the network. A second processor may be operably connected to the second network interface for controlling the operating system of the target. A second memory device may be operably connected to the second processor for storing data communicated to and from the second processor, while a storage device may be connected for storing files.

The method may include loading by the target, at the instance of a launcher hosted on the controller to be in communication with an operating system hosted on the target, certain files, including executable files downloaded by the target from a server. These files may include test applications containing instructions executable by the first processor, test datafiles containing data corresponding to test parameters used by the first processor, and the like. Similarly, control applications containing instructions executable by the second processor may be downloaded by the controller.

The method may include running the test applications on the target, creating datafiles containing data corresponding to results obtained by the first processor while running the test applications. The method may also include uploading the datafiles of results to the server.

Temporary slaving may be accomplished by loading a slave module onto each target to operate on the operating system of the target, and a master module to operate on the operating system of controller. The slave module feeds back to the master module all data necessary for the master module to interact with the target's operating system as a user. Thus prompts, screens, and the like generated by the operating system of the target are communicated by the slave module to the master module of the controller. The master module is programmed to act based on data provided by the slave, sending instructions to the slave and commands for forwarding to the operating system of the target (resource).

The slave module receives executables from the master module, along with commands to be sent by the slave module to the command line of the operating system. Thus, the slave module is effectively provided with commands destined for the operating system, and is itself instructed to send the commands to the operating system for execution.

The temporary slaving operation may be conducted by any suitable software modules operating on the controller and the target. For example, a slaving program such as NCONTROL.TM. is a Novell.TM. slaving program that has been found suitable for facilitating the temporary slaving operation.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing and other objects and features of the present invention will become more fully apparent from the following description and appended claims, taken in conjunction with the accompanying drawings. Understanding that these drawings depict only typical embodiments of the invention and are, therefore, not to be considered limiting of its scope, the invention will be described with additional specificity and detail through use of the accompanying drawings in which:

FIG. 1 is a schematic block diagram of one embodiment of an apparatus made in accordance with the invention;

FIG. 2 is a schematic block diagram of one embodiment of software modules hosted on the apparatus of FIG. 1;

FIG. 3 is a schematic block diagram of one embodiment of processes and threads run on a controller, and operational codes passed between processes and threads running on the apparatus of FIG. 1;

FIG. 4 is a schematic block diagram of one embodiment of a process by which the operational codes of FIG. 3 may operate; and

FIGS. 5 and 6 are schematic block diagrams illustrating one embodiment of records of databases accessed by the apparatus of FIG. 1.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

It will be readily understood that the components of the present invention, as generally described and illustrated in the Figures herein, could be arranged and designed in a wide variety of different configurations. Thus, the following more detailed description of the embodiments of the system and method of the present invention, as represented in FIGS. 1 through 6, is not intended to limit the scope of the invention, as claimed, but it is merely representative of the presently preferred embodiments of the invention.

The presently preferred embodiments of the invention will be best understood by reference to the drawings, wherein like parts are designated by like numerals throughout. Reference is first made to FIG. 1, which illustrates one preferred embodiment of a schematic diagram of hardware components, while FIG. 2 illustrates a block diagram of software modules operable on the apparatus from the block diagram of FIG. 1.

FIG. 3 illustrates the processes and threads of certain software modules of FIG. 2, and particularly illustrates certain opcodes passed between the threads for establishing the operating logic of the apparatus of FIG. 1. Since the apparatus and processes may be queue driven according to messages or opcodes sent and received as appropriate, logic may be complex, but a multitude of logical paths may be determined by reference to the FIGS. 1-6.

Each operational code or opcode may be used by a sending and receiving thread or process according to the logic of the flow chart of FIG. 3. Data for inputs to and outputs from the components of apparatus of FIG. 1 may be stored in any suitable data structure or memory device. For example, in one embodiment, data may be stored in databases configured as illustrated by the representative records and fields of the databases of FIGS. 5-6.

Those of ordinary skill in the art will, of course, appreciate that various modifications to the detailed schematic diagrams of FIGS. 1-6 may easily be made without departing from the essential characteristics of the invention, as described in connection with the block diagram of FIGS. 1-6. Thus, the following description of the details of the schematic diagrams of FIGS. 3-6 is intended only as an example, and it simply illustrates one presently preferred embodiment of a schematic diagram that is consistent with the foregoing description of FIGS. 1-2 and the invention as claimed herein. The operation of various components and modules corresponding to each of the functional blocks of FIGS. 1-2 are outlined in FIGS. 3-6 and are numbered with like numerals.

Referring to FIG. 1, an apparatus 10, alternately referred to as a system 10 or an automated test harness 10 may include a controller 12. The controller 12 may be connected to a network interface 14A, or the network interface 14A may be integral to the controller 12. Regardless, the controller 12 may be connected to a network 16. The controller 12 may host a slaving software module for slaving a number of resources 18, alternately referred to as targets 18, or target computers 18. The resources 18 may have alternate embodiments including the resource 20 and resource 22. That is, a resource 18 may include all of the components of a general purpose computer. Nevertheless, the resource 18 need only contain a processor and sufficient memory to host an operating system for temporary enslavement to the controller 12, followed by later emancipation for running independently.

The resources 18, 20, 22, and controller 12 may be connected to a server 24 by means of a carrier 26, typically a physical line 26 or cable 26, although the carrier 26 may be a wireless carrier 26.

The controller 12 and resources 18, together with the server 24 may be configured in a variety of topologies. For example, the network 16 may be arranged as a star, a ring, a mesh having more than one connection on a single node, or the like. Alternatively, the network 16 may be configured as a bus having a single line 26 to which all nodes 28 connect. In general, a node 28 may be used to designate any microprocessor based device connectable to the network 16.

Similarly, the nodes 28 may be configured to operate under any one of a multitude of available protocols. For example, popular protocols that might be employed may include an internetwork packet exchange (IPX) or transmission control protocol/internet protocol (TCP/IP), sometimes called transport control protocol/interface program, sequenced packet exchange (SPX), token ring, and other protocols that are currently available or may be made available in the future.

The cable 26 of the network 16 may be of any suitable local area network (LAN) or wide area network (WAN). For example, a token ring cable system, a twisted pair, a co-axial cable, a 10 base T, fiber optic lines, microwave or other radio frequency (RF), wireless transmission media, infrared or laser communication beams, and the like. The controller 12 may operate under any suitable operating system, but in one preferred embodiment should include a true multi-tasking operating system.

Although the controller 12 may include multiple processors, a multi-tasking operating system operating on a single processor 30 may be selected from OS/2.TM., UNIX, Windows NT.TM., Windows 95.TM., Macintosh.TM. Operating System, Next Step.TM., or the like. An object-oriented operating system may be suitable, but is not required. The conventional Windows.TM. operating system is not truly multi-tasking, and as currently configured would not be suitable.

By contrast, the resources 18, 20, 22 need not have multi-tasking operating systems. Although any resource 18, 20, 22 may include an entire general purpose computer, and may host any operating system such as Windows 95, Next Step, Macintosh Operating System, OS-2, or the like. In short, the resources 18, 20, 22 may be configured with any operating system capable of operating on a processor.

For example, the Novell.TM. embedded systems technology (NEST) devices and systems represent a very limited capability. However, NEST devices are capable of hosting an operating system, and thereby operating under the direction of the controller 12 in the automated test harness 10 long enough to be configured for subsequent independent operatio

That is, each resource 18 may include in a minimal configuration a central processing unit and sufficient memory, either on the individual chip associated with the processor, or independent thereof, capable of independent operation once loaded. Thus, each resource 18 need only be capable of executing instructions. In general an "executable" may be thought of as any data that may be understood by an operating system and thus resulting eventually in a machine code instruction executable by a processor.

As used here, a resource 18 may refer to any of the resources 18, 20, 22 or the like. Thus, a resource 18 may be the generalized expression for a resource 18, 20, 22 or the like.

Referring to FIG. 1, a controller 12 may include a processor 30 connected to a memory device 32 and a storage device 34. Connections may be made by a bus 36. Other auxiliary devices 38 may also connect to the bus 36. In addition, the controller 12 may include an input device 42, such as a keyboard, mouse, graphical user interface with some interactive sensor for receiving user inputs, or the like. Similarly, an output device 44 may be connected to the bus 36, such as a monitor for supporting a graphical user interface, or the like.

The controller 12 may have multiple processors 46, 48 in addition to the processor 30. Nevertheless, the processor 30 may simply be configured to host a multi-tasking operating system and thereby carry on all processing of the controller 12.

The resource 20 may be the most common embodiment of the resource 18 connected to the network 16. The resource 20 may include a processor 50 connected to a memory device 52 and storage device 54 for operational storage of data, and long-term non-volatile storage, respectively. The bus 56 connecting the processor 50 to the memory device 52 and the storage device 54 may also accommodate connections to other auxiliary device 58 whether singular or plural. Similarly, the resource 22 may be configured with different software packages to operate differently than the resource 20, as discussed below, but may also include a processor 60 connected to a memory device 62 and a storage device 64 by the bus 66. Auxiliary devices 68 may also be connected to the bus 66 as needed. The resource 18, needing only a processor 70 and a sufficient memory device 74 to provide for operations of the processor 70 may or may not include a bus 76, depending upon the configuration of the memory device 74 with respect to the processor 70. The resource 18 need only host an operating system, and need not be complex, or sophisticated. That is, certain devices exist that may be desirable to temporarily control by means of a controller 12 remotely connected over an extensive network 16. Any microprocessor-based device may be a suitable resource 18. For example, numerous types of data acquisition, instrumentation, process control, and other devices exist on networks 16. Temporary slaving, followed by emancipation for independent operation, may be desirable and suitable in an automated test harness 10 in accordance with the invention.

All nodes 28 connected to the network 16 may include network cards 14A, 14B, 14C, 14D, 14E, 14F as illustrated, for providing a hardware interface with the network 16. Different networks 16 provide for different amounts of embedded hardware and software for accomplishing the functions of a network card 14A, 14B, 14C, 14D, 14E, 14F. However, in general, a network card 14 designates any one of the network cards 14A-14F.

The server 24 may be a general purpose computer and may include a processor 80 connected to a memory device 82 and storage device 84 by a bus 86. Auxiliary devices 88 may include additional storage devices 84, additional memory devices 82, and the like as needed. Inasmuch as a server 24 provides file access and management for all the nodes 28 on the network 16, the server 24 may include various auxiliary devices 88.

The software system hosted by the nodes 28 of the automated test harness 10 may include a system of controller modules 92 and resource modules 94, 96, 98 as illustrated in FIG. 2. Also, server modules 100 may be hosted by the server 24. The controller modules 92 may include a network client interface 102 for driving the network card 14A. Thus, the network client interface 102 facilitates communication by the controller 12 over the network 16. The controller modules 92 also include a multi-tasking operating system for controlling the processor 30 of the controller 12.

An automated test harness 10 may include modules 106 (ATH Modules) or processes 106 hosted on the controller 12. Processes 106 may include a resource manager 108 for monitoring all of the resources 18 connected to the network 16. A scheduler 110 may be included for scheduling tests according to the availability of resources 18 and the requirements for each specific test. Launchers 112 may be "spawned" by the scheduler 110. A launcher 112 may be instructed by the scheduler 110 to run, and may be spawned as needed. Multiple instances of the launcher 112 may run simultaneously.

The data base manager 114 may be unique to the controller 12. Alternatively, a variety of suitable data base management software modules are available. For example, Lotus Notes.TM. has been shown to provide an "engine" for an effective data base manager. A console 116 may include software for interfacing with a user. For example, the console 116 may include a graphical user interface including icons, windows, and other mechanisms for selection by a user with a minimum of command structures.

The ATH modules 106 may include a server 118. Although a set of server modules 100 are hosted by the server 24, the controller 12, in one currently preferred embodiment of an apparatus 10 in accordance with the invention, may include a server module 118. Thus, the controller 12 may include all of the modules required to operate the automated test harness 10 and the server 24.

Thus, in general, all of the server modules 100 may actually be incorporated into the server module 118 in the controller 12. Nevertheless, the server 24 will be discussed as a separate hardware component of the automated test harness 10, hosting the server modules 100. The resource modules 94 may include a network client interface 122 for communicating with the network 16, as well as an operating system 124. A slaving module 126 may be included to permit enslaving of the operating system 124 to the controller 12 temporarily for configuring the resource 20 prior to emancipating the resource 20 to operate independently. In addition, temporary applications 128 may be hosted in the resource 20, typically by the resource 20 downloading the temporary applications 128 from the server 24 in response to commands received in a slave mode from the controller 12.

The resource modules 96 corresponding to the resource 22, may include a network client interface 132, an operating system 134, a slaving module 136, and preloaded applications 138. Although the resource modules 96 may be identical to those of the resource modules 94, for the sake of explanation and discussion, the resource 22 is configured to have preloaded applications 138, rather than temporary applications 128 as hosted by the resource 20. Thus, although not taking full advantage of the capabilities of the automated test harness 10, a resource 22 that is completely configured, including being loaded with the software to be run, may be fed information and commands one line at a time by the controller 12. Nevertheless, a more useful automated test harness 10 may be configured using resources such as the resource 20, in which temporary applications 128 are loaded by the resource 20 as a result of the controller 12 slaving the operating system 124 temporarily to instruct the resource 20 by command line instructions. That is, once the operating system 124 has been slaved to the controller 12, the operating system 124 may be instructed on what to load and how to load it. Thereafter, the operating system 124 and the resource 20 may be emancipated to operate independently, as though they had been programmed by a user individually. Nevertheless, the resource 20 at that point (emancipated) can operate to run software, download and upload files, with a very high degree of autonomy. This is substantially different than other slaving in which individual command lines must be passed to a preloaded executables in response to queries, or prompts.

The resource modules 98 represent a minimum configuration in which a processor 70 of a resource 18 need include only sufficient processor and memory capability to host an operating system 144. The resource module 98 may include a network client interface 142 and a slaving module 146 for facilitating communication between the controller 12 and the processor 70, or more correctly the operating system 144 hosted on the processor 70.

The network server modules 100 may include a network server interface 152 corresponding to the network client interfaces 102, 122, 132, 142. The network server interface 152 facilitates communication by the server 24 over the network 16. Thus, the controller modules 92 hosted by the controller 12 correspond to the resource module 94, 96, 98 and server modules 100 of the resources 20, 22, 18 and server 24, respectively.

The server modules 100 may include a network server interface 152 for facilitating communication by the operating system 154 over the network 16, while network applications 156 may operate "on top of" the operating system 154 for accomplishing the functional requirements of the server 24. Of course, a number of files 158 are typically stored on the storage device 84 of the server 24. Accordingly, the network applications 156 may perform management, storage, retrieval, indexing, and other associated functions for the files 158, serving the files 158 to each resource 18, 20, 22 or to the controller 12, as needed.

In general, the operating system 104 of the controller 12, or of the controller modules 92 hosted by the controller 12, should be a multi-tasking operating system such as an OS-2 or UNIX operating system, as discussed above. In addition, a network interface should render the controller 12 a node 28 on the network 16 served by the server 24. For example, the controller 12 may be set up as an OS-2 requester, or as a client in a network 16. The data base manager 114 of the controller modules 92 may require that the controller 12 host either the server software or the client software for the data base manager program. For example, the notes server or client may be associated with the Lotus Notes.TM. data base manager for managing all data base files associated with the automated test harness 10.

Each of the network interfaces 102, 122, 132, 142 may be configured to facilitate communication by the controller 12 at an operating system level with the resources 18, 20, 22. Thus, the controller 12, communicating as a node 28 of the network 16 may instruct the resources 18, 20, 22 to load executables. Nevertheless, as mentioned previously, the resource 22 may be preloaded with applications. This configuration gives less flexibility but may be used by the automated test harness 10. Nevertheless, even in such a configuration, the resource 22 may be enslaved by the controller 12, communicating with the operating system 34 to reconfigure the resource 22.

An explanation of the relationships between the various opcodes 180 and the threads 150 from which and to which each may be directed is explained below. However, referring to FIG. 3, the sources and destinations of all opcodes 180 may be illustrated by schematic block diagram. Since the logic of the automated test harness 10 is so intertwined among the various threads 160, 170, 172, 174, and opcodes 180, all opcodes 180 and threads 150 need to be identified, and their relationships identified, before the operation and logic of each may be properly explained with reference to each of the other opcodes 180 and threads.

In addition, Tables 1-3 below illustrate logical relations between various opcodes 180. Entries in Tables 1-3 are arranged more-or-less according to which process 106 in the second column is sending an opcode 180 in the third column. In certain circumstances, a thread 150, in general, of the scheduler 110 may send an opcode 180 to another general thread 150 of the scheduler 110.

For each opcode 180 identified in the middle or third ("opcode") column, the process 106 in the second ("from") column is the sending process 106, and the process 106 in the fourth ("to") column receives the opcode 180. The sending process 106 identified in the second column may send an opcode 180 upon receiving an opcode 180, or occurrence of some other initiating event, identified in the first ("initiated by") column.

The receiving process 106 of the fourth ("to") column may send a return opcode 180 identified in the fifth ("returns") column. A returned opcode 180 is typically sent to the sending process 106 of the second ("from") column, but may be sent to another process 106, either of which will be identified in the sixth or last ("to") column.

                                      TABLE 1
    __________________________________________________________________________
    OPCODES FROM SCHEDULER TO RESOURCE MANAGER
    INITIATED BY
            FROM
                OPCODE  TO   RETURNS   TO
    __________________________________________________________________________
            SCH INIT.sub.--
                        RM 108
                             INIT.sub.--
                                       SCH
            110 QUEUES 230   SUCCESS 242
                                       110
            SCH INIT.sub.--
                        RM 108
                             INIT.sub.--
                                       SCH
            110 QUEUES 230   FAIL 244  110
    BLD.sub.--
            SCH SETUP.sub.--
                        RM 108
                             SETUP.sub.--
                                       SCH
    SUCCESS 220
            110 PROGRAM 232  FAIL 248  110
    BLD.sub.--
            SCH SETUP.sub.--
                        RM 108
                             SETUP.sub.--
                                       SCH
    SUCCESS 220
            110 PROGRAM 232  SUCCESS 246
                                       110
    BLD.sub.--
            SCH SETUP.sub.--
                        RM 108
                             RESERVE.sub.--
                                       SCH
    SUCCESS 220
            110 PROGRAM 232  PENDING 258
                                       110
    BLD.sub.--
            SCH SETUP.sub.--
                        RM 108
                             RESERVE.sub.--
                                       SCH
    SUCCESS 220
            110 PROGRAM 232  SUCCESS 260
                                       110
    TEST.sub.--
            SCH CLEANUP 234
                        RM 108
                             CLEANUP.sub.--
                                       SCH
    COMPLETE 214
            110              SUCCESS 250
                                       110
    TEST.sub.--
            SCH CLEANUP 234
                        RM 108
                             CLEANUP.sub.--
                                       SCH
    COMPLETE 214
            110              FAIL 248  110
    RESOURCE.sub.--
            SCH CLEANUP 234
                        RM 108
                             CLEANUP.sub.--
                                       SCH
    REBOOT 256
            110              SUCCESS 250
                                       110
    RESOURCE.sub.--
            SCH CLEANUP 234
                        RM 108
                             CLEANUP.sub.--
                                       SCH
    REBOOT 256
            110              FAIL 248  110
    LAUNCHER.sub.--
            SCH CLEANUP.sub.--
                        RM 108
                             CLEANUP.sub.--
                                       SCH
    FAIL 218
            110 LAUNCHER.sub.--
                             LAUNCHER.sub.--
                                       110
                FAIL 236     FAIL.sub.-- FAIL 268
    LAUNCHER.sub.--
            SCH CLEANUP.sub.--
                        RM 108
                             CLEANUP.sub.--
                                       SCH
    FAIL 218
            110 LAUNCHER.sub.--
                             LAUNCHER.sub.-- FAIL
                                       110
                FAIL 236     .sub.--
                             SUCCESS 266
    (LAUNCH SCH RESERVE.sub.--
                        RM 108
                             RESERVE.sub.--
                                       SCH
    ENTRY   110 REMOVE 238   REMOVE.sub.--
                                       110
    DELETED)                 SUCCESS 262
    (LAUNCH SCH RESERVE.sub.--
                        RM 108
                             RESERVE.sub.--
                                       SCH
    ENTRY   110 REMOVE 238   REMOVE.sub.--
                                       110
    DELETED)                 FAIL 264
    CONSOLE.sub.--
            SCH EXIT 204
                        RM 108
    EXIT 229
            110
    __________________________________________________________________________

                                      TABLE 2
    __________________________________________________________________________
    OPCODES FROM RESOURCE MANAGER TO SCHEDULER
    INITIATED BY   FROM OPCODE        TO
    __________________________________________________________________________
    INIT.sub.-- QUEUES 230
                   RM 108
                        INIT.sub.-- SUCCESS 242
                                      SCH 110
    INIT.sub.-- QUEUES 230
                   RM 108
                        INIT.sub.-- FAIL 244
                                      SCH 110
    SETUP.sub.-- PROGRAM 232
                   RM 108
                        SETUP.sub.-- SUCCESS 246
                                      SCH 110
    SETUP.sub.-- PROGRAM 232
                   RM 108
                        SETUP.sub.-- FAIL 248
                                      SCH 110
    CLEANUP 234    RM 108
                        CLEANUP.sub.-- SUCCESS 250
                                      SCH 110
    CLEANUP 234    RM 108
                        CLEANUP.sub.-- FAIL 252
                                      SCH 110
    (UNIDENTIFIED  RM 108
                        INCONSISTENT.sub.--
                                      SCH 110
    OPCODE)             DATA 254
    (RESOURCE REBOOTED)
                   RM 108
                        RESOURCE.sub.-- REBOOT 256
                                      SCH 110
    SETUP.sub.-- PROGRAM 232
                   RM 108
                        RESERVE.sub.-- PENDING 158
                                      SCH 110
    (R.sub.-- P 158 SENT PREVIOUSLY)
                   RM 108
                        RESERVE.sub.-- SUCCESS 160
                                      SCH 110
    RESERVE.sub.-- REMOVE 238
                   RM 108
                        RESERVE.sub.-- REMOVE.sub.--
                                      SCH 110
                        SUCCESS 262
    RESERVE.sub.-- REMOVE 238
                   RM 108
                        RESERVE.sub.-- REMOVE.sub.--
                                      SCH 110
                        FAIL 264
    CLEANUP.sub.-- LAUNCHER.sub.--
                   RM 108
                        CLEANUP.sub.-- LAUNCHER.sub.--
                                      SCH 110
    FAIL 236            FAIL.sub.-- SUCCESS 266
    CLEANUP.sub.-- LAUNCHER.sub.--
                   RM 108
                        CLEANUP.sub.-- LAUNCHER.sub.--
                                      SCH 110
    FAIL 236            FAIL.sub.-- FAIL 268
    __________________________________________________________________________

                                      TABLE 3
    __________________________________________________________________________
    OTHER OPCODES
    INITIATED BY
            FROM
                OPCODE  TO   RETURNS   TO
    __________________________________________________________________________
    RESERVE.sub.--
            SCH SUITES.sub.--
                        SCH  SETUP.sub.--
                                       RM
    SUCCESS 260
            110 READY 121
                        110  PROGRAM 232
                                       108
            SCH TEST.sub.--
                        SCH  CLEANUP 234
                                       RM
            110 COMPLETE 214
                        110            108
    SETUP.sub.--
            SCH BLD.sub.--
                        SCH  BLD.sub.--
                                       SCH
    SUCCESS 246
            110 CONFIG 224
                        110  SUCCESS 220
                                       110
    SETUP.sub.--
            SCH BLD.sub.--
                        SCH  BLD.sub.--
                                       SCH
    SUCCESS 246
            110 CONFIG 224
                        110  FAIL 222  110
    BLD.sub.--
            SCH BLD.sub.--
                        SCH  (LAUNCHER 112
    CONFIG 224
            110 SUCCESS 220
                        110  INITIATED)
    BLD.sub.--
            SCH BLD.sub.--
                        SCH
    CONFIG 224
            110 FAIL 222
                        110
            ANY SYSTEM.sub.--
                        SCH
                LOG 210 110
            LAU LAUNCHER.sub.--
                        SCH
            112 PASS 216
                        110
            LAU LAUNCHER.sub.--
                        SCH
            112 FAIL 218
                        110
            CON CONSOLE.sub.--
                        SCH
            116 ADDRESS 225
                        110
            CON CONSOLE.sub.--
                        RM 108
            116 ADDRESS 225
    (USER ON
            CON ADD.sub.--
                        RM 108
    CONSOLE GUI)
            116 PREFIX 226
    (USER ON
            CON DEL.sub.--
                        RM 108
    CONSOLE GUI)
            116 PREFIX 228
    (USER ON
            CON CONSOLE.sub.--
                        SCH
    CONSOLE GUI)
            116 EXIT 229
                        110
    __________________________________________________________________________

• Inventors
  Anderson, II, Micheil M.; Bangerter, Howard K.; Borup, Marlon T.; Byer, James E.; Cable, Darin L.; Doxey, Ross W.; Graham, Richard S.; Hale, Todd D.; Hawley, Britt J.; Lamplugh, Richard W.; Pray, Rick L.;
• Assignee
  Novell Inc. (Provo, UT)
• Published
  Jun-1-1999
• Current US Classes:
  709/208
  717/178
• Application #
  518160
• International Classes
  G06F 013/00
• Field of Search
  395/183.03 395/183.14 395/712 395/200.47 395/200.49 395/200.5 395/200.51 395/200.52 395/200.38 395/200.39 395/200.41
• Examiner
  An; Meng-Al T.
• Agent
  Madson & Metcalf