You are here: NI Home > Support > Product Reference > Manuals > NI TestStand™ 4.1 Help

A B C D E F G H I K L M N O P R S T U V W

A
abort	To stop an execution without running any of the steps in the Cleanup step groups in the sequences on the call stack. When you abort an execution, no report generation occurs.
active window	The window that user input affects at a given moment. The title of an active window is highlighted.
ActiveX (Microsoft ActiveX)	Set of Microsoft technologies for reusable software components. Formerly called OLE.
ActiveX control	A reusable software component that adds functionality to any compatible ActiveX control container.
ActiveX reference property	A container of information that maintains a reference to an ActiveX object. TestStand maintains the value of the property as an IDispatch or IUnknown pointer.
ActiveX Automation server	Any executable code that makes itself available to other applications according to the ActiveX standard. ActiveX implies a client/server relationship in which the client requests objects from the server and asks the server to perform actions on the objects.
ActiveX/COM Adapter	See adapter.
adapter	If an adapter is specific to an application development environment (ADE), the adapter knows how to open the ADE, how to create source code for a new code module in the ADE, and how to display the source for an existing code module in the ADE. Some adapters support stepping into the source code of the ADE while executing the step from the TestStand Sequence Editor. See module adapter.
administrator	A user profile that usually contains all privileges for a test station.
ADO	ActiveX Data Object
Application Development Environment (ADE)	A programming environment such as LabVIEW, LabWindows/CVI, or Microsoft Visual Basic, in which you can create code modules and user interfaces.
Application Programming Interface (API)	A set of classes, methods, and properties you use to control a specific service, such as the TestStand Engine.
array property	A property that contains an array of single-valued properties of the same type.
ASCII	American Standard Code for Information Interchange
B
binding	See early binding and late binding.
block diagram	Pictorial description or representation of a program or algorithm. In LabVIEW, the block diagram that consists of executable icons called nodes and wires that carry data between the nodes. The block diagram is the source code for the VI. The block diagram resides in the block diagram window of the VI.
breakpoint	An interruption in the execution of a program.
built-in property	A property all steps or sequences contain, for example, the step run mode property. TestStand normally does not display these properties in the sequence editor, although it lets you modify some of them through dialog boxes.
built-in step type property	A property common to all steps of the same type. A built-in step type property is either a class step type property or an instance step type property.
button	A dialog box item that when selected executes a command associated with the dialog box.
C
C/C++ DLL Adapter	See adapter.
call stack	The chain of active sequences waiting for the nested subsequences to complete.
Call Stack pane	Displays the call stack for the execution thread currently selected in the Threads control.
callback	A sequence used to handle common tasks, such as serial number inquiry or report logging.
checkbox	An input control in a dialog box that allows you to toggle between two possible options.
class	Defines a list of methods and properties you can use with respect to the objects you create as instances of that class. A class is like a data type definition except that it applies to objects rather than variables.
class step type property	A built-in step property that exists only in the step type itself. TestStand uses these properties to define how the step type works for all step instances. Step instances do not contain their own copies of class properties.
client sequence file	A sequence file that contains the Main sequence that a process model invokes to test a UUT. Each client sequence file contains a sequence called MainSequence. The process model defines what is constant about the testing process, whereas the client sequence file defines the steps that are unique to the different types of tests you run.
clipboard	A temporary storage area the operating system uses to hold data you cut, copy, or delete from a work area.
cluster	A set of ordered, non-indexed data elements in LabVIEW of any data type, including numeric, Boolean, string, array, or cluster. The elements must be all controls or all indicators.
code module	A program module, such as a Windows Dynamic Link Library (.dll) or LabVIEW VI (.vi), that contains one or more functions that perform a specific test or other action.
code template	A source file that contains skeleton code. The skeleton code serves as a starting point for the development of code modules for steps that use a particular step type.
Configuration entry point	A sequence in the process model file that configures a feature of the process model. Configuration entry points usually save configuration information in a .ini file in the <TestStand Application Data>\cfg directory. By default, Configuration entry points are visible in the Configure menu. For example, the default process model contains the Configuration entry point Config Report Options. The Config Report Options entry point is visible as Report Options in the Configure menu.
connection string	A string version of the connection information required to open a session to a database.
connector	Part of a LabVIEW VI or function node that contains input and output terminals. Data values pass to and from the node through a connector.
container property	A property that contains no values and typically contains multiple subproperties. Container properties are analogous to structures in Microsoft Visual C/C++ and to clusters in LabVIEW.
context menu	Access context menus by right-clicking an object. Menu options in a context menu pertain specifically to the object you have selected.
control	An input and output device in a panel or window, in which you can enter data or make a setting.
control flow	The sequential order of instructions that determines execution order.
CPU	Central Processing Unit
CRLF	carriage return/linefeed
custom named data type	A data type you define and name. For example, you might create a Transmitter data type that contains subproperties such as number of channels, NumChannels, and power level, PowerLevel.
custom property	A property you define in a step type. Each step you create with the step type has its own copy of the custom property. TestStand uses the value you specify for the custom property in the step type as the initial value of the property in each new step you create. Normally, after you create a step, you can change the value of the property in the step.
custom sequence editor	See sequence editor
D
data link	Connection information for opening a data source, such as a database. A data link typically specifies the server on which the data resides, the database or file that contains the data, the user ID, and permissions to use when connecting to the data source.
data source	A provider of data, such as a database.
DBMS	Database Management Systems
developer	A user profile that usually contains all privileges associated with operating, debugging, and developing sequences and sequence files but excludes configuration of user privileges, report options, and database options.
dialog box	A user interface in which you specify additional information for the completion of a command.
DLL	Dynamic Link Library
E
early binding	Setting that causes the ActiveX/COM Adapter to use IDs to specify to automation servers what operations to perform on objects. See also late binding.
Edit substep	A substep the engine calls when a developer or user edits the step. You invoke the substep with the menu item listed in the context menu above Specify Module. The Edit substep launches a dialog box in which the sequence developer edits the values of custom step properties. For example, the Edit Limits item is visible in the context menu for Numeric Limit Test steps, and the Edit Pass/Fail Source item is listed in the context menu for Pass/Fail Test steps.
engine	A module or set of modules that provide an API for creating, editing, executing, and debugging sequences. A sequence editor or user interface uses the services of a test executive engine.
Engine callback	A sequence TestStand invokes at specific points during execution. Use Engine callbacks to tell TestStand to call certain sequences before and after the execution of individual steps, before and after interactive executions, after loading a sequence file, and before unloading a sequence file.
entry point	A sequence in the process model file TestStand displays as a menu item, such as Test UUTs, Single Pass, and Report Options.
error occurred flag	A Boolean flag, Step.Result.Error.Occurred, that indicates whether a run-time error occurred in a step.
execution	An object that contains information TestStand needs to run a sequence, its steps, and any of the sequences it calls. You can suspend, interactively debug, resume, terminate, or abort executions.
Execution entry point	A sequence in a process model that runs tests against a UUT. Execution entry points call the MainSequence callback in the client sequence file. The default process model contains two execution entry points: Test UUTs and Single Pass. By default, execution entry points are visible in the Execute menu. Execution entry points are visible in the menu only when the active window contains a sequence file that has a MainSequence callback.
Execution object	An object that contains all of the information TestStand needs to run a sequence, its steps, and any subsequences it calls. Typically, the TestStand Sequence Editor creates a new window for each execution.
execution pointer	A yellow pointer icon that shows the progress of execution by pointing to the currently executing step in the Steps pane.
Execution window	A window in the sequence editor or user interface that displays the steps an execution runs. When execution is suspended, the Execution window displays the next step to execute and provides single-stepping options. You can also view variables and properties in any active sequence context in the call stack.
expression	A formula that calculates a new value from the values of multiple variable or properties. In expressions, you can access all variables and properties in the sequence context that is active when TestStand evaluates the expression.
external viewer	An application other than TestStand that you use to view test reports and sequence file documentation. For example, you can use Microsoft Internet Explorer and Notepad as external viewers for HTML and ASCII-text files.
F
Front-End callback	A common sequence that the sequence editor and user interfaces call. Front-End callbacks allow multiple applications to share the same implementation for a specific operation. TestStand installs the sequence file FrontEndCallback.seq, which contains the Front-End callback sequence, LoginLogout.
Front-End callback sequence file	A sequence file that contains Front-End callbacks. TestStand installs the sequence file FrontEndCallback.seq, which contains the Front-End callback sequence, LoginLogout.
front panel	The interactive user interface of a LabVIEW VI. Front panel appearance imitates physical instruments, such as oscilloscopes and multimeters.
G
global variable	TestStand defines two types of global variables: sequence file global variables and station global variables. Sequence file global variables are accessible by any sequence or step in the sequence file. Station global variables are accessible by any sequence file loaded on the station. The values of station global variables are persistent across different executions and even across different invocations of TestStand.
GUI	See user interface.
H
hex	hexadecimal
Hidden Execution entry point	Execution entry points used by the main Execution entry points to initiate test socket executions. These entry points are never displayed.
highlight	The way in which input focus appears on a TestStand screen. To move the input focus onto an item.
HTBasic Adapter	See adapter.
I
IDispatch pointer	A pointer to an interface that exposes objects, methods, and properties to automation programming tools and other applications.
in-process	When executable code runs in the same process space as the client, in other words, an ActiveX server in a dynamic-link library (DLL).
instance step type property	A built-in step property that exists in each step instance. Each step you create with the step type has its own copy of the property. TestStand uses the value you specify for an instance property in the step type as the initial value of the property in each new step you create. Normally, after you create a step, you can change the values of its instance step type properties.
interactive mode	When you run steps by selecting one or more steps in a sequence and select Run Selected Steps or Loop Selected Steps from the context menu or menu bar. The selected steps in the sequence execute, regardless of any branching logic the sequence contains. The selected steps run in the order in which they appear in the sequence.
internal viewer	The functionality in the TestStand Sequence Editor you can use to view test reports. Access the internal viewer by selecting the Report tab in an Execution window.
IUnknown pointer	An interface, provided by all ActiveX objects, that enables you to control the lifetime and obtain other interfaces of an object.
K
kill	To stop a running, terminating, or aborting execution by terminating the thread of the execution without any cleanup of memory. This action can leave TestStand in an unreliable state.
L
LabVIEW	Laboratory Virtual Instrument Engineering Workbench. LabVIEW is a graphical programming language that uses icons instead of lines of text to create programs.
LabVIEW Adapter	See adapter.
LabWindows/CVI Adapter	See adapter.
late binding	Setting that causes the ActiveX/COM Adapter to use names to specify to a server what operations to perform on objects. See also early binding.
legacy	Characteristic of a version of TestStand prior to TestStand 3.5.
LF	linefeed.
list box	A control that displays a list of possible choices.
LLB	LabVIEW file that contains a collection of related VIs for a specific use.
local variable	A property of a sequence that holds a value or additional subproperties. Only a step within the sequence can directly access the property value.
lookup string	A string that defines a complete path from the object on which you call the method to the specific property you want to access.
M
Main sequence	The sequence that initiates the tests on a UUT. The process model invokes the Main sequence as part of the overall testing process. The process model defines what is constant about the testing process, whereas the Main sequences defines the steps that are unique to the different types of tests you run.
manager controls	Controls that call the TestStand API to perform tasks such as loading files, launching executions, and retrieving sequence information. Manager controls are visible at design time but invisible at run time.
MAX	Measurement & Automation Explorer
MB	megabytes of memory
menu bar	Horizontal bar that contains names of main menus.
method	Performs an operation or function on an object.
MFC	Microsoft Foundation Class Library
modal dialog box	A dialog box you must dismiss before you can operate other application windows.
Model callback	A mechanism that allows a sequence file to customize the default behavior of a sequence in the process model.
Model sequence file	A special type of sequence file that contains process model sequences. The sequences within the Model sequence file direct the high-level sequence flow of an execution when you test a UUT.
module adapter	A module adapter knows how to load and call a code module, how to pass parameters to a code module, and how to return values and status from a code module. See also adapter.
MRU	most recently used
multi-threaded apartment model (MTA)	A model in which an ActiveX object can be accessed from any thread at any time. The operating system does not synchronizes access to the object. You cannot create or display a window that contains an ActiveX control from a thread initialized using the multi-threaded model. ActiveX control require threads initialized using the single-threaded apartment model. By default, all execution threads are initialized using the multi-threaded apartment model.
N
named data type	A type of variable or property that you give a unique name. The data type usually contains multiple subproperties, thus creating an arbitrarily complex data structure. All variables or properties that use the data type have the same data structure, but the values they contain can differ.
nested	Called by another step or sequence. If a sequence calls a subsequence, the subsequence is nested in the invocation of the calling sequence.
nested interactive execution	When you run steps interactively from an Execution window for a normal execution suspended at a breakpoint. You can run steps only in the sequence and step group in which execution is suspended. The selected steps run within the context of the normal execution.
.NET Adapter	See adapter.
normal execution	When you start an execution in the sequence editor by selecting Run <Sequence Name>, where <Sequence Name> is the name of the sequence you are running, or one of the Process Model entry points from the Execute menu.
normal sequence file	Any sequence file containing sequences that test UUTs.
numeric property	A 64-bit, floating-point value in the IEEE 754 format.
O
object	A service an ActiveX server makes available to clients.
ODBC	Open Database Connectivity
OLE-DB	Object Linking and Embedding Database
operator	A user profile that usually contains all privileges associated with operating a test station but excludes debugging of sequence executions, editing of sequence files, and configuration of user privileges, station options, report options, and database options.
operator interface	A program that provides a graphical user interface (GUI) for executing sequences on a production station.
out-of-process	When executable code does not run in the same process space as the client, such as an ActiveX server in an executable.
P
parameters	A value passed to a program or subroutine.
parent sequence	The calling sequence of a subsequence.
pop-up menus	See context menu.
post actions	Actions TestStand takes depending on the pass/fail status of the step or a custom condition that the engine evaluates after executing a step. Post actions allow you to execute callbacks or jump to other steps after executing the step.
Post-Step substep	A substep the engine invokes after calling a code module. For example, a Post-Step substep might call a code module that compares the values the step module stored in step properties against limit values the Edit substep stored in other step properties.
Pre-Step substep	A substep the engine invokes before calling the code module. For example, a Pre-Step substep might call a code module that retrieves measurement configuration parameters and stores them into step properties for use by the step module.
preconditions	A set of conditions for a step that must be True for TestStand to execute the step during the normal flow of execution in a sequence.
process	A running application that consists of a private memory space and other operating-system resources visible to the process. A process also contains one or more threads that run in the context of the process.
process model	A sequence file you designate that performs a standard series of operations before and after a test executive executes the sequence that performs the tests. Common operations include identifying the UUT, notifying the operator of pass/fail status, generating a test report, and logging results.
property	A container of information, which stores and maintains a setting or attribute of an object. A property can be of type number, string, Boolean, container, ActiveX reference, a user-defined data type, or an array of these types. A property can contain a single value, an array of values of the same type, or no value at all. A property can also contain any number of subproperties. Only a container property has the ability to contain any number of subproperties. Each property has a name and a comment.
property-array property	A property containing a value that is an array of subproperties of a single type. In addition to the array of subproperties, property-array properties can contain any number of subproperties of other types.
R
RAM	random-access memory
record set	The retrieved records an SQL SELECT command or query returns.
reference count	Information each ActiveX object uses to keep track of the number of things that reference it. This allows the object to determine when to free the resources it uses.
reference property	See ActiveX reference property.
resource string	Text strings stored in an external file so you can alter the strings without directly altering the application.
ROM	read-only memory
root interactive execution	When you run selected steps from a Sequence File window in an independent execution. Root interactive executions do not invoke process models.
RTF	rich text format
run mode	The mode in which you execute a step, such as normal, skip, force pass, or force fail.
run-time error	An error condition that forces an execution to terminate. When the error occurs while running a sequence, TestStand jumps to the Cleanup step group, and the error propagates to any calling sequence up the call stack to the top-level sequence.
RunState	Contains properties that describe the state of execution in the sequence invocation.
S
s	seconds
SCC	source code control
sequence	Located within a sequence file, a sequence contains a series of steps you specify to execute in a particular order. When and if a step is executed can depend on the results of previous steps.
Sequence Adapter	See adapter.
sequence context	A TestStand object that contains references to all global variables and all local variables and step properties in active sequences. The contents of the sequence context changes depending on the currently executing sequence and step.
sequence editor	A program that provides a graphical user interface (GUI) for creating, editing, and debugging sequences.
sequence file	A file that contains the definition of one or more sequences.
sequence file global variables	Variables you can use to store data relevant to the entire sequence file. Each sequence and step in the sequence file can directly access these global variables.
Sequence File window	A separate window within the sequence editor in which a sequence file appears.
single-threaded apartment model (STA)	A model in which ActiveX objects execute within a single thread. The operating system synchronizes all access to the object when accessing the object from other threads. You must create objects that use the single-threaded apartment model, such as ActiveX controls, in threads initialized to use the single-threaded apartment model. TestStand executes Edit substeps in threads initialized to use the single-threaded apartment model to allow the substep to display windows that include ActiveX controls.
single-valued property	A property that contains a single value. TestStand has four types of these properties: number, string, Boolean, and object reference.
soft front panel (SFP)	A software graphical display for an instrument.
source code template	A set of source files that contain skeleton code, which serves as a starting point for the development of code modules for steps. TestStand uses the source code template when you click Create Code on the Source Code tab of the Specify Module dialog box for a step.
SQL NULL	An empty column in a row in a database table.
SQL Statement data	The retrieved record an SQL SELECT command or query returns.
standard named data type	A data type TestStand defines and names. You can add subproperties to the standard data types, but you cannot delete any of their built-in subproperties. The standard named data types are Path, Error, and CommonResults.
station	A complete TestStand test implementation that operators, developers, and administrators use to perform tests.
Station callback sequence file	A sequence file that contains the Station callback sequences. Station callbacks run before and after the engine executes each step in any normal or interactive execution.
station global variables	Variables that are persistent across different executions and even across different invocations of the sequence editor or user interfaces. The TestStand Engine maintains the value of station global variables in a file on the run-time computer.
station model	A process model you select to use for all sequence files for a station. The TestStand installation program establishes SequentialModel.seq as the default station model file. Use the Station Options dialog box to select a different station model.
step	An element you can insert into a sequence that performs an action, such as calling a code module to perform a specific test. Typically, a sequence contains a series of steps that define the test and execution flow.
step group	A set of steps in a sequence. A sequence contains the following groups of steps: Setup, Main, and Cleanup. When TestStand executes a sequence, the steps in the Setup step group execute first, the steps in the Main step group execute next, and the steps in the Cleanup step group execute last.
step property	A property of a step.
step result	A container property that contains a copy of the subproperties from the Result property of a step and additional execution information such as the name of the step and its position in the sequence. TestStand automatically creates a step result as each step executes and places the step result into a result list TestStand uses to generate its reports.
step status	A string value that indicates the status of a step in an execution. Every step has a Result.Status property. Although TestStand imposes no restrictions on the values to which the step or its code module can set the status property, TestStand and the built-in step types use and recognize a predefined set of values.
step type	A component that defines a set of custom step properties and standard behavior for each step of that type. All steps of the same type have the same properties, but the values of the properties can differ. Step types define their standard behaviors using substeps.
step-type-specific dialog box	A dialog box step types display when you invoke their Edit substep. The dialog box lets you modify step properties specific to the step type. You invoke the dialog box with the menu item listed in the context menu above Specify Module. For example, the Edit Limits item is visible in the context menu for Numeric Limit Test steps, and the Edit Pass/Fail Source item is visible in the context menu for Pass/Fail Test steps.
subsequence	A sequence that another sequence calls. You specify a subsequence call as a step in the calling sequence.
substep module	The code module that an Edit, Pre-Step, or Post-Step substep calls.
substeps	Actions a step type performs for a step other than calling the step module. You define a substep by selecting an adapter and specifying a module call. TestStand defines three different types of substeps: Edit substep, Pre-Step substep, and Post-Step substep.
T
technician	A user profile that usually contains all privileges associated with operating and debugging sequences and sequences files but excludes editing of sequence files and configuration of user privileges, station options, report options, and database options.
template	See code template.
terminal	Object or region on a LabVIEW VI node through which data values pass.
terminate	To stop an execution by halting the normal execution flow and running all the Cleanup step groups in the sequences on the call stack.
test executive engine	See engine.
TestStand Engine	See engine.
TestStand UI Controls API	Provides a set of common commands you can add to the application. Connect these commands to a TestStand button or application menu item to automatically execute the command.
ThisContext	Holds a reference to the current sequence context. You usually use this property to pass the entire sequence context as an argument to a subsequence or a code module. See also sequence context.
thread	A subprocess that is part of a process or application. A thread can execute any part of the code of an application and other threads within a process execute concurrently. All threads under a process share the memory space and other operating-system resources of their respective processes.
U
Unit Under Test (UUT)	The device or component you are testing.
user interface	A program that provides a graphical user interface (GUI) for executing sequences or for creating, editing, and debugging sequences. See also operator interface and sequence editor.
User Manager	The component of the TestStand Engine that maintains a list of users, their login names and passwords, and their privileges. You can access the user manager from the User Manager window in the sequence editor.
V
variables	A property you can freely create in a certain context. You can have variables that are global to a sequence file or local to a particular sequence. You can also have station global variables.
variables window	A window that shows the values of all the currently active variables or properties.
variant	Data type that can hold any defined type of data.
VI	Virtual Instrument
VI library	See LLB.
visible controls	Controls that connect to manager controls to automatically display information or to enable the user to select items to view.
W
Watch Expression pane	A pane that shows the values of user-selectable variables and expressions that are currently active.
window	A working area that supports specific tasks related to developing and executing programs.
wire	Data path between nodes in a LabVIEW VI.