# US 7,613,954 B2 · Test executive with stack corruption detection

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 7,613,954 B2
- Document ID: US7613954B2
- Status: Granted
- Kind: B2
- Application number: 11/107,337
- Filed: 2005-04-15
- Published: 2006-06-29
- Granted: 2009-11-03
- Earliest claimed: 2004-12-21
- Assignees: National Instruments Corporation
- Inventors: James A. Grey; Erik Crank
- Web page: https://patentgrep.com/patent/US7613954B2

## CPC

- G06F 11/3672: {Test management}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

A system and method for detecting and/or preventing execution problems caused by user-supplied code modules that are called by steps of a test executive sequence. The test executive sequence may include a plurality of test executive steps. At least a subset of the steps may be configured to call user-supplied code modules. The test executive sequence may be executed on a host computer under control of a test executive engine. For each step that calls a user-supplied code module, the test executive engine may perform certain actions to detect and/or prevent execution problems caused by the user-supplied code module. For example, the test executive engine may be operable to automatically detect stack corruption caused by the user-supplied code module, may be operable to utilize stack safety buffers to avoid stack corruption problems caused by the user-supplied code module, and/or may include features for aiding a user in determining whether the user-supplied code module contains an uninitialized local variable.

## Claims

### Claim 1

A computer-readable memory medium storing program instructions executable to:
include a plurality of test executive steps in a test executive sequence in response to user input;
configure each respective step of the plurality of test executive steps to call a respective user-supplied code module in response to user input;
determine an initial location on a stack before execution of the test executive sequence begins; and
execute the test executive sequence, wherein said executing comprises executing each respective step of the plurality of test executive steps after determining the initial location;
wherein executing each respective step comprises:
storing a first portion of the stack ranging from the initial location to a current stack pointer location;
invoking execution of the respective user-supplied code module called by the respective step; and
checking the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing to determine whether the first portion of the stack changed during execution of the respective user-supplied code module called by the respective step;
wherein for each respective step of the plurality of test executive steps, said storing the first portion of the stack comprises storing a respective portion of the stack beginning at the same initial location.

### Claim 2 (depends on 1)

The computer-readable memory medium of claim 1,
wherein the program instructions are further executable to report an error in response to determining that the first portion of the stack changed during execution of a user-supplied code module called by a test executive step.

### Claim 3 (depends on 1)

The computer-readable memory medium of claim 1,
wherein the program instructions are further executable to stop execution of the test executive sequence in response to determining that the first portion of the stack changed during execution of a user-supplied code module called by a test executive step.

### Claim 4 (depends on 1)

The computer-readable memory medium of claim 1, wherein for each respective step of the plurality of test executive steps:
said storing the first portion of the stack comprises storing a portion of the stack that the respective user-supplied code module called by the respective step is not supposed to change;
wherein said checking the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing comprises checking whether the respective user-supplied code module called by the respective step wrote data to the portion of the stack that the respective user-supplied code module is not supposed to change.

### Claim 5 (depends on 1)

The computer-readable memory medium of claim 1, wherein for each respective step of the plurality of test executive steps, said executing the respective step further comprises:
copying one or more parameters to pass to the respective user-supplied code module called by the respective step onto the stack after said storing the first portion of the stack;
wherein the respective user-supplied code module called by the respective step is allowed to access the one or more parameters on the stack but not the first portion of the stack.

### Claim 6 (depends on 1)

The computer-readable memory medium of claim 1,
wherein determining the initial location on the stack comprises determining a location of a stack pointer for the stack before the execution of the test executive sequence begins.

### Claim 7 (depends on 1)

The computer-readable memory medium of claim 1,
wherein said determining the initial location on the stack is performed only once.

### Claim 8 (depends on 1)

The computer-readable memory medium of claim 1,
wherein the initial location represents a location of a stack pointer for the stack when a thread begins execution;
wherein said determining the initial location is performed when the thread begins execution.

### Claim 9 (depends on 1)

The computer-readable memory medium of claim 1,
wherein said storing the first portion of the stack comprises storing the first portion of the stack in a heap.

### Claim 10 (depends on 1)

The computer-readable memory medium of claim 1,
wherein one or more of the plurality of test executive steps have pre-functionality, wherein the pre-functionality for each respective step of the one or more steps comprises functionality to be performed before invoking execution of the respective user-supplied code module called by the respective step;
wherein for each respective step that has pre-functionality, said executing the respective step further comprises executing the pre-functionality of the respective step before said invoking execution of the respective user-supplied code module called by the respective step.

### Claim 11 (depends on 1)

The computer-readable memory medium of claim 1,
wherein one or more of the plurality of test executive steps have post-functionality, wherein the post-functionality for each respective step of the one or more steps comprises functionality to be performed after the respective user-supplied code module called by the respective step finishes executing;
wherein for each respective step that has post-functionality, said executing the respective step further comprises executing the post-functionality of the respective step after the respective user-supplied code module called by the respective step finishes executing.

### Claim 12 (depends on 1)

The computer-readable memory medium of claim 1,
wherein the program instructions are further executable to display a graphical user interface for creating the test executive sequence;
wherein said including the plurality of test executive steps in the test executive sequence is performed in response to user input received to the graphical user interface requesting inclusion of the test executive steps in the test executive sequence.

### Claim 13 (depends on 1)

The computer-readable memory medium of claim 1,
wherein for each respective step of the plurality of test executive steps, the program instructions are further executable to display a graphical user interface for configuring the respective step;
wherein for each respective step of the plurality of test executive steps, the respective step is configured to call a respective user-supplied code module in response to user input received to the graphical user interface for configuring the respective step, wherein the user input specifies the respective user-supplied code module.

### Claim 14 (depends on 1)

The computer-readable memory medium of claim 1,
wherein said executing the test executive sequence comprises executing the test executive sequence under control of a test executive engine;
wherein for each respective step of the plurality of test executive steps, the test executive engine is operable to perform said storing the first portion of the stack, invoking execution of the respective user-supplied code module called by the respective step, and checking the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing.

### Claim 15

A computer-implemented method comprising:
including a plurality of test executive steps in a test executive sequence in response to user input;
configuring each respective step of the plurality of test executive steps to call a respective user-supplied code module in response to user input;
determining an initial location on a stack before execution of the test executive sequence begins; and
executing the test executive sequence, wherein said executing comprises executing each respective step of the plurality of test executive steps after determining the initial location;
wherein each respective comprises:
storing a first portion of the stack ranging from the initial location to a current stack pointer location;
invoking execution of the respective user-supplied code module called by the respective step; and
checking the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing to determine whether the first portion of the stack changed during execution of the respective user-supplied code module called by the respective step;
wherein for each respective step of the plurality of test executive steps, said storing the first portion of the stack comprises storing a respective portion of the stack beginning at the same initial location.

### Claim 16 (depends on 15)

The method of claim 15, wherein for each respective step of the plurality of test executive steps:
said storing the first portion of the stack comprises storing a portion of the stack that the respective user-supplied code module called by the respective step is not supposed to change;
wherein said checking the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing comprises checking whether the respective user-supplied code module called by the respective step wrote data to the portion of the stack that the respective user-supplied code module is not supposed to change.

### Claim 17 (depends on 15)

The method of claim 15, wherein for each respective step of the plurality of test executive steps, said executing the respective step further comprises:
copying one or more parameters to pass to the respective user-supplied code module called by the respective step onto the stack after said storing the first portion of the stack;
wherein the respective user-supplied code module called by the respective step is allowed to access the one or more parameters on the stack but not the first portion of the stack.

### Claim 18 (depends on 15)

The method of claim 15,
wherein said storing the first portion of the stack comprises storing the first portion of the stack in a heap.

### Claim 19 (depends on 15)

The method of claim 15,
wherein one or more of the plurality of test executive steps have pre-functionality, wherein the pre-functionality for each respective step of the one or more steps comprises functionality to be performed before invoking execution of the respective user-supplied code module called by the respective step;
wherein for each respective step that has pre-functionality, said executing the respective step further comprises executing the pre-functionality of the respective step before said invoking execution of the respective user-supplied code module called by the respective step.

### Claim 20 (depends on 15)

The method of claim 15,
wherein one or more of the plurality of test executive steps have post-functionality, wherein the post-functionality for each respective step of the one or more steps comprises functionality to be performed after the respective user-supplied code module called by the respective step finishes executing;
wherein for each respective step that has post-functionality, said executing the respective step further comprises executing the post-functionality of the respective step after the respective user-supplied code module called by the respective step finishes executing.

### Claim 21 (depends on 15)

The method of claim 15,
wherein said executing the test executive sequence comprises executing the test executive sequence under control of a test executive engine;
wherein for each respective step of the plurality of test executive steps, the test executive engine is operable to perform said storing the first portion of the stack, invoking execution of the respective user-supplied code module called by the respective step, and checking the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing.

### Claim 22

A system comprising:
a sequence editor;
a test executive engine;
a host computer configured to execute the sequence editor and the test executive engine; and
a unit under test (UUT) coupled to the host computer;
wherein the host computer is configured to execute the sequence editor to create a test executive sequence for testing the UUT, wherein said creating the test executive sequence comprises including a plurality of test executive steps in the test executive sequence in response to user input to the sequence editor and configuring each respective step of the plurality of test executive steps to call a respective user-supplied code module in response to user input to the sequence editor;
wherein the host computer is further configured to determine an initial location on a stack before execution of the test executive sequence begins;
wherein the host computer is further configured to execute the test executive engine, wherein the test executive engine is configured to control execution of the test executive sequence, wherein said controlling execution of the test executive sequence comprises causing each respective step of the plurality of test executive steps to be executed on the host computer after determining the initial location;
wherein for each respective step, the test executive engine is configured to:
store a first portion of the stack ranging from the initial location to a current stack pointer location;
invoke execution of the respective user-supplied code module called by the respective step; and
check the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing to determine whether the first portion of the stack changed during execution of the respective user-supplied code module called by the respective step;
wherein for each respective step of the plurality of test executive steps, said storing the first portion of the stack comprises storing a respective portion of the stack beginning at the same initial location.

### Claim 23

A computer-readable memory medium comprising program instructions executable to:
include a plurality of test executive steps in a test executive sequence in response to user input;
configure each of the test executive steps to call a user-supplied code module in response to user input; and
execute the test executive sequence, wherein said executing comprises executing each of the test executive steps in the test executive sequence;
wherein for each test executive step in the test executive sequence, said executing the test executive step comprises;
allocating a safety buffer on a call stack to prevent the user-supplied code module called by the test executive step from corrupting the call stack;
initializing the safety buffer so that each bit in the safety buffer is set to an initial value;
copying one or more parameters for the user-supplied code module called by the test executive step onto the call stack after said allocating the safety buffer; and
invoking execution of the user-supplied code module called by the test executive step.

### Claim 24 (depends on 23)

The computer-readable memory medium of claim 23, wherein the program instructions are further executable to:
receive user input specifying a prototype for each user-supplied code module that is called by a test executive step in the test executive sequence;
wherein said receiving user input specifying the prototypes for the user-supplied code modules includes receiving user input specifying a first prototype for a first user-supplied code module called by a first test executive step, wherein the specified first prototype does not match an actual prototype of the first user-supplied code module;
wherein executing the first test executive step comprises;
allocating a safety buffer on the call stack;
initializing the safety buffer so that each bit in the safety buffer is set to an initial value;
copying one or more parameters according to the specified first prototype onto the call stack after allocating the safety buffer; and
invoking execution of the first user-supplied code module called by the first test executive step;
wherein said allocating the safety buffer on the call stack prevents the first user-supplied code module from corrupting the call stack.

### Claim 25 (depends on 24)

The computer-readable memory medium of claim 24,
wherein the first user-supplied code module writes onto the call stack beyond bounds of the one or more parameters copied onto the call stack according to the specified first prototype;
wherein said allocating the safety buffer on the call stack prevents said writing beyond the bounds of the one or more parameters from corrupting the call stack.

### Claim 26 (depends on 23)

The computer-readable memory medium of claim 23,
wherein the test executive sequence includes a first test executive step that calls a first user-supplied code module;
wherein the first user-supplied code module writes onto the call stack beyond bounds of the one or more parameters for the first user-supplied code module copied onto the call stack;
wherein said allocating the safety buffer on the call stack prevents said writing beyond the bounds of the one or more parameters from corrupting the call stack.

### Claim 27 (depends on 26)

The computer-readable memory medium of claim 26, wherein the program instructions are further executable to:
receive user input specifying a first prototype for the first user-supplied code module called by the first test executive step, wherein the specified first prototype does not match an actual prototype of the first user-supplied code module;
wherein said writing beyond the bounds of the one or more parameters is caused by the mismatch between the specified first prototype and the actual prototype of the first user-supplied code module.

### Claim 28 (depends on 23)

The computer-readable memory medium of claim 23,
wherein for each test executive step in the test executive sequence, said executing the test executive step further comprises checking the safety buffer after the user-supplied code module called by the test executive step finishes executing to determine whether each bit in the safety buffer is still set to the initial value.

### Claim 29 (depends on 28)

The computer-readable memory medium of claim 28,
wherein the program instructions are further executable to report an error in response to determining that a user-supplied code module called by a test executive step caused a bit in a safety buffer to be set to a value other than the initial value.

### Claim 30 (depends on 28)

The computer-readable memory medium of claim 28,
wherein the program instructions are further executable to stop execution of the test executive sequence in response to determining that a user-supplied code module called by a test executive step caused a bit in a safety buffer to be set to a value other than the initial value.

### Claim 31 (depends on 23)

The computer-readable memory medium of claim 23,
wherein said initializing the safety buffer so that each bit in the safety buffer is set to an initial value comprises initializing the safety buffer so that each bit in the safety buffer is set to zero.

### Claim 32 (depends on 23)

The computer-readable memory medium of claim 23,
wherein one or more test executive steps in the test executive sequence have pre-functionality, wherein the pre-functionality for each of the one or more test executive steps comprises functionality to be performed before invoking execution of the user-supplied code module called by the test executive step;
wherein for each test executive step in the test executive sequence that has pre-functionality, said executing the test executive step further comprises executing the pre-functionality of the step before said invoking execution of the user-supplied code module called by the test executive step.

### Claim 33 (depends on 23)

The computer-readable memory medium of claim 23,
wherein one or more test executive steps in the test executive sequence have post-functionality, wherein the post-functionality for each of the one or more test executive steps comprises functionality to be performed after the user-supplied code module called by the test executive step finishes executing;
wherein for each test executive step in the test executive sequence that has post-functionality, said executing the test executive step further comprises executing the post-functionality of the step after the user-supplied code module called by the test executive step finishes executing.

### Claim 34 (depends on 23)

The computer-readable memory medium of claim 23,
wherein the program instructions are further executable to display a graphical user interface for creating the test executive sequence;
wherein said including the plurality of test executive steps in the test executive sequence is performed in response to user input received to the graphical user interface requesting inclusion of the test executive steps in the test executive sequence.

### Claim 35 (depends on 23)

The computer-readable memory medium of claim 23,
wherein for each test executive step in the test executive sequence, the program instructions are further executable to display a graphical user interface for configuring the test executive step;
wherein for each test executive step in the test executive sequence, the test executive step is configured to call a user-supplied code module in response to user input received to the graphical user interface for configuring the test executive step, wherein the user input specifies the user-supplied code module.

### Claim 36 (depends on 23)

The computer-readable memory medium of claim 23,
wherein said executing the test executive sequence comprises executing the test executive sequence under control of a test executive engine;
wherein for each test executive step in the test executive sequence, the test executive engine is operable to perform said allocating the safety buffer, initializing the safety buffer, copying the one or more parameters onto the call stack, and invoking execution of the user-supplied code module called by the test executive step.

### Claim 37 (depends on 23)

The computer-readable memory medium of claim 23, wherein for a first test executive step in the test executive sequence, said invoking execution of the user-supplied code module called by the first test executive step comprises one of:
calling a function in a DLL;
invoking a method of an ActiveX object; or
invoking execution of a graphical program.

### Claim 38

A computer-implemented method comprising:
including a plurality of test executive steps in a test executive sequence in response to user input;
configuring each of the test executive steps to call a user-supplied code module in response to user input; and
executing the test executive sequence, wherein said executing comprises executing each of the test executive steps in the test executive sequence;
wherein for each test executive step in the test executive sequence, said executing the test executive step comprises:
allocating a safety buffer on a call stack to prevent the user-supplied code module called by the test executive step from corrupting the call stack;
initializing the safety buffer so that each bit in the safety buffer is set to an initial value;
copying one or more parameters for the user-supplied code module called by the test executive step onto the call stack after said allocating the safety buffer; and
invoking execution of the user-supplied code module called by the test executive step.

### Claim 39 (depends on 38)

The method of claim 38, further comprising:
receiving user input specifying a prototype for each user-supplied code module that is called by a test executive step in the test executive sequence;
wherein said receiving user input specifying the prototypes for the user-supplied code modules includes receiving user input specifying a first prototype for a first user-supplied module called by a first test executive step, wherein the specified first prototype does not match an actual prototype of the first user-supplied code module;
wherein executing the first test executive step comprises:
allocating a safety buffer on the call stack;
initializing the safety buffer so that each bit in the safety buffer is set to an initial value;
copying one or more parameters according to the specified first prototype onto the call stack after allocating the safety buffer; and
invoking execution of the first user-supplied code module called by the first test executive step;
wherein said allocating the safety buffer on the call stack prevents the first user-supplied code module from corrupting the call stack.

### Claim 40 (depends on 39)

The method of claim 39,
wherein the first user-supplied code module writes onto the call stack beyond bounds of the one or more parameters copied onto the call stack according to the specified first prototype;
wherein said allocating the safety buffer on the call stack prevents said writing beyond the bounds of the one or more parameters from corrupting the call stack.

### Claim 41 (depends on 38)

The method of claim 38,
wherein the test executive sequence includes a first test executive step that calls a first user-supplied code module;
wherein the first user-supplied code module writes onto the call stack beyond bounds of the one or more parameters for the first user-supplied code module copied onto the call stack;
wherein said allocating the safety buffer on the call stack prevents said writing beyond the bounds of the one or more parameters from corrupting the call stack.

### Claim 42 (depends on 38)

The method of claim 38,
wherein for each test executive step in the test executive sequence, said executing the test executive step further comprises checking the safety buffer after the user-supplied code module called by the test executive step finishes executing to determine whether each bit in the safety buffer is still set to the initial value.

### Claim 43 (depends on 38)

The method of claim 38,
wherein said initializing the safety buffer so that each bit in the safety buffer is set to an initial value comprises initializing the safety buffer so that each bit in the safety buffer is set to zero.

### Claim 44 (depends on 38)

The method of claim 38,
wherein one or more test executive steps in the test executive sequence have pre-functionality, wherein the pre-functionality for each of the one or more test executive steps comprises functionality to be performed before invoking execution of the user-supplied code module called by the test executive step;
wherein for each test executive step in the test executive sequence that has pre-functionality, said executing the test executive step further comprises executing the pre-functionality of the step before said invoking execution of the user-supplied code module called by the test executive step.

### Claim 45 (depends on 38)

The method of claim 38,
wherein one or more test executive steps in the test executive sequence have post-functionality, wherein the post-functionality for each of the one or more test executive steps comprises functionality to be performed after the user-supplied code module called by the test executive step finishes executing;
wherein for each test executive step in the test executive sequence that has post-functionality, said executing the test executive step further comprises executing the post-functionality of the step after the user-supplied code module called by the test executive step finishes executing.

### Claim 46 (depends on 38)

The method of claim 38,
wherein said executing the test executive sequence comprises executing the test executive sequence under control of a test executive engine;
wherein for each test executive step in the test executive sequence, the test executive engine is operable to perform said allocating the safety buffer, initializing the safety buffer, copying the one or more parameters onto the call stack, and invoking execution of the user-supplied code module called by the test executive step.

### Claim 47

A system comprising:
a sequence editor;
a test executive engine;
a host computer configured to execute the sequence editor and the test executive engine; and
a unit under test (UTJT) coupled to the host computer;
wherein the host computer is configured to execute the sequence editor to create a test executive sequence for testing the UUT, wherein said creating the test executive sequence comprises including a plurality of test executive steps in the test executive sequence in response to user input to the sequence editor and configuring each of the test executive steps to call a user-supplied code module in response to user input to the sequence editor;
wherein the host computer is further configured to execute the test executive engine, wherein the test executive engine is configured to control execution of the test executive sequence, wherein said controlling execution of the test executive sequence comprises causing each of the test executive steps in the test executive sequence to be executed on the host computer;
wherein for each test executive step in the test executive sequence, the test executive engine is configured to:
allocate a safety buffer on a call stack to prevent the user-supplied code module called by the test executive step from corrupting the call stack;
initialize the safety buffer so that each bit in the safety buffer is set to an initial value;
copy one or more parameters for the user-supplied code module called by the test executive step onto the call stack after said allocating the safety buffer; and
invoke execution of the user-supplied code module called by the test executive step.

### Claim 48

A computer-readable memory medium comprising program instructions executable to:
include a plurality of test executive steps in a test executive sequence in response to user input;
configure each of the test executive steps to call a user-supplied code module in response to user input;
receive user input specifying an amount of stack space to initialize before invoking execution of the user-supplied code modules called by the test executive steps; and
execute the test executive sequence, wherein said executing comprises executing each of the test executive steps in the test executive sequence;
wherein for each test executive step in the test executive sequence, said executing the test executive step comprises:
initializing at least a portion of unused space on a stack so that each bit in the portion is set to an initial value, wherein initializing the at least a portion of unused space on the stack comprises initializing the specified amount of stack space; and
invoking execution of the user-supplied code module called by the test executive step after said initializing the portion of unused space on the stack;
wherein the user-supplied code module called by the test executive step utilizes the stack for storage of one or more local variables used in the user-supplied code module;
wherein said initializing the portion of unused space on the stack aids in determining whether the user-supplied code module called by the test executive step has an uninitialized local variable bug.

### Claim 49 (depends on 48)

The computer-readable memory medium of claim 48,
wherein said initializing the at least a portion of unused space on the stack comprises initializing all unused space on the stack.

### Claim 50 (depends on 48)

The computer-readable memory medium of claim 48,
wherein the program instructions are further executable to receive user input specifying the initial value to which to set each bit in the portion of unused space on the stack;
wherein said initializing the portion of unused space on the stack comprises setting each bit in the portion to the specified initial value.

### Claim 51 (depends on 50)

The computer-readable memory medium of claim 50,
wherein said receiving user input specifying the initial value to which to set each bit in the portion of unused space on the stack comprises receiving user input specifying to set each bit in the portion of unused space on the stack to either 0 or 1.

### Claim 52 (depends on 50)

The computer-readable memory medium of claim 50, wherein the program instructions are executable to:
receive user input specifying a first initial value to which to set each bit in the portion of unused space on the stack;
execute the test executive sequence a first time using the first initial value;
receive user input specifying a second initial value to which to set each bit in the portion of unused space on the stack, wherein the second initial value is different than the first initial value;
execute the test executive sequence a second time using the second initial value;
wherein executing the test executive sequence multiple times using different initial values for the portion of unused space on the stack aids in determining whether a user-supplied code module called by a test executive step in the test executive sequence has an uninitialized local variable bug.

### Claim 53 (depends on 48)

The computer-readable memory medium of claim 48,
wherein for each test executive step in the test executive sequence, said executing the test executive step further comprises copying one or more parameters for the user-supplied code module called by the test executive step onto the stack.

### Claim 54 (depends on 48)

The computer-readable memory medium of claim 48,
wherein one or more test executive steps in the test executive sequence have pre-functionality, wherein the pre-functionality for each of the one or more test executive steps comprises functionality to be performed before invoking execution of the user-supplied code module called by the test executive step;
wherein for each test executive step in the test executive sequence that has pre-functionality, said executing the test executive step further comprises executing the pre-functionality of the step before said invoking execution of the user-supplied code module called by the test executive step.

### Claim 55 (depends on 48)

The computer-readable memory medium of claim 48,
wherein one or more test executive steps in the test executive sequence have post-functionality, wherein the post-functionality for each of the one or more test executive steps comprises functionality to be performed after the user-supplied code module called by the test executive step finishes executing;
wherein for each test executive step in the test executive sequence that has post-functionality, said executing the test executive step further comprises executing the post-functionality of the step after the user-supplied code module called by the test executive step finishes executing.

### Claim 56 (depends on 48)

The computer-readable memory medium of claim 48,
wherein the program instructions are further executable to display a graphical user interface for creating the test executive sequence;
wherein said including the plurality of test executive steps in the test executive sequence is performed in response to user input received to the graphical user interface requesting inclusion of the test executive steps in the test executive sequence.

### Claim 57 (depends on 48)

The computer-readable memory medium of claim 48,
wherein for each test executive step in the test executive sequence, the program instructions are further executable to display a graphical user interface for configuring the test executive step;
wherein for each test executive step in the test executive sequence, the test executive step is configured to call a user-supplied code module in response to user input received to the graphical user interface for configuring the test executive step, wherein the user input specifies the user-supplied code module.

### Claim 58 (depends on 48)

The computer-readable memory medium of claim 48,
wherein said executing the test executive sequence comprises executing the test executive sequence under control of a test executive engine;
wherein for each test executive step in the test executive sequence, the test executive engine is operable to perform said initializing and said invoking execution of the user-supplied code module called by the test executive step.

### Claim 59

A computer-implemented method comprising:
including a plurality of test executive steps in a test executive sequence in response to user input;
configuring each of the test executive steps to call a user-supplied code module in response to user input;
receiving user input specifying an amount of stack space to initialize before invoking execution of the user-supplied code modules called by the test executive steps; and
executing the test executive sequence, wherein said executing comprises executing each of the test executive steps in the test executive sequence;
wherein for each test executive step in the test executive sequence, said executing the test executive step comprises:
initializing at least a portion of unused space on a stack so that each bit in the portion is set to an initial value, wherein initializing the at least a portion of unused space on the stack comprises initializing the specified amount of stack space; and
invoking execution of the user-supplied code module called by the test executive step after said initializing the portion of unused space on the stack;
wherein the user-supplied code module called by the test executive step utilizes the stack for storage of one or more local variables used in the user-supplied code module;
wherein said initializing the portion of unused space on the stack aids in determining whether the user-supplied code module called by the test executive step has an uninitialized local variable bug.

### Claim 60 (depends on 59)

The method of claim 59,
wherein said initializing the at least a portion of unused space on the stack comprises initializing all unused space on the stack.

### Claim 61 (depends on 59)

The method of claim 59, further comprising:
receiving user input specifying the initial value to which to set each bit in the portion of unused space on the stack;
wherein said initializing the portion of unused space on the stack comprises setting each bit in the portion to the specified initial value.

### Claim 62 (depends on 61)

The method of claim 61,
wherein said receiving user input specifying the initial value to which to set each bit in the portion of unused space on the stack comprises receiving user input specifying to set each bit in the portion of unused space on the stack to either 0 or 1.

### Claim 63 (depends on 61)

The method of claim 61, wherein the method comprises:
receiving user input specifying a first initial value to which to set each bit in the portion of unused space on the stack;
executing the test executive sequence a first time using the first initial value;
receiving user input specifying a second initial value to which to set each bit in the portion of unused space on the stack, wherein the second initial value is different than the first initial value; and
executing the test executive sequence a second time using the second initial value;
wherein executing the test executive sequence multiple times using different initial values for the portion of unused space on the stack aids in determining whether a user-supplied code module called by a test executive step in the test executive sequence has an uninitialized local variable bug.

### Claim 64 (depends on 59)

The method of claim 59,
wherein one or more test executive steps in the test executive sequence have pre-functionality, wherein the pre-functionality for each of the one or more test executive steps comprises functionality to be performed before invoking execution of the user-supplied code module called by the test executive step;
wherein for each test executive step in the test executive sequence that has pre-functionality, said executing the test executive step further comprises executing the pre-functionality of the step before said invoking execution of the user-supplied code module called by the test executive step.

### Claim 65 (depends on 59)

The method of claim 59,
wherein one or more test executive steps in the test executive sequence have post-functionality, wherein the post-functionality for each of the one or more test executive steps comprises functionality to be performed after the user-supplied code module called by the test executive step finishes executing;
wherein for each test executive step in the test executive sequence that has post-functionality, said executing the test executive step further comprises executing the post-functionality of the step after the user-supplied code module called by the test executive step finishes executing.

### Claim 66 (depends on 59)

The method of claim 59,
wherein said executing the test executive sequence comprises executing the test executive sequence under control of a test executive engine;
wherein for each test executive step in the test executive sequence, the test executive engine is operable to perform said initializing and said invoking execution of the user-supplied code module called by the test executive step.

### Claim 67

A system comprising:
a sequence editor;
a test executive engine;
a host computer configured to execute the sequence editor and the test executive engine; and
a unit under test (UUT) coupled to the host computer;
wherein the host computer is configured to execute the sequence editor to create a test executive sequence for testing the UUT, wherein said creating the test executive sequence comprises including a plurality of test executive steps in the test executive sequence in response to user input to the sequence editor and configuring each of the test executive steps to call a user-supplied code module in response to user input to the sequence editor;
wherein the host computer is further configured to execute the sequence editor to receive user input specifying an amount of stack space to initialize before invoking execution of the user-supplied code modules called by the test executive steps;
wherein the host computer is further configured to execute the test executive engine, wherein the test executive engine is configured to control execution of the test executive sequence, wherein said controlling execution of the test executive sequence comprises causing each of the test executive steps in the test executive sequence to be executed on the host computer;
wherein for each test executive step in the test executive sequence, the test executive engine is configured to:
initialize at least a portion of unused space on a stack so that each bit in the portion is set to an initial value, wherein initializing the at least a portion of unused space on the stack comprises initializing the specified amount of stack space; and
invoke execution of the user-supplied code module called by the test executive step after said initializing the portion of unused space on the stack;
wherein the user-supplied code module called by the test executive step utilizes the stack for storage of one or more local variables used in the user-supplied code module;
wherein said initializing the portion of unused space on the stack aids in determining whether the user-supplied code module called by the test executive step has an uninitialized local variable bug.

### Claim 68

A computer-readable memory medium storing program instructions executable to:
include a plurality of test executive steps in a test executive sequence in response to user input;
configure each respective step of the plurality of test executive steps to call a respective user-supplied code module in response to user input;
determine an initial location on a stack; and
execute the test executive sequence, wherein said executing comprises executing each respective step of the plurality of test executive steps after determining the initial location;
wherein executing each respective step comprises:
storing a first portion of the stack ranging from the initial location to a current stack pointer location;
invoking execution of the respective user-supplied code module called by the respective step; and
checking the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing to determine whether the first portion of the stack changed during execution of the respective user-supplied code module called by the respective step;
wherein for each respective step of the plurality of test executive steps, said storing the first portion of the stack comprises storing a respective portion of the stack beginning at the same initial location;
wherein said determining the initial location on the stack is performed only once.

### Claim 69

A computer-implemented method comprising:
including a plurality of test executive steps in a test executive sequence in response to user input;
configuring each respective step of the plurality of test executive steps to call a respective user-supplied code module in response to user input;
determining an initial location on a stack; and
executing the test executive sequence, wherein said executing comprises executing each respective step of the plurality of test executive steps after determining the initial location;
wherein each respective comprises:
storing a first portion of the stack ranging from the initial location to a current stack pointer location;
invoking execution of the respective user-supplied code module called by the respective step; and
checking the stored portion of the stack against contents of the stack after the respective user-supplied code module called by the respective step finishes executing to determine whether the first portion of the stack changed during execution of the respective user-supplied code module called by the respective step;
wherein for each respective step of the plurality of test executive steps, said storing the first portion of the stack comprises storing a respective portion of the stack beginning at the same initial location;
wherein said determining the initial location on the stack is performed only once.

### Claim 70

A computer-readable memory medium comprising program instructions executable to:
include a plurality of test executive steps in a test executive sequence in response to user input;
configure each of the test executive steps to call a user-supplied code module in response to user input;
execute the test executive sequence, wherein said executing comprises executing each of the test executive steps in the test executive sequence;
wherein for each test executive step in the test executive sequence, said executing the test executive step comprises:
initializing all unused space on a stack so that each bit in the unused space is set to an initial value; and
invoking execution of the user-supplied code module called by the test executive step after said initializing the unused space on the stack;
wherein the user-supplied code module called by the test executive step utilizes the stack for storage of one or more local variables used in the user-supplied code module;
wherein said initializing the unused space on the stack aids in determining whether the user-supplied code module called by the test executive step has an uninitialized local variable bug.

### Claim 71

A computer-readable memory medium comprising program instructions executable to:
include a plurality of test executive steps in a test executive sequence in response to user input;
configure each of the test executive steps to call a user-supplied code module in response to user input;
receive user input specifying an initial value for stack initialization; and
execute the test executive sequence, wherein said executing comprises executing each of the test executive steps in the test executive sequence;
wherein for each test executive step in the test executive sequence, said executing the test executive step comprises:
initializing at least a portion of unused space on a stack so that each bit in the portion is set to the specified initial value; and
invoking execution of the user-supplied code module called by the test executive step after said initializing the portion of unused space on the stack;
wherein the user-supplied code module called by the test executive step utilizes the stack for storage of one or more local variables used in the user-supplied code module;
wherein said initializing the portion of unused space on the stack aids in determining whether the user-supplied code module called by the test executive step has an uninitialized local variable bug.

### Claim 72

A computer-implemented method comprising:
including a plurality of test executive steps in a test executive sequence in response to user input;
configuring each of the test executive steps to call a user-supplied code module in response to user input;
receiving user input specifying an initial value for stack initialization; and
executing the test executive sequence, wherein said executing comprises executing each of the test executive steps in the test executive sequence;
wherein for each test executive step in the test executive sequence, said executing the test executive step comprises:
initializing at least a portion of unused space on a stack so that each bit in the portion is set to the specified initial value; and
invoking execution of the user-supplied code module called by the test executive step after said initializing the portion of unused space on the stack;
wherein the user-supplied code module called by the test executive step utilizes the stack for storage of one or more local variables used in the user-supplied code module;
wherein said initializing the portion of unused space on the stack aids in determining whether the user-supplied code module called by the test executive step has an uninitialized local variable bug.