Glossary

TestStand 2019 Help

Edition Date: May 2019

Part Number: 370052AA-01

»View Product Info
Download Help (Windows Only)

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 version of LabVIEW

Version of the LabVIEW Development System you most recently launched.

Note: Although the LabVIEW adapter configuration dialog will display the most recently opened version of LabVIEW Development System as the active version of LabVIEW, if multiple versions of LabVIEW are open at the same time on the system, the first version of LabVIEW launched will be used by the LabVIEW adapter and related tools to create or edit or debug VIs. This behavior is the consequence of how Out-of-Process ActiveX Servers are designed and implemented.

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 Object Linking and Embedding (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 module adapter.
adapter See module adapter.
additional result A value TestStand adds to the result list of a step when the step executes. An additional result can be a module parameter or a custom additional result in which you specify the name and value of the result. You can configure TestStand to automatically include additional results in reports and log additional results to a database.
administrator A user profile that usually contains all privileges for a test station.
ADO ActiveX Data Object
analysis Process the TestStand Deployment Utility follows to determine which files to include in a deployment.
analysis module A function in a DLL or a VI that the TestStand Sequence Analyzer invokes to implement analyzer rules. Analysis modules perform the checks the rules specify and generate messages that the sequence analyzer stores in the analyzer project.
analysis module specifications Specify the analysis modules to call. Analysis module specifications also specify when the sequence analyzer calls the analysis module, the types of objects to which the analysis modules apply, and whether to call the analysis module when transitioning from one type of object to another.
analyzer See TestStand Sequence Analyzer.
Application Development Environment (ADE) A programming environment, such as LabVIEW, LabWindows/CVI, or Microsoft Visual Studio, in which you 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. TestStand supports number, string, Boolean, and object reference array properties.
ASCII American Standard Code for Information Interchange
ATML Automatic Test Markup Language
attribute Attributes store data associated with a PropertyObject. Every PropertyObject has an Attributes container object under which you can create attribute variables. Use container subproperties as attribute namespaces.

B

binding See early binding and late binding.
bitness The number of bits in pointers on a given architecture. For example, the x86 architecture is 32-bit, and the IA64 and x64 architectures are 64-bit.
bitness-conditional Describes code or an operation that behaves differently depending on the architecture.
bitness independent Simultaneously supports 32-bit applications and 64-bit applications.
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.
build Process the TestStand Deployment Utility follows to create a deployable image of a TestStand-based test system and, optionally, an installer that contains the deployable image.
build specification Part of a LabVIEW project that contains all the settings for building a source distribution, executable file, DLL, or packed project library. The settings for a build specification include the files to include, destination directories, and settings for VIs.
built-in property A property all steps or sequences contain, such as the step run mode property. TestStand normally does not display these properties in the sequence editor, although you can modify some properties 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 DLL A DLL built with a C compiler or with a C++ compiler that specifies C-style linkage using the extern "C" directive so that it does not use C++ name decoration.
C/C++ DLL Adapter See module 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. The default TestStand process models require that 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.
CLR Common Language Runtime. Run-time environment the Microsoft .NET Framework provides.
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 Microsoft 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, which serves as a starting point for the development of code modules for steps that use a particular step type.
component Piece of an application to install or remove, tracked by a component ID. Examples of components include one or more files, registry keys, shortcuts, and so on.
component ID GUID that uniquely identifies an installer component.
Configuration entry point A sequence in the process model file that configures a feature of the process model and usually saves configuration information in a .ini file in the <TestStand Application Data>\cfg directory. By default, the Configure menu lists the Configuration entry points. For example, the default process model contains the Configuration entry point Config Report Options, which appears as Configure 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 but contains multiple subproperties. Container properties are analogous to clusters in LabVIEW and structures in C/C++.
context (of LabVIEW project) Memory space in which a LabVIEW project loads VIs or project libraries. VIs in the context of a LabVIEW project can use items the project defines, such as DAQ channels or shared variables. The names of VIs in the context of one LabVIEW project do not collide with the names of VIs in other project contexts.
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
CPU affinity On a multi-core system, each process or thread is allocated to a dedicated CPU. See also multi-core processor and SMP system.
CRLF carriage return/linefeed
cross bitness An operation or action that involves 32-bit elements and 64-bit elements.
cross-linking Scenario in which LabVIEW references a VI different from the VI you intend because another VI exists in memory with the same filename or because LabVIEW found another VI on disk with the same filename.
custom commands Commands that execute after the installer you built with the deployment utility completes, such as a command to launch a third-party hardware driver installer.
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
dependencies Files or installers another file or installer requires to execute without errors.
deploy Process of collecting the files, drivers, and run-time engines that comprise a test system and transferring those files to another computer.
deployable image File hierarchy that includes all the files and dependencies you specify on the System Source tab of the deployment utility. The deployable image can contain sequence files, code modules and supporting files, process model and supporting files, user interface applications, configuration files, and step types and supporting files the TestStand system uses.
deployment Collection of files and/or installers that when run or copied creates a TestStand-based test system on a test station computer. See also TestStand system.
destination Target directory for the deployment.
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.
development computer Computer that contains all the software the TestStand-based test system uses, such as the sequence files and code modules, driver software, and development tools. For example, a development computer could have NI-DAQmx, the TestStand Sequence Editor and Engine with a TestStand Development System License, and the LabVIEW Professional Development System installed. You create deployments to transfer all or part of a TestStand system from a development computer to other computers. You can also use a test station computer that includes a development version of LabVIEW or LabWindows/CVI, the TestStand Engine, a custom user interface, and a TestStand Custom Sequence Editor License to modify and redeploy test sequences.
dialog box A user interface in which you specify additional information for the completion of a command.
distribution Collection of one or more products and the support files needed to install and execute those products.
DLL Dynamic Link Library
double A 64-bit double-precision, floating-point value.
driver Software that hardware components require. For example, National Instruments GPIB devices require the NI-488.2 driver software.
dynamically referenced files Files you specify using an expression, which might evaluate to different values depending on the values of other variables during execution because TestStand evaluates expression values only at run time after specifying the values of dependent variables. The TestStand Deployment Utility cannot automatically locate these types of files, so you must manually add dynamically referenced files to the deployment to ensure that the test system executes correctly on the test station computer. For example, a Sequence Call step can specify the sequence file path using an expression that contains the UUT model number to execute different test sequences for different models of the UUT.

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 the Specify Module option. The Edit substep launches a dialog box in which you can edit the values of custom step properties. For example, the Edit Limits item appears in the context menu for Numeric Limit Test steps, and the Edit Pass/Fail Source item appears in the context menu for Pass/Fail Test steps.
edit time The time during which you create or edit a sequence or code module using an editor or ADE. See also run time.
engine A module or set of modules that provide an application programming interface (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 make TestStand 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 See Execution object.
Execution entry point A sequence in a process model file that invokes a test sequence file, typically by calling the MainSequence callback in the client sequence file. The default process model contains Test UUTs and Single Pass Execution entry points. By default, the Execute menu lists Execution entry points only when the active window contains a sequence file that uses the process model.
Execution object An object that contains all the information TestStand needs to run a sequence and the subsequences it calls. You can suspend, interactively debug, resume, terminate, or abort executions. 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 active in the sequence context when TestStand evaluates the expression.
external source files or cabinet files (.cab) Files that store compressed files for an installer.
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 multiple user interface applications can call to share the same implementation for a specific operation. The FrontEndCallback.seq file TestStand installs in the <TestStand>\Components\Callbacks\FrontEnd directory contains one LoginLogout Front-End callback sequence. The TestStand Sequence Editor and default user interfaces call the LoginLogout callback.
front panel The interactive user interface of a LabVIEW VI. Front panel appearance imitates physical instruments, such as oscilloscopes and multimeters.

G

GAC Global Assembly Cache. A computerwide code cache that stores .NET assemblies. Refer to Microsoft documentation for more information.
global variable TestStand defines sequence file global variables and station global variables. Any sequence or step in a sequence file can access sequence file global variables. Any sequence file loaded on a station can access station global variables. The values of station global variables persist across different executions and even across different invocations of TestStand.
globally unique identifier (GUID) String that contains a unique 128-bit reference number. An example of a GUID is {C070444F-FF1F-4A95-9236-477B83FD7A3D}.
GUI See user interface.

H

handle An abstract reference to a resource. Handles are often pointer sized.
hex hexadecimal
hidden Execution entry point Execution entry points the main Execution entry points use to initiate test socket executions. These entry points are never displayed.
HTBasic Adapter See module adapter.

I

IDispatch pointer A pointer to an interface that exposes objects, methods, and properties to automation programming tools and other applications.
image directory Root directory that contains the deployable image the TestStand Deployment Utility creates during a build.
implicitly referenced files Files that are not code module dependencies or referenced explicitly but that are required for the test system to execute correctly. The TestStand Deployment Utility cannot automatically locate these types of files, so you must manually add implicitly referenced files to the deployment to ensure that the test system executes correctly on the test station computer. For example, a test system can include an external calibration file in the same directory as the user interface, but no TestStand steps reference this file.
inplaceness Technique LabVIEW uses to identify data allocations it can reuse during execution to improve performance and to save memory by preventing unnecessary data copies. When you change the inplaceness of a control or indicator in a subVI, you must recompile all VIs that call the subVI.
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).
installer version Three numbers that range from 0.0.0 to 255.255.65535. Specify the installer version so you can remove files from a previous version of the installer and to prevent installing files over later versions of the files.
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 source files Cabinet files embedded in a Microsoft Windows Installer database file.
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 Adapter See module adapter.
LabVIEW project A collection of LabVIEW files and files not specific to LabVIEW that you can use to create build specifications and deploy or download files to targets.
LabVIEW packed project library A packed project library exports multiple LabVIEW-related files into a single file (.lvlibp) that calling VIs and applications can invoke.
LabVIEW project library A collection of VIs, type definitions, shared variables, palette menu files, and other files, including other project libraries.
LabWindows/CVI Adapter See module 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 earlier than 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. Local variables store data relevant to only the current sequence. Only steps within the sequence that defines the local variable can access these variables.
logs Files the TestStand Deployment Utility uses to record its operations.
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 defines what is constant about the testing process, and the Main sequences define the unique steps for the different types of tests to run. The TestStand Sequence Editor automatically inserts an empty sequence named MainSequence in new files. The default TestStand process models invoke MainSequence in client sequence files as part of the overall testing process when executing the Test UUTs and Single Pass Execution entry points.
manager controls Controls that call the TestStand API to perform tasks such as loading files, launching executions, and retrieving sequence and execution information. Manager controls also notify you when application events occur, such as when a user logs in, an execution reaches a breakpoint, or a user changes the file or sequence they are viewing. 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.
merge module file (.msm) File that contains the database tables a Microsoft Windows Installer database file requires to install a component. You cannot use merge modules to install files directly. You must incorporate the files into a Microsoft Windows Installer database file.
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 client sequence file to customize the behavior of a process model for each client sequence file that uses it.
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 The TestStand Engine uses module adapters to invoke code modules TestStand sequences call. Module adapters load and call code modules, pass parameters to code modules, and return values and status from code modules. If an adapter is specific to an application development environment (ADE), the adapter can open the ADE, create source code for a new code module in the ADE, and 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 a TestStand application.
MRU most recently used
MSI Engine Program that performs installations using Microsoft Windows Installer database files.
multi-core processor A processing system that consists of two or more independent cores. See also SMP system.
multi-threaded apartment (MTA) model 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 MTA model. ActiveX controls require threads initialized using the single-threaded apartment (STA) model. By default, all execution threads are initialized using the MTA model. See also single-threaded apartment (STA) 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 Running 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 module adapter.
non-essential project library VIs VIs that are not code module VIs or code module subVIs but are part of a project library that includes code module VIs or code module subVIs.
normal execution Starting 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 that contains 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.
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

packed project library See LabVIEW packed project library.
parameters A value passed to a program or subroutine.
parent sequence The calling sequence of a subsequence.
part Smallest unit a National Instruments installer needs to track by version or the largest indivisible group of features.
pointer-sized 32-bits (4 bytes) in a 32-bit application; 64-bits (8 bytes) in a 64-bit application.
pop-up menu See context menu.
post actions Operations TestStand takes depending on the pass/fail status of the step or any custom condition. Operations include executing the next step, executing a particular step or sequence, terminating the execution, or suspending in debug mode.
Post-Step substep A substep TestStand calls after calling a step code module. For example, a Post-Step substep might call a substep 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 TestStand calls before calling the step code module. For example, a Pre-Step substep might call a substep code module that retrieves measurement configuration parameters and stores those parameters in step properties the step code module uses.
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 that define the testing process include identifying the UUT, notifying the operator of pass/fail status, logging results, and generating a report.
product Set of features grouped into a sellable unit. A product consists of one or more parts.
product cache Directory in which National Instruments stores copies of the National Instruments parts the National Instruments installer architecture uses to build installers so you do not have to manually load the installation media for different products during each build.
property A container of information that stores and maintains a setting or attribute of an object. A property can be a number, string, Boolean, container, or ActiveX reference type, 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 that contains 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.
redistribution Including an installed product in the installer you build. For example, you can use the TestStand Deployment Utility to build an installer that can redistribute the TestStand Engine.
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 Running steps interactively from a Sequence File window to create a new execution. Root interactive executions do not invoke process models.
root sequence files Sequence files that are not dependencies of any other sequence files. For example, sequence files you load to test a UUT are root sequence files.
RTF rich text format
rule Defines a single task to perform during analysis, such as ensuring that the prototype of each code module is up to date or ensuring that each expression specified evaluates to the correct type and does not include any syntax errors.
run mode The mode in which you execute a step, such as normal, skip, force pass, or force fail.
run time The time during which you execute a sequence. See also edit time.
run-time error An error condition that prevents a sequence from executing. 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
search paths A list of directories, in order of precedence, that module adapters use to resolve relative paths of code modules for steps and substeps in step types.
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 module adapter.
sequence context An object in the TestStand API that represents the execution state of a sequence. For each active sequence, TestStand maintains a sequence context you can use to access all the objects, variables, and properties that relate to the execution of the sequence. The contents of the sequence context vary depending on the currently executing sequence and step, the location of the active sequence in the call stack, and the identity of the execution in which the active sequence resides.
sequence editor A program that provides a graphical user interface (GUI) for creating, editing, executing, and debugging sequences.
sequence file A file that contains the definition of one or more sequences.
sequence file global variables Variables that 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 TestStand Sequence Editor in which you can edit sequences, steps, and variables.
shared variable LabVIEW variable you can use to read or write live data among several VIs in a project or across a network.
single-threaded apartment (STA) model 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 STA model, such as ActiveX controls, in threads initialized to use the STA model. TestStand executes Edit substeps in threads initialized to use the STA model to allow the substep to display windows that include ActiveX controls. See also multi-threaded apartment (MTA) model.
single-valued property A property that contains a single value. TestStand supports number, string, Boolean, and object reference single-valued properties.
size_t A pointer-sized unsigned integer used in the C and C++ programming languages.
SMP system Symmetric multiprocessing system, which is a computer that contains multiple CPUs, where a CPU can be a single core on a multi-core processor or a single-core processor on a multiprocessor computer. Windows and other modern operating systems can take advantage of SMP systems to achieve increased performance. SMP systems achieve better performance by executing multiple threads on multiple CPUs concurrently. Generally, when an application is implemented with multiple threads, the operating system attempts to schedule each thread on a separate CPU when possible. Under some circumstances, this automatic scheduling can have a negative impact on application performance.
soft front panel (SFP) A software graphical display for an instrument.
source code control (SCC) system/revision control system (RCS) Software that development teams commonly use to manage changes to a set of computer files. You can use a source code control system or revision control system as an alternative deployment mechanism to distribute files instead of using an installer.
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.
source distribution Collection of one or more LabVIEW VIs and dependencies you create to send to another developer. You can use LabVIEW projects to create a build specification that generates a source distribution.
source files Files you specify to include in a deployment by using the From TestStand Workspace File, From Directory, or From TestStand Public Directories options in the Deploy Files section on the System Source tab of the TestStand Deployment Utility.
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, such as Error, CommonResults, Path, and Expression. The only standard named data types you can modify are the CommonResults and the NI_UserCustomPrivileges types. With the CommonResults standard data type, you can add subproperties to the standard data types, but you cannot delete any of the built-in subproperties.
statically referenced files Files that are code module dependencies or referenced explicitly. These files resolve to a single file on disk and do not depend on the values of other variables. The TestStand Deployment Utility automatically locates these types of files, so you do not need to manually add statically referenced files to the deployment.
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, which run before and after the engine executes each step in any normal or interactive execution.
station global variables Variables that persist 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 computer on which TestStand is running.
station model A process model you select to use for all sequence files for a station. The SequentialModel.seq file is the default station model file. Use the Station Model option on the Model tab of the Station Options dialog box to select a different station model.
step An individual element of a test sequence that can call code modules or perform other operations.
step group A set of steps in a sequence. A sequence contains Setup, Main, and Cleanup step groups. TestStand executes the steps in the Setup step group first, the Main step group second, and the Cleanup step group 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 result of the step 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 built-in step properties and any number of custom step properties. Although all steps of the same type have the same properties, the values of those properties can differ. The step type specifies the initial values of all the step properties.
subsequence A sequence another sequence calls as a step.
substep module The code module 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 Edit, Pre-Step, and Post-Step substeps.
subVI VI used on the block diagram of another VI, such as a code module or other subVI, but not called directly from a TestStand step or included as a file in a TestStand workspace. Comparable to a subroutine.
support files Files that are not executable code but that code modules require to execute correctly, such as .ini files, data files, graphics, icons, instructions, or other text files.

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 Description (TD) A standard the IEEE Standards Coordinating Committee 20 (SCC20) developed to identify and document test descriptions that can be used during the test of a UUT. A TD file is a document that validates against the ATML TD schema. The TestStand ATML Toolkit provides support for translating a TD file into a TestStand sequence file and a set of LabVIEW or LabWindows/CVI code modules. See also ATML, TPS, and Unit Under Test (UUT).
test executive engine See engine.
test program set (TPS) The complete group of sequence files and code modules that define a test for a UUT. See also TD and Unit Under Test (UUT).
Test Results and Session Information ATML schema that provides the definition for the data collected when you execute a test or tests of a UUT using test procedures in an automated test environment, including the measured values, pass/fail results, and accompanying data, such as test operator, station information, environmental conditions, and so on. See also ATML and Unit Under Test (UUT).
test station computer Computer that contains the software and hardware required to execute a deployed test system. You typically do not use test station computers to create new tests because these computers usually have installed only a user interface, the TestStand Engine, a TestStand Base Deployment Engine License, and the required run-time engines to execute code modules correctly. You can install a development version of LabVIEW or LabWindows/CVI, the TestStand Engine, a custom user interface, and a TestStand Custom Sequence Editor License on a test station computer to modify and redeploy test sequences.
TestStand deployment file (.tsd) Stores all the information required to build a deployment in the TestStand Deployment Utility.
TestStand Engine See engine.
TestStand options file (.tso) Contains information about window positions, source code control configuration, and the expansion state of the Workspace pane.
TestStand project file (.tpj) Contains a hierarchy of directories and files.
TestStand Sequence Analyzer Use the TestStand Sequence Analyzer in the TestStand Sequence Editor or the stand-alone sequence analyzer application to find errors, enforce custom development guidelines you establish, and gather statistics about workspace files, sequence files, directories, type palette files, station globals files, template files, and users files during development or before deployment.
TestStand system The complete TestStand-based test solution you create from multiple TestStand components, including the TestStand Engine and support files, LabVIEW and LabWindows/CVI Run-Time Engines, process models, step types, configuration files, user interface applications, workspace files, sequence files, code modules, and hardware drivers.
TestStand UI Controls API A set of ActiveX controls that implement common functionality for applications to display, execute, edit, save, and debug test sequences. Connect these commands to a TestStand button or application menu item to automatically execute the command.
TestStand workspace file (.tsw) Contains one or more TestStand project files and can serve as the source file you use to create a deployment.
ThisContext Holds a reference to the current sequence context. Usually, you use this property to pass the entire sequence context as an argument to a subsequence or a step 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. See also process.
transfer Process of using a transport method to move test system files from one computer to another, typically from a development computer to a test station computer.
transform Set of changes you apply to a Microsoft Windows Installer database file before installation. For example, you can replace text the installer displays with localized text strings.
transport method Common mechanism used to transfer a test system from the development computer to another computer, such as moving a CD from one computer to another, copying files over a local area network, or copying files over the Internet.

U

Unit Under Test (UUT) The device or component to test.
upgrade code GUID that uniquely identifies a related set of Microsoft Windows Installers. You can use only one installer with a specific upgrade code on a computer at a given time. An installer that has the same upgrade code but a later version updates an older installation.
user interface A program that provides a graphical user interface (GUI) for executing sequences on a production station. A sequence editor and user interface can be separate applications or different aspects of the same application. See also sequence editor.
User Manager The component of the TestStand Engine that maintains a list of users, user names, user passwords, user privileges, groups, group privileges, and members of groups. TestStand can limit the functionality of the TestStand Sequence Editor and User Interfaces depending on the privilege settings you define in the user manager for the current user and the groups to which the user belongs.

V

variables A property you can freely create in a certain context. Variables can apply globally to a sequence file or locally to a particular sequence. You can also use station global variables with values that persist across different executions and across different invocations of the sequence editor or user interfaces.
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 allow users to select items to view. See also manager controls.

W

W3C World Wide Web Consortium
watch expression An expression you enter to monitor values of variables and properties as you trace or single-step through a sequence.
Watch View pane A pane that shows the values of watch expressions you enter.
window A working area that supports specific tasks related to developing and executing programs.
Windows Installer database file (.msi) File that contains database tables that define how the MSI Engine performs an installation.
wire Data path between nodes in a LabVIEW VI.

X

XPath XML Path Language, a query language the W3C developed for selecting nodes from an XML document and computing values from the content of an XML document. XPath is a subset of XQuery. See also W3C and XQuery.
XQuery A language the W3C developed to query XML data using XPath expression syntax. See Also XPath.
XSD XML Schema Document, a document written in the XML Schema language and that typically contains the xsd XML namespace prefix and has a .xsd filename extension.

WAS THIS ARTICLE HELPFUL?

Not Helpful