WO2000075783A1 - Protocol acknowledgment between homogeneous systems - Google Patents
Protocol acknowledgment between homogeneous systems Download PDFInfo
- Publication number
- WO2000075783A1 WO2000075783A1 PCT/US2000/015342 US0015342W WO0075783A1 WO 2000075783 A1 WO2000075783 A1 WO 2000075783A1 US 0015342 W US0015342 W US 0015342W WO 0075783 A1 WO0075783 A1 WO 0075783A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- operating system
- testing
- test
- target device
- computer
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/22—Detection or location of defective computer hardware by testing during standby operation or during idle time, e.g. start-up testing
- G06F11/26—Functional testing
- G06F11/263—Generation of test inputs, e.g. test vectors, patterns or sequences ; with adaptation of the tested hardware for testability with external testers
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3696—Methods or tools to render software testable
Definitions
- This invention relates to product quality assurance and to test systems and methods for validating operating systems provided in computerized products. More particularly, the present invention relates to product quality assurance and to test systems and methods for validating an operating systems during the development of computerized products. Even more particularly, the present invention relates to product quality assurance and to test systems and methods for validating operating systems, such as Windows CE, manufactured and sold by Microsoft, Incorporated of Redmond, WA, typically provided in computerized products.
- TCP Transmission Control Protocol
- O/S O/S-independent manner.
- sent messages requiring an acknowledgment must be maintained in a list which cross-references the identification of a sent message with an execution thread, such thread waiting for such acknowledgment.
- Such related art systems follow a lengthy sequence: creating a message ID prior to sending the initial message; adding an element in a list associating the execution thread with the message ID; sending the message; blocking the sending thread of the execution until the receiving code unblocks it; acknowledging, by the remote process, the sent message by sending back an ACK message containing the original message ID; receiving ACK message by the sending machine; parsing for the message ID of the originally sent message; looking-up the message ID in the list; determining which execution thread to release from the list; and finally, releasing the original sending thread of execution to continue program execution.
- a code which is simpler, shorter, and less error-prone via an alternative method of processing ACKs would be beneficial where a plurality of actions could be executed upon reception of an acknowledgment message (e.g., multiple cross-referencing and attendant delays elimination, code for the reception of ACK which is largely identical with a single-thread case, priority data which need not be maintained in a sent message list if multiple threads are prioritized, and an ID list which need not be entirely scanned to determine a thread-release priority as an O/S restarts all threads with an appropriate priority).
- an acknowledgment message e.g., multiple cross-referencing and attendant delays elimination, code for the reception of ACK which is largely identical with a single-thread case, priority data which need not be maintained in a sent message list if multiple threads are prioritized, and an ID list which need not be entirely scanned to determine a thread-release priority as an O/S restarts all threads with an appropriate priority.
- a beneficial system would also be able to implement multiple pending threads of execution which are waiting for an ACK message, the threads needing merely to use the O/S-provided function of waiting for an event handle which was embedded by the initial "send" in the protocol header. Likewise advantageous, multiple threads of execution should be triggered, without additional cross- reference processing, by an ACK for any message of a plurality of sent messages.
- the present invention to be commercially available under applicant's assignee's trademark of CEValidatorTM, is an operating system validator, (herein also referred to as O/S Validator, and designated in the Figures with the numeral "1 ,” which solves the foregoing problems by providing a test system encompassing an automated test suite method for testing a port of an operating system, such as Windows CE, in a target device's hardware and/or software being newly developed.
- O/S Validator an operating system validator
- the O/S Validator comprises a comprehensive code base, specifically developed to purposefully stress the O/S, device driver, OEM Adaptation Layer (OAL), and hardware interaction through the use of a unique contemporaneous multithreaded execution methodology for acknowledging protocol between homogeneous systems.
- the provided test suites focus on identifying three primary defects: hardware design, hardware programming (drivers/OAL), and operating system interaction. Special diagnostic emphasis is placed on Windows CE subsystems which have historically shown the most problems.
- the test suites comprise nearly 1500 tests which include system stress-testing routines, as well as feature-and-function tests, providing a complete analysis of a Windows CE port. These tests are grouped by the O/S Validator.
- the O/S Validator includes both test source codes and executable programs for all tests.
- GUI graphical user interface
- the O/S Validator generates useful error information when a target device fails a test. While the suites are running, results are displayed in a plurality of dynamically created log windows as well as in a configuration's summary tab.
- the logging windows contain the full text of a given test's results. Failures are color-coded red to ease identification. Navigation buttons in the logging window allow the user to quickly move from one failure to another.
- the logging APIs in the tests also cause a prolog and an epilog to be generated in each result file.
- Information such as concurrently running processes, battery power level, and execution date and time is automatically recorded in the results file and displayed in the log window.
- Useful summary information such as loss of program memory, loss of storage memory, or total test execution time is provided in a log window tab.
- the summary information for a given test result is also collected and displayed in a Summary tab of the configuration window. The summary tab reports the number of PASS and FAIL test cases in real time. Breakout PASS and FAIL numbers for individual suites are
- the present invention uses an O/S-generated event handle as a member field of a protocol, releasing an execution thread which is waiting for an acknowledgment (ACK) message.
- a O/S-generated event handle such as a WIN32 event handle, used for blocking an original send thread of execution, is placed in a header and sent back in the ACK.
- a receiving thread does not require the looking-up of a transaction identification (ID) in a list. Instead, the receiving thread unblocks any threads waiting for the event.
- the present invention uses the O/S-provided events, the O/S-internally-maintained event list, and the O/S- internally -maintained list of blocking threads (i.e. sending threads).
- adding an element which associates the execution thread with the message ID in a list looking-up the message ID in a list, and determining which execution thread to release from a list entry.
- the present invention offers many advantages in expediting a plurality of actions upon the reception of an acknowledgment message: multiple cross-referencing and attendant delays are eliminated, code for the reception of ACK is largely identical with the single-thread case, priority data need not be maintained in a sent message list if the multiple threads are prioritized, and the ID list need not be entirely scanned to determine the thread-release priority as the O/S restarts all threads with the appropriate priority.
- the threads need merely use the O/S-provided function of waiting for an event handle which was embedded by the initial "send" in the protocol header.
- multiple threads of execution may be triggered, without additional cross-reference processing, by an ACK for any of a plurality of sent messages.
- Figure 1.0 is a schematic diagram representative of a computerized product presently being provided with an embedded operating system in a control unit.
- Figure 2.0 is a manufacturing flow diagram illustrating quality assurance testing on a computerized product provided with an embedded operating system, in accordance with the present invention.
- Figure 3.0 is a block diagram showing the primary components of the operating system validator of the present invention, including a graphical user interface, an engine, a plurality of test suites, and a logging library, in accordance with the present invention.
- Figure 4.0 is a block diagram showing the execution of a plurality of test suite configurations from a host device for testing a plurality of target devices provided with an embedded operating system, in accordance with the present invention.
- Figure 5.0 is a block diagram showing the present invention essentially as depicted in
- Figure 5 a illustrates an arrangement where communications between a plurality of host and target devices may occur over Ethernet, in accordance with the present invention.
- Figure 6 shows yet another arrangement for a test suite execution situation, in accordance with the present invention.
- Figure 7.0 is a table listing of functional areas of specific APIs tested in automatic and manual test suite execution, in accordance with the present invention.
- Figures 8A. 8B, and 8C together, comprise a comprehensive table listing of functional areas and their respective APIs which may be tested in automatic or manual mode, in accordance with the present invention.
- Figure 9.0 is a table listing of selected APIs for use in building automation scripts, in accordance with the present invention.
- Figure 10.0 is a schematic diagram representative of the concept of the present invention providing source code for all executable programs, in accordance with the present invention.
- Figure 11.0 is a block diagram representation of a window showing the test suites selection options as well as other related summary functions, in accordance with the present invention.
- Figure 12.0 is a block diagram representation of a logging window showing tabs for test results, test failures, and related test summary options, in accordance with the present invention.
- Figure 13 illustrates, in graph form, the test cycle time as a function of the number of test devices being concurrently tested, in accordance with the present invention.
- Figure 14.0 is a block diagram representation of a configuration window showing tabs for executing a variety of configuration related functions, in accordance with the present invention.
- Figures 15A, 15B, and 15C together, comprise a table listing testing details of the operating system components, in accordance with the present invention.
- Figure 16 is a flowchart illustrating the unique contemporaneous multithreading capability, with respect to acknowledgment protocol between homogeneous systems, in accordance with the present invention.
- Figure 1.0 shows a computerized product 1000, (9), typical of computerized products such as computer workstations, set-top boxes, gaming systems, bar-code scanners, and factory automation systems presently being provided with an embedded operating system, depicted by the numeral 1001a.
- product 1000 may comprise a typical target device 9 provided with an operating system 1001a, such as an embedded
- the computerized product 1000 may function as a standalone device, having an installation of the present invention, the O/S Validator 1, for testing and validating its own operating system 1001a.
- the standalone testing facilitates new test development and de-bugging of reported defects as elaborate knowledge of O/S Validator infrastructure is not necessitated.
- product 1000 may function, in a manufacturing quality assurance testing environment M, as a host computer 4 having an installation of the present invention, the O/S Validator 1 for testing a target devices 9, and being provided with an operating system 1001a.
- a computerized product 1000 may comprise, by example, several subcomponents, including a control unit 1020, including a plurality of input/ output ports 1021, a keyboard 1009, a printer 1010, a mouse 1011, and a monitor 1012.
- the sub-components 1009, 1010, 1011, and 1012, themselves, may be testable target devices.
- the typical control unit 1020 itself, comprises several sub-components, including a central processing unit 1001 , storage devices such as a hard disk drive 1004, other memory components including RAM, 1002, a ROM 1003, a compact disc 1005, an audio component 1006, a network/server card 1007, and a modem 1008.
- FIG. 3 shows the primary components of the O/S Validator 1 including a graphical user interface (GUI) 2, an Engine 3, a plurality of Test Suites 11, and a Logging Library 12.
- GUI graphical user interface
- Engine 3 a plurality of Test Suites 11, and a Logging Library 12.
- HarnessLink.dll a component called HarnessLink.dll, designated by the numeral 7 within O/S Validator 1 and discussed below in more detail.
- Figure 4.0 illustrates a host computer 4 provided with O/S Validator 1. As illustrated, a plurality of target devices 9, are provided with an O/S 1001a for being tested in accordance with the present invention.
- the O/S Validator 1 has capabilities of generating testing configurations, such as a plurality of test configurations 21a, 21b, and 21c, for testing a particular function under control of OS 1001a within target devices 9.
- a device side component, termed CEHarness 8 communicates with Engine 3 in O/S Validator 1. As depicted in Figures 5 and 5a, CEHarness 8 may also communicate with Engine 3 in O/S Validator 1 via
- Ethernet means 4a illustrates, that because communication may occur over Ethernet, a plurality of hosts 4 may run suites against a plurality of target devices 9.
- CEHarness 8 may also communicate with Engine 3 in O/S Validator 1 via suite execution connection 1021a, where host computer 4 may comprise a NT host computer, where the logging library
- test results 12 is also provided in a target device 9, and where the test results are provided to host computer 4 via socket connections 1021b.
- the O/S Validator 1 tests and validates target devices 9 provided with an embedded operating system, by example a Windows CE Operating System.
- the O/S Validator 1 functions by (1) validating the Windows CE port to a target device, (2) providing stress and performance testing, (3) logging and analyzing results, (4) testing a plurality of functional areas, including a plurality of applications program interfaces (APIs), (See Table 1.0 and Table 2.0 in Figures 7, 8A, 8B, and 8C, respectively), (5) executing a plurality of pass/fail tests in a plurality of test suites, (6) facilitating customization of tests in the automated suites, (7) providing a host side graphical test harness, (8) stressing and evaluating memory performance, (9) providing means for building test automation, including a plurality of APIs, (See Table 3.0 in Figure 9.0), and (10) providing a results analysis tool termed CEAnalyzer.
- APIs applications program interfaces
- O/S Validator 1 includes, for all tests, both test source codes SC and executable programs EP (also referred to as test executable).
- test executable EP also referred to as test executable.
- the sole implementation requirement for a test executable EP is that test case "passes” and “failures” be reported using two specific APIs: WRITETESTPASS ( ) and
- the O/S Validator 1 method further comprises mediating between the GUI 2 and the test cases encapsulated in the test executables EP and providing a means by which the GUI 2 distributes and coordinates the execution of tests.
- the test suites 11 comprise text files 5 composed of suite language commands (e.g. PUT, RUN, WAIT, and DELETE) which are the direct expressions of the tasks needed to distribute and execute the test.
- suite language commands e.g. PUT, RUN, WAIT, and DELETE
- Other supported suite commands are GET for retrieving a file from a target device 9, RUNHOST for running an executable program EP on the host computer 4 which is useful for client/ server style tests,
- WAITHOST for waiting for the termination of a process on the host computer 4, which is also useful for client/server style tests, PUTSYSTEM for putting a file in the device's system directory (/Windows), SLEEP for basic timing when all else fails, MSGBOX for displaying a message box on the host machine, SETREG for adding or changing a registry setting on the device, and DELREG for removing a registry setting from the device.
- Initial suite file comments in addition to providing internal suite documentation, are presented as the suite descriptions in GUI 2.
- the O/S Validator 1 method includes organizing the test suite files 5 by their hierarchical placement within a directory structure on the host computer 4.
- test suites 11 are divided at the top level as being either automatic test suites (Au), manual test suites (Ma), or stress test suites (SS).
- Automatic suites Au are tests which do not require any user intervention during their execution.
- manual suites Ma do require user intervention (e.g. keyboard and touch panel suites).
- the O/S Validator 1 method includes stressing the system, through the stress suites SS by pressing input/output (I/O) throughput to the limit, operating with little or no available program or object store memory, and possibly bringing down a custom file system with multi-threaded concurrent stressing. Below this top level of hierarchy, the O/S Validator 1 method includes arranging the test suites
- Figure 3.0 shows the primary components of the O/S Validator 1 including a graphical user interface (GUI) 2, an Engine 3, a plurality of Test Suites 11, and a Logging Library 12.
- GUI graphical user interface
- O/S Validator 1 utilizes GUI 2 as a Visual Basic component since it works well for any level of user.
- the GUI 2 design is based on the concept of interfacing the user input with underlying components.
- the Engine 3 holds the core of the functionality on the host 4.
- the Engine 3 reads a plurality of suite files 5, parses them, and executes the commands.
- the Engine 3 obtains the information from the GUI 2 and uses the information to set-up a variety of execution options.
- the Engine 3 is written in C/C+ + language.
- HarnessLink.dll 7 is an ActiveX control. HarnessLink.dll 7 is instantiated and called from the GUI 2 by a variety of information, which is passed to the Engine 3 before it begins to execute. Dll link 7 also functions to communicate between the Engine 3 and the GUI 2 during the execution, to relay information, error messages, and some dynamic run-time commands.
- the target device 9 comprises a device-side (as opposed to a host-side) component called CEHarness 8.
- CEHarness 8 is a C/C+ + program residing on the target device 9 and, as shown in Figure 4, communicates nearly exclusively with the Engine 3, unless broadcasting target information on the network, with the GUI 2 receiving such information and passing it to the Engine 3 (See Figures 5 and 5a).
- CEHarness 8 is an event-driven application, where the Engine 3 sends the events and CEHarness 8 responds.
- the two remaining components, test suites 11 and logging library 12, are intertwined since the test suites 11 are written using a plurality of application program interfaces (APIs) 13 that are part of the logging library 12 (See Figures 8A, 8B, and 8C). These APIs 13 have substantial functionality and are somewhat dependent on the information passed through the component chain.
- APIs 13 application program interfaces
- the logging library 12 has a simple functionality concept, communicating the test results 14 by creating log files 15 by either logging TCP/IP information 16 back to the GUI 2 (See Figure 5.0) or by writing results 14 and log files 15 directly to the device 9 (See Figure 6.0).
- a logging window LW shows the test results 14 in test files 15, failures F and a summary tab SumT which facilitates user-access to program memory, passes, failures, and timing information.
- the plurality of test suites tests 11 comprise the indispensable component of the O/S Validator 1.
- Figure 13 illustrates in graph form that the test cycle time CT decreases as the number of test devices are concurrently tested.
- GUI 2 is a complex code due to its degree of functionality required for handling its layer of components.
- the GUI 2 provides a "wizard" whose primary function is walking new users through the various selectable settings and listing the default settings.
- GUI 2 also provides a configuration window CW, as the means for executing a test run which comprises a single pass through a set of selected suites 11 on a target device 9.
- a plurality of configurations 21a, 21b, and 21c may be run to simulate a variety of scenarios.
- the contents of a configuration window CW comprises a plurality of tabs for user control.
- suite tab S provides a tree view of suite files directory under the O/S Validator directory.
- This tree view is organized to provide meaningful distinctions between the types of tests 11 the user selects. Additionally, this tree view is created as the user opens the configuration window CW, allowing the user to extend the O/S Validator 1 by adding new user-input suites to the suite file directory created by the O/S Validator 1 installation program. Test suites 11 are scripts of commands that the Engine 3 reads and then performs actions corresponding to such scripts of commands. The suite files
- the logging tabs contains considerable valuable information.
- the user may select three methods of logging, namely LH for logging to the host 4, LTD for logging to the target device 9, or LHD for logging to both host 4 and target device 9.
- the log information is then stored in a configurable directory listed in an edit box. All this information is sent through the DLL 7 to the Engine 3 and then to CEHarness 8 in target device 9.
- the information is acquired by the logging library 12 upon running a test 11.
- Other tabs in the configuration window CW include a set stress condition tab SC, selecting high priority threads during suite execution by selecting thread tab T, reducing program and storage memory by selecting tabs PM and SM, selecting run time by selecting tab SRT, and stopping the run by selecting tab STOP.
- the user can utilize infinite loop tab Hoop for finding memory leaks in the system.
- Useful summary information such as loss of program memory, loss of storage memory, or total test execution time is provided in a summary tab SumT.
- the summary information for a given test result is also collected and displayed in a Summary tab SumT.
- the summary tab reports the number of PASS and FAIL test cases in real time.
- Breakout PASS and FAIL numbers for individual suites are also displayed.
- the configuration window's Summary tab facilitates quick navigation to an individual failure among perhaps thousands of test results.
- the exact source file and line number corresponding to a logged failure are automatically reported by the O/S Validator's logging APIs. Since O/S Validator provides the source code for all of its executables, being able to go directly to the source code reporting an error is a powerful adjunct to the textural descriptions of the failure.
- the logging options vary dramatically in their implementation and effects. The first option presumes that whenever the user runs a test suite 11 resulting in a "pass", a set of log files 15, summarizing these test results 14, automatically issues. Dependent upon the chosen logging method, the summary files 15 are created by either CEHarness 8 or the Engine 3.
- the Engine 3 traverses all the log files 16 in the logging directory, so the user may receive a log files list not corresponding to the test 11 being run.
- the user can delete the log directory before running, or the user can select a logging option such as "Return only the newest summary results" which causes the Engine 3 to traverse only one log file 15 for each test 11. This means that if the user ran a file system test thirty times on a given day, there would only be one entry in the summary log for that test corresponding to the most recent execution. The summary log would have only one entry for each test 11 whose log file 15 still resides in the logged directory. The other two options are handled in the GUI 2.
- a window termed Available Targets, shows the active devices on the network that are broadcasting information to the GUI 2.
- the active devices send a large volume of information, some of which is displayed in the Available Targets window.
- the user may view the information by selecting a View/ Available Targets menu.
- Another window must be accessed to obtain the complete set of broadcasted information.
- This broadcast information is valuable, because it is used to initialize the connection from the Engine 3 to a particular CEHarness 8 in a test target device 9.
- the stress Test Settings SS are now further described.
- Stress Suites 11 are manifested in a variety of forms; however, their fundamental purpose is for stressing the target device 9 by running a very long test, running multiple iterations of a short test, or electing a wide range of parameters in one test. These remain specific to their own test 11 area, for example, a Database Stress Suite only stresses the Database functionality of an O/S, such as Windows CE. The Stress Test Options are distinguishable from Stress
- the Stress Test Options are different, because they target functionality to provide more broadband stress scenarios equivalent to real world usage models. These scenarios run in conjunction with any user-selected set of test suite files 5.
- the Stress Test Options can and should be run both conjointly and disjointly as, in so doing, a significant boost to the range of any test plan is provided.
- the first two Stress Test Options are related to the memory on the target device 9.
- the first Stress Test Option is the Low Virtual Memory Option which greatly reduces the amount of virtual memory of the target device before ranning the selected tests 11. This simulates the realistic harsh circumstances that might occur when a user has opened fifteen applications, effecting a malfunction.
- the second Stress Test Option is the Low Storage Memory option.
- this second Stress Test Option fills the storage memory of the target device 9 to its maximum capacity in order to experience the target device 9 response to low storage memory solutions. In some cases, this second Stress Test Option is also good for testing application programs as contained within the target device 9 as they may depend on non-existent storage memory.
- the next three Stress Test Options are execution options.
- the first executable stress option is the infinite loop, which is ideal for long test cycles. A common problem in many device drivers is malfunction under long, intense, stressful situations. This infinite loop stress test provides a test for determining a possible breakdown. This infinite loop test runs the selected suites 11 until the user manually hits the Stop button.
- the next stress execution option is the configurable CPU cycle deprivation test available as a text file identified as O/S Validator ⁇ Tests ⁇ TestInputFiles called Data.txt.
- Data.txt Two examples are provided in the file which a user may copy, reuse, or modify.
- the text file, Data.txt controls the number of threads and their attributes that the user may include in his test run. In other words, the user can run his tests while other processes are consuming the CPU time, eliminating many problems including timing.
- the last Stress Test Option is the Random Execution. When the user selects this option, the GUI 2 will reorder the list of test suites 11 at run time so that they run in a different order. This option is ideal, because it facilitates the diagnoses of interaction problems with various components.
- the remaining Test Run options are generic activities that the user may control.
- the first option, "Use Selected Target Exclusively,” is important, because, when a target device 9 is connected over the Ethernet, other users in a subnet can access that target device 9 through the O/S Validator 1 available target devices window. This helps to create stress on the target device 9. In the event that the user wishes to isolate a problem, extra stress should not be applied. In that situations, the user should have exclusive access to the target device 9.
- the last Test Run Option is set Target Time which prompts the Engine 3 to send the time from the host computer 4 to the target device 9, and thereby synchronizing the target device 9 system time to the host computer 4 time.
- Synchronization is advantageous as the log files return with a date and time stamp related to the date and time on the target device 9.
- the last tab before running a test is the Environment Settings tab which contains valuable information for the various selectable environment variables.
- These environment settings are designed to extend and abstract the test suite files 5 by allowing the test suite files to contain environment variable instead of hard carded information.
- the Serial Tests take an available com-port as a parameter. If the com-port is not entered as an environment variable, the test fails, because it is unable to open a com-port. All the environment variables used in the suites are provided; however, any additional environment variables may be user-added to the user-input suites.
- a Test Status is available for obtaining status information for the current test run. The information is dynamically being updated.
- a Suites Run section window lists the selected suites that have started. The user may open any log file from this window by selecting a desired test icon. The other icons in this control provide failure information. The failure icons are shown, by example, as a stylized beaker crossed-out with a red "X.”
- a Test Run Summary Information keeps tracks of the number of test suite files run, suites selected, suites with a failure, and percentage of suites with a failure.
- the user may select a Configure Failed Suites tab prompting the appearance of a new configuration window selecting all the failed suites in the current test run, facilitating regression testing.
- Test Details The remaining two sections are called Test Details.
- One of these Test Details section monitors the individual test cases that pass, as well as fail, which section is valuable for gauging the value of a test run.
- the remaining Test Details section is the Failed Suites section where all selected suites with a fail are listed by suite name, showing the number of corresponding passing and failing test cases. All this information gives the user a very good idea of the limits of his target device 9 during a test run (i.e. what passes, and more importantly what fails).
- the primary object of the present invention is to properly test a port of an O/S 1001a, such as Windows CE.
- O/S 1001a such as Windows CE.
- hundreds of suite tests 11 are needed and are provided by the O/S Validator 1.
- nearly 1500 test suites 11, as grouped by the verified O/S subsystem, are provided.
- the O/S Validator 1 includes both source codes and executable codes for all tests 11, covering the major O/S 1001a subsystems and the common adaptation drivers, with special emphasis on subsystems historically exhibiting the most problems.
- O/S subsystem components tested by the O/S Validator 1 include: Ethernet/NDIS, serial port driver, display driver, touch panel driver, mouse driver, keyboard driver, OEM Adaptation Layer, and PC Card adapter driver.
- Figure 15A, 15B, and 15C together, show a table listing testing details of these system components.
- Engine 3 is linked to the GUI 2 via a component termed HarnessLink.dll 7, which is an ActiveX control.
- HarnessLink.dll 7 provides a set of functions on the GUI 2 for calling (i.e. affecting) the Engine 3.
- a majority of HarnessLink.dll 7 function-calls set-up some parameters for the Engine 3's command line. All the initial information is passed to the Engine 3 through this command line, insuring readiness of the Engine 3 for specified execution.
- a plurality of GUI- related functions provide information on the command line. The information on the command line corresponds the GUI 2 information.
- HarnessLink.dll 7 serves is to communicate activity during the running of the Engine 3 by opening a named pipe. If an error or a need arises to transmit some memory information, the Engine 3 communicates through the named pipe. A named pipe insures that the communication between the Engine
- HarnessLink.dll 7 When the HarnessLink.dll 7 receives a message from the pipe, it signals the appropriate VB event which, in turn, causes the GUI 2 to take the information and process it accordingly. As described with relation to Figure 5.0, Engine 3 communicates with one HarnessLink.dll 7, which, in turn, communicates with one CEHarness
- the Engine 3 execution is simple: a command line is received and processed, establishing the execution socket connection to the target device, opening the pipe for communication with the GUI 2, reading the test suite files 5, and subsequently executing the tests in three phases, PreExecution, Execution, and PostExecution.
- the PreExecution stage establishes the error socket connection between the target device 9 and the host 4. Relevant data such as logging paths and styles, various test run information, and stress scenarios are sent during the PreExecution stage.
- the Execution stage involves a response to each sequential suite command.
- a suite command is generally sent by the host 4 and is processed by the CEHarness 8 which, in turn, responds with a socket message when execution of the command is completed.
- CEHarness 8 in test target device 9 is a significantly more complicated component than the Engine 3. This complexity is because each device 9 has one instance of CEHarness 8 at any given time; however, that device can handle a plurality of simultaneous connections, a vitally important feature to the testing methodology provided by the O/S Validator 1.
- a broadcast thread When the user starts CEHarness 8, it creates two threads that endure through the entire execution time: a broadcast thread and an execution thread. This broadcast thread updates information such as the device IP, connection type, and available com-ports every ten seconds, sending a broadcast message at the same rate to the network.
- the connection type will change to PPP_PEER. If this occurs, the broadcast message is sent only to the host 4 from which the target device 9 is directly connected. If the user changes the connection at some point during execution, the message is updated. Meanwhile, the execution thread waits for a connection attempt from an Engine 3. When the execution thread receives the connection, it spawns another thread, a main execution thread, that performs the various functions required. The main execution thread starts another socket for sending any error or memory information. Thus, the execution thread is event-driven, receiving a command and responding appropriately. Each connection attempt spawns its own execution thread; therefore, a single CEHarness 8 may have many active connections, extending the test functionality by running a plurality of configurations simultaneously on one target device 9, and thereby creating a more realistic stress situation.
- Figure 16 is a flowchart illustrating the present invention protocol acknowledgment system 4000 comprising a message sender 2000 and a message receiver 3000.
- the message sender has a receive thread 2001 and a send thread 2009 which may parallel-process information.
- the send thread 2009 generates a message at block 2008, placing a header around the message to form a packet where a WIN32 event handle is in a field of the header, as shown in block 2007.
- Such packet is then sent, as per block 2006, either to block 2005 for blocking the send thread 2009 or to block 3001 for receiving the packet by the message receiver 3000, which would in turn, either send the packet having the WIN32 event handle in a field of the header, as shown by block 3002, to the receive thread 2001 via receiving block 2002 or continue processing in accordance with message receiver 3000 functions.
- the receive thread 2001 having received the acknowledgment packet, then uses the WIN32 event handle in the header of the acknowledgment packet for unblocking the send thread at block 2003, and then either resumes the send thread 2009 at block 2004 or continue processing of receive thread 2001 functions.
- the Logging library 12 shown in Figure 3.0, is a complex tool integrated into the O/S Validator 1 in various ways.
- the Logging library 12 is integrated into the source files for the tests.
- the tests make calls to the library APIs whereupon the library handles all the details regarding capture and recordation of test results.
- the Logging library 12 also supports a variety of communication options.
- the recommended option is through the TCP, allowing the user to see the readout of the log files as they migrate from the TCP connection.
- Another communication option is direct logging to files on a device. This can be advantageous, for example, if the user wants to log to a PCMCIA card but does not want extra information to be broadcast over the network.
- the Logging library 12 acts as the device-side component to the TCP communications
- a host 4 component acts as the GUI 2-side component to the communications.
- This aspect of the logging library 12 provides a log window on the host 4 and color coding for the test results.
- failure messages are displayed as a red line.
- the name and location of the source code file as well as the line number where the message was generated is included in the logging library 12 messages.
- a detailed error message is provided describing current events in the program.
- Each log window has a summary tab which facilitates user-access to program memory, passes, failures, and timing information.
- Another important feature of the log files is that they capture a large volume of information at the beginning and at the end of a test. This information provides snapshot of the Memory, System, Power, and other valuable information.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
- Test And Diagnosis Of Digital Computers (AREA)
- Computer And Data Communications (AREA)
Abstract
Description
Claims
Priority Applications (6)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
JP2001501988A JP2003501743A (en) | 1999-06-04 | 2000-05-31 | Protocol response between similar systems |
KR1020017015622A KR20020012254A (en) | 1999-06-04 | 2000-05-31 | Protocol acknowledgment between homogeneous systems |
AU54618/00A AU5461800A (en) | 1999-06-04 | 2000-05-31 | Protocol acknowledgment between homogeneous systems |
EP00939544A EP1224551A1 (en) | 1999-06-04 | 2000-05-31 | Protocol acknowledgment between homogeneous systems |
BR0012111-8A BR0012111A (en) | 1999-06-04 | 2000-05-31 | Method and system for computer-based testing and validation of an embedded operating system |
HK03100624.1A HK1048540A1 (en) | 1999-06-04 | 2003-01-23 | Protocol acknowledgment between homogeneous systems |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US13762999P | 1999-06-04 | 1999-06-04 | |
US60/137,629 | 1999-06-04 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO2000075783A1 true WO2000075783A1 (en) | 2000-12-14 |
Family
ID=22478338
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US2000/015342 WO2000075783A1 (en) | 1999-06-04 | 2000-05-31 | Protocol acknowledgment between homogeneous systems |
Country Status (8)
Country | Link |
---|---|
EP (1) | EP1224551A1 (en) |
JP (1) | JP2003501743A (en) |
KR (1) | KR20020012254A (en) |
CN (1) | CN1353835A (en) |
AU (1) | AU5461800A (en) |
BR (1) | BR0012111A (en) |
HK (1) | HK1048540A1 (en) |
WO (1) | WO2000075783A1 (en) |
Cited By (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6928378B2 (en) * | 2002-07-23 | 2005-08-09 | Sun Microsystems, Inc. | Stress testing at low cost through parallel execution of unit tests |
CN100403701C (en) * | 2004-08-09 | 2008-07-16 | 华为技术有限公司 | Goal device service realization testing method and system |
CN112202628A (en) * | 2020-09-08 | 2021-01-08 | 杭州涂鸦信息技术有限公司 | WiFi module serial port protocol automatic test system and method |
Families Citing this family (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN1300961C (en) * | 2003-03-06 | 2007-02-14 | 华为技术有限公司 | Test method |
KR102332506B1 (en) * | 2017-07-19 | 2021-12-01 | 엔에이치엔 주식회사 | Method and system for invoking event based package module |
KR102327927B1 (en) * | 2017-07-19 | 2021-11-19 | 엔에이치엔 주식회사 | Method and system for invoking event based package module |
CN108008977B (en) * | 2017-12-27 | 2021-01-15 | 遵义职业技术学院 | Software development service platform oriented to function outsourcing |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5600790A (en) * | 1995-02-10 | 1997-02-04 | Research In Motion Limited | Method and system for loading and confirming correct operation of an application program in a target system |
US5630049A (en) * | 1994-11-30 | 1997-05-13 | Digital Equipment Corporation | Method and apparatus for testing software on a computer network |
US6029257A (en) * | 1996-12-06 | 2000-02-22 | Intergraph Corporation | Apparatus and method for testing computer systems |
-
2000
- 2000-05-31 BR BR0012111-8A patent/BR0012111A/en not_active Application Discontinuation
- 2000-05-31 WO PCT/US2000/015342 patent/WO2000075783A1/en not_active Application Discontinuation
- 2000-05-31 EP EP00939544A patent/EP1224551A1/en not_active Withdrawn
- 2000-05-31 CN CN00808464A patent/CN1353835A/en active Pending
- 2000-05-31 AU AU54618/00A patent/AU5461800A/en not_active Abandoned
- 2000-05-31 KR KR1020017015622A patent/KR20020012254A/en not_active Application Discontinuation
- 2000-05-31 JP JP2001501988A patent/JP2003501743A/en active Pending
-
2003
- 2003-01-23 HK HK03100624.1A patent/HK1048540A1/en unknown
Patent Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5630049A (en) * | 1994-11-30 | 1997-05-13 | Digital Equipment Corporation | Method and apparatus for testing software on a computer network |
US5600790A (en) * | 1995-02-10 | 1997-02-04 | Research In Motion Limited | Method and system for loading and confirming correct operation of an application program in a target system |
US6029257A (en) * | 1996-12-06 | 2000-02-22 | Intergraph Corporation | Apparatus and method for testing computer systems |
Cited By (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6928378B2 (en) * | 2002-07-23 | 2005-08-09 | Sun Microsystems, Inc. | Stress testing at low cost through parallel execution of unit tests |
CN100403701C (en) * | 2004-08-09 | 2008-07-16 | 华为技术有限公司 | Goal device service realization testing method and system |
CN112202628A (en) * | 2020-09-08 | 2021-01-08 | 杭州涂鸦信息技术有限公司 | WiFi module serial port protocol automatic test system and method |
CN112202628B (en) * | 2020-09-08 | 2022-09-02 | 杭州涂鸦信息技术有限公司 | WiFi module serial port protocol automatic test system and method |
Also Published As
Publication number | Publication date |
---|---|
KR20020012254A (en) | 2002-02-15 |
AU5461800A (en) | 2000-12-28 |
HK1048540A1 (en) | 2003-04-04 |
BR0012111A (en) | 2002-03-12 |
EP1224551A1 (en) | 2002-07-24 |
JP2003501743A (en) | 2003-01-14 |
CN1353835A (en) | 2002-06-12 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6182246B1 (en) | Protocol acknowledgment between homogeneous system | |
EP1236108A1 (en) | A system and method for testing and validating devices having an embedded operating system | |
US8356282B1 (en) | Integrated development environment for the development of electronic signal testing strategies | |
US6408403B1 (en) | Method for integrating automated software testing with software development | |
US7143310B2 (en) | Generating standalone MIDlets from a testing harness | |
US7134049B2 (en) | System and method for sequencing and performing very high speed software downloads concurrent with system testing in an automated production environment | |
AU2004233548B2 (en) | Method for Computer-Assisted Testing of Software Application Components | |
US8589886B2 (en) | System and method for automatic hardware and software sequencing of computer-aided design (CAD) functionality testing | |
US8074204B2 (en) | Test automation for business applications | |
US5513315A (en) | System and method for automatic testing of computer software | |
US7165191B1 (en) | Automated verification of user interface tests on low-end emulators and devices | |
US9098635B2 (en) | Method and system for testing and analyzing user interfaces | |
US6418543B1 (en) | Apparatus and method for debugging source code | |
KR101008977B1 (en) | Method of testing OSGi service platform and test tool thereof | |
US20020091968A1 (en) | Object-oriented data driven software GUI automated test harness | |
US20090287643A1 (en) | Context based script generation | |
WO2008045117A1 (en) | Methods and apparatus to analyze computer software | |
CN115686540A (en) | RPA control method and system based on Hongmong system | |
CN111813671A (en) | IMA software simulation test system | |
Nevedrov | Using jmeter to performance test web services | |
US7143361B2 (en) | Operator interface controls for creating a run-time operator interface application for a test executive sequence | |
WO2000075783A1 (en) | Protocol acknowledgment between homogeneous systems | |
CN111639029B (en) | Reliability test method and system for soft AC product | |
US8402388B2 (en) | Setting up a communication procedure between instances and a protocol tester using the method | |
CN114265769A (en) | Test system and method based on python script test case |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
WWE | Wipo information: entry into national phase |
Ref document number: 00808464.5 Country of ref document: CN |
|
AK | Designated states |
Kind code of ref document: A1 Designated state(s): AE AL AM AT AU AZ BA BB BG BR BY CA CH CN CR CU CZ DE DK DM EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A1 Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
WWE | Wipo information: entry into national phase |
Ref document number: IN/PCT/2001/01481/MU Country of ref document: IN |
|
ENP | Entry into the national phase |
Ref document number: 2001 501988 Country of ref document: JP Kind code of ref document: A |
|
WWE | Wipo information: entry into national phase |
Ref document number: 1020017015622 Country of ref document: KR |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2000939544 Country of ref document: EP |
|
WWP | Wipo information: published in national office |
Ref document number: 1020017015622 Country of ref document: KR |
|
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
WWP | Wipo information: published in national office |
Ref document number: 2000939544 Country of ref document: EP |
|
WWW | Wipo information: withdrawn in national office |
Ref document number: 1020017015622 Country of ref document: KR |
|
WWW | Wipo information: withdrawn in national office |
Ref document number: 2000939544 Country of ref document: EP |