|
OpenTAP 9.35
API Reference
|
| ►NOpenTap | |
| ►NAuthentication | |
| CAuthenticationSettings | This class stores information about the logged in client |
| CTokenInfo | Represents a set of Oauth2/OpenID Connect tokens (access and possibly refresh token) that grants access to a given domain |
| ►NCli | Command Line Interface handling |
| CCliActionExecutor | Helper used to execute ICliActions |
| CCommandLineArgumentAttribute | When used on a property inside a ICliAction, this attribute indicates a command line arugment or switch |
| CExitCodeException | Thrown from OpenTap.Cli.ICliAction.Execute to set a specific exit code |
| CICliAction | Plugin type that defines a sub command for the OpenTAP CLI (tap.exe). Deriving from this, and annotating the class and any public properties with CommandLineArgumentAttribute and UnnamedCommandLineArgument attributes will allow it to be called from the OpenTAP CLI |
| CRunCliAction | Test plan run CLI action. Execute a test plan with 'tap.exe run test.TapPlan' |
| CUnnamedCommandLineArgument | Used on properties of a ICliAction to define an unnamed arguments on the CLI. These can be ordered to handle cases where some values are required and others can occur multiple times. The property type will indicate how many will be consumed. The type can be either string or string[]. In case of string[] all the remaining arguments will be assigned to this property |
| ►NDiagnostic | Contains diagnostic functionality like the OpenTAP logging system |
| CAccurateStamper | Default timestamper |
| CBinaryLog | A simple log listener that writes events to a binary file |
| CEvent | A structure containing all information about an event |
| CILog | Log source interface. Instances of this are always created by a corresponding ILogContext |
| CILogContext | A log context that can have multiple log sources and LogResultListener |
| CILogContext2 | Extended ILogContext interface |
| CILogListener | Interface a log listener must implement |
| CILogTimestampProvider | The timestamping mechanism used by ILogContext |
| CLogFactory | Factory class that can create implementations of the ILogContext interface |
| CLogFile | A simple log listener that writes events to a binary file |
| ►NPackage | Package name space |
| ►NSetAsmInfo | |
| CGacResolver | Resolver for assemblies in the GAC |
| CActionStep | Represents an action/step that can be executed during or after installation of a package |
| CArchitectureHelper | Helper methods used to determine CpuArchitecture and compatibility between them |
| CCacheAction | Hidden CLI sub command tap package cache that allows clearing the package cache |
| CCustomPackageActionArgs | Argument for ICustomPackageAction.Execute |
| CDependencyAnalyzer | Algorithm for calculate nth degree dependency issues |
| CDependencyIssue | Model object for a dependency issue |
| CDependencyResolver | Finds dependencies for specified packages in Package Repositories |
| CEULA | End User License Agreement |
| CFileExists | This package validation checks if a file exists |
| CFilePackageDefSource | The package definition is sourced from a .TapPackage file |
| CFilePackageRepository | Implements a IPackageRepository that queries a local directory for OpenTAP packages |
| CFileRepositoryPackageDefSource | The package definition is sourced from a local or remote file system storage. This can be a local folder or a remove shared file system drive |
| CGitVersionAction | CLI sub command tap sdk gitversion that can calculate a version number based on the git history and a .gitversion file |
| CHttpPackageRepository | Implements a IPackageRepository that queries a server for OpenTAP packages via http/https |
| CHttpRepositoryPackageDefSource | The package definition is sourced from a remote package repository server |
| CICustomPackageAction | Custom actions for ICustomPackageData inside File element in package.xml files, to be executed at predefined stages (PackageActionStage) |
| CICustomPackageData | Custom data elements in package.xml inside File elements, to be used for custom actions by ICustomPackageAction at predefined stages (PackageActionStage) |
| CIFilePackageDefSource | The package definition is sourced from a .TapPackage file |
| CImageIdentifier | Image that specifies a list of PackageSpecifier to install and a list of repositories to get the packages from |
| CImageResolveException | Exception thrown when ImageSpecifier.Resolve fails |
| CImageResolver | Resolves packages dependencies for an image.This should be able to resolve any set of package dependencies, but it may take a long time in some edge cases. In most cases however it seems to settle quite quickly |
| CImageSpecifier | An ImageSpecifier defines an OpenTAP installation. The specifier can be resolved to an ImageIdentifier which can be deployed to an actual OpenTAP installation |
| CInstallation | Represents an OpenTAP installation in a specific directory |
| CInstalledPackageDefSource | The package definition is sourced from an OpenTAP installation |
| CIPackageDefSource | Interface for determining where a package definition is sourced |
| CIPackageIdentifier | Uniquely identifies a package in the OpenTAP package system |
| CIPackageIdentifierExtensions | Extensions to IPackageIdentifier |
| CIPackageRepository | A client interface for a package repository. Implementations include FilePackageRepository and HttpPackageRepository |
| CIRepositoryPackageDefSource | The package definition is sourced from a package repository |
| CIsolatedPackageAction | Base class for ICliActions related to installing or removing packages. Useful for making changes to the installation. Previously this made a copy of the installation to a temp dir before executing |
| CIVersionConverter | This interface specifies how to convert from a version string to a SemanticVersion |
| CIVersionTryConverter | Plugin type like IVersionConverter, that can TryConvert, which does will not throw an exception |
| CLockingPackageAction | Base class for ICliActions that use a mutex to lock the Target directory for the duration of the command |
| CMissingPackageData | Placeholder object that represents an unrecognized XML element under the File element in a package definition xml file (package.xml) |
| CPackageAction | Indicates a well defined action to be performed on a package. A number of common actions are PackageInstallAction, PackageUninstallAction, and PackageDownloadAction. Deriving from this, and annotating the class and any public properties with CommandLineArgumentAttribute and UnnamedCommandLineArgument attributes will allow it to be called from the OpenTAP.Package CLI |
| CPackageCreateAction | CLI sub command tap sdk create that can create a *.TapPackage from a definition in a package.xml file |
| CPackageDef | Definition of a package file. Contains basic structural information relating to packages |
| CPackageDependency | Represents a dependency on a package |
| CPackageDependencyGraph | This graph describes every version of every package in a memory-efficient way. Each unique name version and version specifier is represented by one value, connections between them are some dictionaries. The graph can be merged from multiple different sources - both file repositories and http repositories, but the source of each becomes lost when building the graph. When the source is needed a new lookup will be needed from a different place, this code is not really concerned with that |
| CPackageDependencyQuery | This class takes care of making the right package query queries to the repository server |
| CPackageFile | Information about a file in a package |
| CPackageFileExtensions | Extension methods to help manage ICustomPackageData on PackageFile objects |
| CPackageIconData | Used for adding icons to a TapPackage. Add this element to the package.xml inside File (PackageFile) |
| CPackageIdentifier | Uniquely identifies a package in the OpenTAP package system |
| CPackageManagerSettings | Settings class containing plugin package manager settings |
| CPackageSpecifier | Holds search parameters that specifies a range of packages in the OpenTAP package system |
| CPackageVersion | Represents a version of a package. Objects of this type is returned byIPackageRepository.GetPackageVersions |
| CPluginFile | Represents a plugin (type that derives from ITapPlugin) in a payload file of an OpenTAP package |
| CRepositorySettingEntry | Structure used by PackageRepositories setting |
| CUseVersionData | Defines the UseVersion XML element that can be used as a child element to the File element in package.xml to indicate that a package should take its version from the AssemblyInfo in that file |
| CValidation | Base class for package validation objects |
| CVerifyPackageHashes | CLI Action to verify the installed packages by checking their hashes |
| CVersionSpecifier | Specifies parts of a semantic version. This is used in PackageSpecifier to represent the part of a SemanticVersion to search for. E.g. the VersionSpecifier "9.0" may match the semantic version "9.0.4+abcdef" and also "9.1.x" if MatchBehavior is set to "Compatible" |
| CXmlPackageDefSource | The package definition is loaded from an package XML file |
| ►NPlugins | Plugin name space |
| CDefaultValueSerializer | Serializer implementation for default value attributes |
| CEventsSerializerPlugin | Serializer implementation for default value attributes |
| ►CExternalParameterSerializer | Serializer implementation for parameters |
| CExternalParamData | Structure for holding data about TestPlan.ExternalParameters |
| CIConstructingSerializer | Implemented by serializer plugins that creates and populates members of an object |
| CInputOutputRelationSerializer | Serializes input/output relations. It does so by adding a collection of inputs to the step XML while serializing. This is done because some of the properties might be read-only or XML ignore and in these cases we might still want to serialize the relation ship between them, even though the values are not themselves serialized |
| CTestStepSerializer | Serializer implementation for TestStep |
| ►NTranslation | |
| CIStringLocalizer | An IStringLocalizer can define localizable strings by calling the Translate() or TranslateFormat() method from a public computed property. Example: public string MyString => Translate("Neutral string") // returns "Translated string" if available A localizable string defaults to the neutral string, unless, OpenTAP is configured to display in a different language in which a translation is available |
| CTranslationManager | Functions for working with translations |
| CAllowAnyChildAttribute | Used to specify that a TestStep class allows any class of step to be added as a child |
| CAllowAsChildInAttribute | Identifies which TestStep types that allow this TestStep as a child. Parent type can be TestPlan |
| CAllowChildrenOfTypeAttribute | Specifies that a TestStep class allows any child TestStep of a given type |
| CAnnotationCollection | A collection of annotations. Used to store high-level information about an object |
| CAnnotationIgnoreAttribute | Marks that a property should be ignored when annotating members. This can be applied as an optimization to properties in order to improve annotation performance |
| CAssemblyData | Representation of an assembly including its dependencies. Part of the object model used in the PluginManager |
| CAssignOutputEventArgs | Event args for ITestStepPostRun mixin |
| CAttachmentType | An "extensible Enum" that can be used to describe attachments |
| CAvailableValuesAttribute | Marks that a property should be selected from a list in the UI. Points to another property that contains the list of possible values |
| CBeforeAttribute | Ordering constraint for plugin types. This should be used 'before' something else. This is currently only support by implementations of IStringConvertProvider. If more than one of these attributes are used, it will try to find a type before all of them |
| CBigFloat | Arbitrary precision floating point numbers for exact numeric computations for when performance is not an issue |
| CBigFloatConverter | Converter for OpenTAP arbitrary precision number types |
| CBreakConditionProperty | Break condition is an 'attached property' that can be attached to any implementor of ITestStep. This ensures that the API for ITestStep does not need to be modified to support the BreakConditions feature |
| CBreakOfferedEventArgs | Provides data for the TestPlan.BreakOffered event |
| CChildItemVisibility | Child item visibility implements the concept of showing or hiding a child item. This could for example be the child steps of a test step |
| CCliUserInputInterface | Standard implementation of UserInputInterface for Command Line interfaces |
| CColumnDisplayNameAttribute | Indicates that a property on a TestStep (a step setting) should be visible within a Test Plan editor UI |
| CComponentSettings | It is recommended to inherit from this class when implementing component settings. This class uses a recurrent template pattern to exhibit a kind of "static reflection" |
| CComponentSettingsLayoutAttribute | Attribute used to specify how to display a ComponentSettingsList class in a GUI |
| CComponentSettingsList | Contains some extra functionality for the ComponentSettingsList. Created so that it is possible to know which (generic) ComponentSettingsList contains a given type |
| CConnection | Object representing a connection between two Ports. Can be extended to add properties |
| CConnectionSettings | Settings specifying how DUTs and Instruments are connected |
| CConsoleTraceListener | A class that prints trace messages to the console |
| CDebuggerAttacher | Class for managing debuggers. Set the OPENTAP_DEBUGGER_ASSEMBLY environment variable to make it possible to attach debuggers. The environment variable should contain paths to assemblies with IDebugger implementations |
| CDefaultDataAnnotator | The default data annotator plugin. This normally forms the basis for annotation |
| CDefaultDisplayAttribute | The default display attribute is used to mark when the display attribute is not specifically added, but just autogenerated instead of putting a null value |
| CDefaultPictureDataProvider | Picture data provider for URI sources |
| CDelegateValidationRule | Validation rule that takes a delegate as an argument. Used for writing error messages |
| CDeserializeInPlaceAttribute | This attribute marks that an object should not be overwritten during serialization, but instead the value existing in the property should be used |
| CDeserializeOrderAttribute | Can be used to control the order in which members are deserialized |
| CDeviceAddressAttribute | Specifies the device address used to establish a connection. Use inheritance to define a custom device address. /> |
| CDirectionalRfConnection | A directional Connection that has an RF cable loss parameter |
| CDirectoryPathAttribute | Identifies a string as a directory path |
| CDisplayAttribute | Defines how a property, class, enum, or other item is presented to the user. Also configures the description and allows items to be grouped and ordered |
| CDotNetTypeDataSearcher | Searches for .NET types. This is the default TypeData searcher |
| CDut | Base class for DUT drivers |
| CDutSettings | Settings governing configured DUTs. These are usually configured by the user |
| CDynamicMember | Dynamic Member |
| CElementFactoryAttribute | Specifies that another member method can be used to create an element value for a given list property |
| CEmbedPropertiesAttribute | This attribute is used to dynamically embed the properties of an object into another object |
| CEnabled | A value that can be enabled or disabled |
| CEnabledIfAttribute | Identifies settings, properties, or methods that should only be valid/enabled when another property or setting has a certain value |
| CEngineSettings | Settings class containing user-configurable platform options |
| CEventTraceListener | A class that listens to trace messages and raises an event when a message occurs |
| CExceptionCustomStackTrace | Used to rethrow, adding more exception info but without generating a lot of extra stack lines |
| CExceptionExtensions | Extension methods for Exception |
| CExternalParameter | Represent an external test plan parameters that can be defined when a test plan is loaded |
| CExternalParameterAttribute | Indicates that a property on a TestStep (a step setting) should be a External Parameter by default when added into Test Plan editor UI |
| CExternalParameters | External test plan parameters |
| CFactoryAttribute | Specifies that another member method can be used to create a value for a given property |
| CFileDependencyAttribute | Marking a property with the FileDependencyAttribute attribute indicates that the property specifies a file. Files specified by this property are included as dependencies during serialization |
| CFilePathAttribute | Identifies a string as a file path |
| CFileTraceListener | TraceListener to be used in the App.Config file of the executable to write trace/log data to a file |
| CFixedSettingsListAttribute | Attribute that determines if the settings list should be fixed |
| CHelpLinkAttribute | Defines a help link for an object |
| CIAccessAnnotation | Specifies the access to an annotation |
| CIAnnotation | Marker interface to indicate that a type represents annotation data for an object |
| CIAnnotationStringer | This is interface is used for generating something from a string. Currently it is used only for PluginTypeSelectorAttribute |
| CIAnnotator | Annotators can be used to annotation objects with data for display |
| CIArtifactListener | Defines the interface for IArtifactListeners. Artifacts are generated by the test plan and may be any kind of file. The artifacts are published sequentially with the results |
| CIAssignOutputMixin | This type of mixin gives access to process an output just before it gets assigned |
| CIAttachmentStream | IResultStore that supports attachment streams |
| CIAttributedObject | A named object |
| CIAvailableValuesAnnotation | Defines a available values implementation. Implement this to extend the data annotation system with a new available values |
| CIAvailableValuesAnnotationProxy | Specifies how available values proxies are implemented. This class should rarely be implemented. Consider implementing just IAvailableValuesAnnotation instead |
| CIAvailableValuesSelectedAnnotation | Enhances the IAvailableValuesAnnotation with a 'SelectedValue'. Having this ensures that objects that has been transformed can get read back in the correct way |
| CIBasicCollectionAnnotation | Specifies how to implement basic collection annotations |
| CICollectionAnnotation | Specifies that the annotation reflects some kind of collection |
| CICombinedNumberSequence | A number of combined number sequences |
| CICombinedNumberSequenceExtension | Extensions for ICombinedNumberSequence |
| CIComponentSettings | Specifies the ComponentSettings class to be a OpenTAP plugin |
| CIconAnnotationAttribute | Icon Annotation attribute. for attaching icon information to a setting |
| CIconNames | Icon names defined here others might be defined by plugins. These names are used by IconAnnotationAttribute |
| CIConstResourceProperty | An immutable/constant object that is a property on a Resource. When deserializing references to objects of this type, TapSerializer makes sure that all references refer to the same unique instance on the specific instrument |
| CIConstResourcePropertyHelpers | Helper and extension methods for IConstResourceProperty |
| CICopyStringValueAnnotation | If the object value is based on copying values, some performance optimizations can be done, so these string value annotations can be marked with this interface |
| CIData | An object in a hierarchy with a name and some named properties |
| CIDebugger | Debugger plugin interface for attaching custom debuggers |
| CIDeserializedCallback | Enables callback from the OpenTAP deserializer after deserialization |
| CIDeviceDiscovery | Interface for defining a custom device address discovery system. Implement this along with a specialization of DeviceAddressAttribute |
| CIDisplayAnnotation | Specifies how a display is implemented and presented to user |
| CIDut | Base interface for DUT drivers |
| CIDynamicMemberData | A dynamic member data is a member data that can be detached from the owner member |
| CIDynamicMemberProvider | Provides a list of dynamic member types. Use DynamicMember.DeclaringType to control which types the member applies to e.g ITestStep |
| CIDynamicMembersProvider | This interface speeds up accessing dynamic members as it avoids having to access a global table to store the information |
| CIDynamicStep | Interface to facilitate the dynamic generation of TestStep types when loading the TestPlan from XML |
| CIEmbeddedMemberData | This interface describes an Embedded member data. When embedding an object with N properties, the embedee object will have N of these virtual properties. Each with the same OwnerMember, but different InnerMember |
| CIEnabled | Interface for types that can be enabled |
| CIEnabledAnnotation | Annotation for marking something as enabled or disabled |
| CIEnabledResource | Resources that can be enabled and disabled. Currently this is only supported for ResultListeners |
| CIEnabledValueAnnotation | Marks a setting that can be enabled/disabled by the user. UIs are expected to render a checkbox in front of the actual value. Settings of type Enabled<T> gets annotated with an annotation that implements this |
| CIErrorAnnotation | Defines how an error annotation works. Note: Multiple of IErrorAnnotation can be used in the same annotation. In this case the errors will be concatenated |
| CIExecutionListener | Interface to listen to when steps execute what |
| CIExternalTestPlanParameterExport | Custom handler for exporting external parameters from a TestPlan to a file |
| CIExternalTestPlanParameterImport | Custom handler for importing external parameters from a file |
| CIFactoryAttribute | Marks a factory attribute, for now this can be internal |
| CIFileResultStore | When implemented along with IResultStore, this interface allows files with a given extension to be opened using your ResultListener. It also can be used to allow the export of results to a file |
| CIFixedSizeCollectionAnnotation | Used to mark a collection as fixed-size |
| CIFormatName | A test step implements custom name formatting |
| CIForwardedAnnotations | Can be used to forward a set of members from one annotation to another |
| CIHideOnMultiSelectAnnotation | Marker interface that indicates that an IAnnotation does not support multi-selecting. When multi-selecting, the UI should not show properties annotated with this |
| CIIconAnnotation | Icon annotation, for giving a name of an icon associated with a setting. This is optionally supported by GUIs |
| CIInput | Interface for TestStep input properties |
| CIInputOutputRelations | Accelerating structure for inputs / outputs owners. Note, it is recommended to implement this explicitly |
| CIInputTypeRestriction | Input type restriction for IInput |
| CIInstrument | Base interface for all instruments |
| CIInteractiveIconAnnotation | For interactive icons that should be advertised on annotation collections |
| CIInvokable | Similar to Action, but this can be implemented by other classes |
| CILockManager | Implementing this interface will enable hooks before and after resources are opened and closed |
| CILoopStep | Marks a test step as a step that loops. Infinite loops can return null in place of MaxIterations |
| CIMemberAnnotation | Marks that an annotation reflects a member of an object |
| CIMemberData | A member of an object type |
| CIMemberMenuModel | Menu model for members |
| CIMembersAnnotation | The annotation reflects multiple members on an object |
| CIMenuModel | Base class for things in a menu item |
| CIMenuModelFactory | Factory class for build menus. This can be used to extend member with additional menu annotations |
| CIMenuModelState | A MenuModel that can signal about it's current state (Enabled/Disabled). This is useful to dynamically disable the menu model |
| CIMergedMethodAnnotation | The merged method annotation marks a custom method annotation which overrides the standard behavior in the case where multiple values are merged. This can happen during multi select of a test step with a method |
| CIMergedTableResultListener | This interface adds support for optimized/merged result tables. This can provide a performance boost in situations where many rows of the same kinds of results are published |
| CIMergedValueAnnotation | A marker interface for object value annotations that comes from a merged source instead of a single-value source |
| CIMethodAnnotation | The annotation can be invoked to do some action |
| CIMixin | Mixins can be used with EmbedPropertiesAttribute to give extra functionality to a test step |
| CIMixinBuilder | A mixin builder defines how to create and apply the instance of a specific mixin |
| CIMultiSelect | The object can be used for multi select operations. Example: FlagAttribute enums can be multi-selected |
| CIMultiSelectAnnotationProxy | Specifies how multi selection annotation proxies are implemented. Not this should rarely need to be implemented |
| CINamedMembersAnnotation | Like IMembersAnnotation, but a specific member can be fetched |
| CINotifyActivity | Notifies clients that the object is active |
| CInput | A generic type that specifies input properties for a TestStep. The user can link this property to properties on other TestSteps that are marked with the OutputAttribute When used in a TestStep, Input value should always be set in the constructor |
| CInputOutputRelation | Relations between two object and a pair of their members |
| CInputPort | An unidirectional port that is always an input |
| CInstrument | Base class for all instruments. Also see
|
| CInstrumentSettings | Settings governing configured instruments. These are usually configured by the user. |
| CInvokable | Action(T) IInvokable |
| CIObjectValueAnnotation | Gets or sets the value of a thing |
| CIOwnedAnnotation | Owned annotations interacts directly with the source object. It is updated through the Read operation and changes are written with the Write operation. Specialized knowledge about the object is needed for implementation |
| CIParameter | A named parameter |
| CIParameterizedMembersCache | For reverse caching of parameters. (source/member => parameter).f |
| CIParameterMemberData | An IMemberData that represents a parameter. The parameter controls the value of a set of parameterized members |
| CIParameterMemberDataNoPropagate | Marker interface for an IParameterMemberData where writes should not be propagated back to the parameter source |
| CIParameters | A list of parameters, with a string indexer |
| CIPicture | Represents a picture resource |
| CIPictureAnnotation | Marks that the annotated object is a picture |
| CIReflectionAnnotation | Reflects the type of the object value being annotated |
| CIReflectionData | Base info for reflection objects |
| CIResource | Base interface for resources. Specializations include Dut, Instrument and ResultListener |
| CIResourceManager | A resource manager implements this interface to be able to control how resources are opened and closed during a testplan execution |
| CIResourcePreOpenMixin | This mixin is activated just before a resource opens |
| CIResourceReferences | Used in ILockManager to represents a resource and its references |
| CIResultColumn | Interface to store IResultTable column data |
| CIResultListener | Interface forming the basis for all ResultListeners |
| CIResultSink | Object used to indicate that a TestStep is interested in results from another TestStep. A public property of this type should exist on the interested TestStep. Methods defined in this interface are called on all instances found as properties on TestSteps in the TestPlan |
| CIResultSource | Interface that the TestStep can access through the Results property |
| CIResultStore | Interface to results storage plugins |
| CIResultStoreNotification | Interface to add notifications when the Results Viewer gets new data |
| CIResultTable | Contains data that has the same table name, column names, and result data types as a ResultTable |
| CIResultTagging | Interface to support result tagging in the OpenTAP Results Viewer |
| CIScpiInstrument | Represents a connection to talk to any SCPI-enabled instrument |
| CIScpiIO | Represents low-level IO primitives for a given SCPI instrument |
| CIScpiIO2 | Represents low-level IO primitives for a given SCPI instrument |
| CIScpiIO3 | Represents low-level IO primitives for a given SCPI instrument. IScpiIO3 is the full interface needed to specify a VISA connection |
| CISettingReferenceIconAnnotation | Specialization of IIconAnnotation that represents a reference to a setting on another TestStep |
| CISkippableInvokable | Implements a check if an invocation can be skipped. This should only be implemented if it can be done very quickly |
| CIStackedTypeDataProvider | Hook into type reflection system. Provides type data for a given object or identifier. This variant is aware of the stack of other providers running after itself |
| CIStartupInfo | An IStartupInfo implementation logs some specific information about the current installation |
| CIStringConvertProvider | Plugin interface for string convert providers |
| CIStringExampleValueAnnotation | Makes it possible to get an example of a value from a property |
| CIStringOverlayAnnotation | Annotation added when a setting has a string overlay (Expression) |
| CIStringReadOnlyValueAnnotation | Defines a read-only string value annotation implementation |
| CIStringValueAnnotation | Defines a string value annotation implementation. This can be implemented for any type which can be converted to/from a string value. Note: IStringReadOnlyValueAnnotation can be implemented in the read-only case |
| CISuggestedValuesAnnotation | Defines a suggested values implementation |
| CISuggestedValuesAnnotationProxy | Specifies how suggested value proxies are implemented. This class should rarely be implemented. Consider implementing just ISuggestedValuesAnnotation instead |
| CITapPlugin | Base type for all OpenTAP plugins |
| CITapSerializerPlugin | Species a OpenTAP Serializer plugin |
| CITapSerializerPluginDependencyMarker | Allows a serializer plugin to specify if it is needed for deserialization. This can affect the package dependencies of test plans as the serializers used by the test plan are otherwise always dependencies of the test plan itself |
| CITestPlanExport | Custom handler for exporting TestPlan data. Which implementation of ITestPlanExport is used is based on the file type (ITestPlanExport.Extension) |
| CITestPlanExportCustomDialog | Custom GUI handler for importing TestPlan data |
| CITestPlanImport | Custom handler for importing TestPlan data. Which implementation of ITestPlanImport is used is based on the file type (ITestPlanExport.Extension) |
| CITestPlanImportCustomDialog | Custom GUI handler for importing TestPlan data |
| CITestPlanPostRunMixin | This mixin is activated just after a step is executed. It allows modifying the test plan run |
| CITestPlanPreRunMixin | This mixin is activated just before a plan is executed. It allows modifying the test plan run |
| CITestPlanRunMonitor | Interface for use in pre/post test plan (for example, it can be used to lock a remote setup). Only supported on ComponentSettings types |
| CITestStep | An interface for a TestStep. All TestSteps are instances of the ITestStep interface |
| CITestStepMenuModel | Menu models for test step properties |
| CITestStepParent | TestPlan or TestStep. Specifies that a class can be inserted into the test plan hierarchy |
| CITestStepPostRunMixin | This mixin is activated just after a step has been executed. It allows modifying the test step run |
| CITestStepPostRunMixinOrder | Defines an ordering for test step post run mixins |
| CITestStepPreRunMixin | This mixin is activated just before a step is executed. It allows modifying the test step run |
| CITestStepPreRunMixinOrder | Defines an ordering for test step pre run mixins |
| CITypeData | The type information of an object |
| CITypeDataProvider | Hook into type reflection system. Provides type data for a given object or identifier |
| CITypeDataSearcher | Searches for "types" and returns them as ITypeData objects. The OpenTAP type system calls all implementations of this |
| CITypeDataSearcherCacheInvalidated | A type data searcher with a cache invalidation event. This can be useful for notifying the rest of the TypeData system that new plugins has been found in this cache |
| CITypeDataSource | Specifies that an object is the source of types |
| CITypeDataSourceProvider | Used for a ITypeDataSearcher to identify a type as something that comes from it |
| CITypeMenuModel | Menu model for types |
| CITypeMenuModelFactory | Factory class for build menus. This can be used to extend a type with additional menu annotations |
| CIUserInputInterface | Defines a way for plugins to request input from the user |
| CIUserInterface | Defines a way for plugins to notify the user that a property has changed |
| CIValidatingObject | Provides the functionality to validate an element when the property changes |
| CIValueDescriptionAnnotation | Interface for providing annotations with a way of explaining the value |
| CIVisa | Interface implemented by VISA libraries |
| CIVisaFunctionLoader | Interface to load visa functions |
| CIVisaProvider | A mechanism for retrieving IVisa implementations |
| CLayoutAttribute | LayoutAttribute can be used to specify the wanted layout for user interfaces |
| CLimit | A single limit from a limit set |
| CLimitCondition | A condition for a specific limit that must be satisfied for the limit to apply |
| CLimitSet | A structure containing limit set data |
| CLog | This class extends System.Diagnostics.Log to provide shorthand methods for logging/tracing messages at different levels |
| CLogExtension | Helper class for writing warning messages about XML nodes |
| CLoginAction | Sets the authentication token for use with a given domain |
| CLogResultListener | Listens to events in the log and outputs them to a file. Can be configured with filters on the log verbosity level. FilePath supports replacement of date and verdict |
| CMacroExpansion | Converts a macro to its expanded string format |
| CMacroString | String that can be expanded with macros |
| CMemberData | Represents the members of C#/dotnet types |
| CMenuAnnotation | This annotation represents a context menu for a given setting. Multiple of these might be present in a single AnnotationCollection |
| ►CMetaDataAttribute | Indicates that a property contains metadata which may be saved into results |
| CMetaDataParameter | Contains metadata for one property |
| CMixinBuilderAttribute | This attribute marks a mixin builder with the types that it supports |
| CMixinFactory | Helper class for producing mixin builders |
| CMixinMemberData | Mixin member data |
| CMultiObjectAnnotator | Used for wrapping multi selections of objects |
| CNonMetaDataAttribute | Specifies that a property is does not constitute meta data for test plan runs |
| CNullTypeData | A type data representing null values |
| CNumberFormatter | Parser / back parser for numbers and sequences of numbers |
| CNumberUnitSplitter | A number unit splitter can split a text into numbers and units using whitespaces and changes from digits to characters as splitting points |
| CObjectCloner | Class for generic cloning of values. This is done in multiple ways |
| COutputAttribute | Specifies that a TestStep property is an output parameter. This property is expected to be set by TestStep.Run Also specifies a property that can be selected as an Input<T> to other TestSteps |
| COutputPort | An unidirectional port that is always an output |
| CParameterCollection | Read-only collection of parameters where parameters can be looked up by name |
| CParameterExtensions | Extensions for parameter operations |
| CParameterizedMembersCache | For accessing IParameterizedMembersCaches |
| CParameterMemberData | A member that represents a parameter. The parameter controls the value of a set of parameterized members. Parameterized members can be added/removed using IMemberData.Parameterize() and IMemberData.Unparameterize() |
| CPicture | Represents a picture resource |
| CPictureDataExtensions | Provide IPicture data from IPictureDataProvider implementations |
| CPluginAssemblyAttribute | Marks an assembly as one containing OpenTAP plugins |
| CPluginManager | Static class that searches for and loads OpenTAP plugins |
| CPluginOrderAttribute | Determines the order of plugin activation related to other plugins |
| CPluginsChangedEventArgs | This event args expresses when plugins inside PluginManager has changed. This is generally used for cache invalidation purposes |
| CPluginSearcher | Searches assemblies for classes implementing ITapPlugin |
| CPluginTypeSelectorAttribute | Indicates that a property can select an instance of a plugin type deriving from the type of the property |
| CPort | Object representing a port on an instrument or DUT. Ports are connected with Connection objects |
| CPosixFileLock | Locks a file using flock on linux and mac. This essentially works as a named mutex |
| CProxyAnnotation | Proxy annotation for wrapping simpler annotation types. For example IAvailableValuesAnnotation is wrapped in a IAvailableValuesAnnotationProxy |
| CReadOnlyMemberAnnotation | Annotates that a member is read only |
| CReflectionDataExtensions | Helpers for work with ITypeInfo objects |
| CResource | Base class for resources. Specializations include Dut, Instrument and ResultListener |
| CResourceOpenAttribute | Indicates how a IResource property should be handled when being opened or closed. By default the resources will be opened in sequence, so any referenced resources are open before Open() and until after Close() |
| CResourcePreOpenEventArgs | Event args for IResourcePreOpenMixin mixin |
| CResourceReference | Represents a reference to a resource. A reference is defined as something in the TestPlan that references a Resource, and thus causes it to get opened. Used by IResourceReferences |
| CResultAttribute | Specifies that a property of a step is also a result |
| CResultColumn | A class to store a column of data for a ResultTable |
| CResultListener | Abstract class forming the basis for all ResultListeners |
| CResultListenerIgnoreAttribute | Instructs the ResultListener not to save the public property value as metadata for TestStep results |
| CResultObjectTypes | Result object types existing in the OpenTAP name space |
| CResultParameter | Represents a result parameter |
| CResultParameters | A collection of parameters related to the results |
| CResultSettings | A class that collects and manages the different ResultListener objects |
| CResultSource | Temporarily holds results from a TestStep, before they are propagated to the ResultListener by the TestPlan. See TestStep.Results |
| CResultTable | A result table containing rows of results with matching names, column name, and types |
| ►CRfConnection | A Connection that has an RF cable loss parameter |
| CCableLossPoint | Represents a point in a frequency/loss table |
| CRunChildStepsOptions | Options for TestStep.RunChildSteps extension method |
| CScalarResultSink | ResultSink that will provide the first result from a given result column published by a given TestStep. When SourceTestStep is inside a loop step, only results from the last iteration of SourceTestStep is accessible |
| CScpi | Utility class for SCPI communication |
| CScpiAttribute | Identifies that a property should be converted to a SCPI string |
| ►CScpiInstrument | Implements a connection to talk to any SCPI-enabled instrument |
| CScpiError | A SCPI error |
| CScpiIO | Implements Visa SCPI IO |
| CSearchChildrenOf | Matches all children of the specified parents |
| CSearchCombinator | A binary operation between two other operations |
| CSearchCondition | The conditions for what to search for |
| CSearchLastRun | Matches the last test plan run |
| CSearchOperand | The basic search operand from which the other search operands are derived |
| CSearchParameterValue | Comparison between a named parameter and a value |
| CSearchRange | Comparison between a named parameter and a value |
| CSemanticVersion | Version object for OpenTAP versions. Adheres to Semantic Version 2.0 formatting and behavior, see http://semver.org. Supported formats: Major.Minor.Patch Major.Minor.Patch-PreRelease Major.Minor.Patch+BuildMetadata. Major.Minor.Patch-PreRelease+BuildMetadata |
| CSession | A session represents a collection of data associated with running and configuring test plans: |
| CSessionLocal | Used to hold a value that is specific to a session |
| CSessionLogs | SessionLogs are logs of all events that occur during startup/shutdown of a OpenTAP session and of all the session's TestPlan runs. A new session log is created at the start of each session, which starts when a process is launched and ends when it closes. Only 10 session logs are allowed to exist, with the oldest deleted as new logs are created. By comparison, a result log typically shows only the log activity for a single run of a TestPlan |
| CSettingsGroupAttribute | ComponentSettings with this attribute belong to a group with a specified name. They can be marked as profile groups, enabling selectable profiles for settings in that group |
| CShortTimeSpan | Takes care of printing and parsing time spans like '1 s' or '15.3 ms'. Supports seconds, milliseconds, microseconds and nanoseconds |
| CStepSelectorAttribute | Identifies the TestSteps that can be selected for a TestStep property |
| CStringConvertProvider | Helper methods for converting to/from strings |
| CSubmitAttribute | Specifies that a property finalizes input |
| CSuggestedValuesAttribute | Marks that a property can be selected from a list in the UI. Points to another property that contains the list of suggested values |
| CSupportedModelsAttribute | Describes what hardware an Instrument or Dut driver supports |
| CSwitchMatrixPath | Represents a specific path through a switch matrix |
| CSwitchMatrixPathCollection | Collecion of SwitchMatrixPaths that belong to a switch matrix. This is a lazy collection that is only populated with actual SwitchMatrixPath when each element is accessed or the |
| CSwitchPosition | Represents a specific setting/mode/position of a switch |
| CTapPluginExtensions | Extension class for Type |
| CTapSerializer | Serializing/deserializing OpenTAP objects. This class mostly just orchestrates a number of serializer plugins. MacroString |
| CTapSerializerPlugin | Base class for OpenTAP Serializer plugins. Implement this in a public class to extend the TapSerializer with additional functionality |
| CTapThread | Represents a item of work in the ThreadManager. Also allows access to the Parent TapThread (the thread that initially calledTapThread.Start(Action, string)) |
| CTeeStream | TeeStream allows many reader-streams to be created from one. If one reader is slower than the others, it will block until the slowest catches up |
| ►CTestPlan | Class containing a test plan |
| CPlanLoadException | Exception occuring when a test plan loads |
| CTestPlanPostRunEventArgs | Event args for the test plan post run mixin event |
| CTestPlanPreRunEventArgs | Event args for ITestStepPreRun mixin |
| ►CTestPlanRun | Object that holds the state of a specific TestPlan run. Also internally manages resources and threads relating to the TestStepRun. Note: ResourceManager manages opening and closing a Resource |
| CSpecialParameterNames | Special Parameters refer to result parameters on a test plan run that describe relevant metadata about the run. They can be extracted with e.g. 'Run.Parameters.FirstOrDefault(p => p.Name == SpecialParameterNames.Property)' |
| CTestPlanRunSummaryListener | Class for generating the summary for a test plan |
| CTestRun | Common base class for TestStepRun and TestPlanRun |
| CTestStep | All TestSteps that are instances of the TestStep abstract class should override the TestStep.Run method. Additionally, the TestStep.PrePlanRun and TestStep.PostPlanRun methods can be overridden |
| CTestStepExtensions | An extension class for the ITestStep interface |
| CTestStepList | This class holds a list of TestSteps and is used for the Children property of TestStepBase. It is responsible for making sure that all TestSteps added to the list are supported/allowed as children of the TestStep in the TestStepList.Parent field |
| CTestStepPostRunEventArgs | Event args for ITestStepPostRun mixin |
| CTestStepPreRunEventArgs | Event args for ITestStepPreRun mixin |
| CTestStepRun | Test step Run parameters. Contains information about a test step run. Unique for each time a test plan is run. If the same step is run multiple times during the same TestStep run, multiple instances of this object will be created |
| CTextWriterTraceListener | Simple TraceListener which outputs data to a TextWriter |
| CThreadHierarchyLocal | Has a separate value for each hierarchy of Threads that it is set on. If a thread sets this to a value, that value will be visible only to that thread and its child threads (as started using TapThread.Start(Action, string)) |
| CTimeSpanFormatAttribute | Attribute for giving directives to the TimeSpanControl provider, that shows the control provider in the GUI |
| CTimeSpanFormatter | Contains helper functions to format a time span into a human readable string |
| CTimeSpanParser | A time span parser can parse a text input (which would typically be a user input) for timespan information like "1 hour 2 minutes" or "1 week 250ms" and sum them all up into a TimeSpan. Currently only English units are supported |
| CTraceBar | Utility class to help print an "ASCII-art" graph with limits in the log files and windows |
| CTraceListener | Base class for various listeners |
| CTraceSource | Encapsulates the features of the OpenTAP logging infrastructure |
| CTypeData | Representation of a C#/dotnet type including its inheritance hierarchy. Part of the object model used in the PluginManager |
| CTypeDataCacheInvalidatedEventArgs | Event occuring when the TypeData cache has been invalidated |
| CTypeDataProviderStack | Represents a stack of ITypeDataProvider/IStackedTypeDataProvider that is used to get TypeData for a given type. The providers on this stack are called in order until a provider returuns a |
| CUnitAttribute | Identifies that units should be assigned to a property |
| CUnmergableAttribute | Marks a property on a test step that cannot be merged with another property from another step. |
| CUnparameterizableAttribute | Marks on a property that it cannot be parameterized |
| CUnsweepableAttribute | Marks a property on a test step that should be fixed during test plan execution. This means it should be excluded from e.g. sweep loops |
| CUserInput | Class for getting user input without using GUI |
| CUtils2 | Named Utils2 to avoid clashing with Utils from the Shared project |
| CValidatingObject | Runtime property value error-checking system. Can be used to validate an object before run or to display messages through a GUI |
| CValidationRule | Validates settings at runtime. A validation rule is attached to an object of type ValidatingObject and is used to validate the property value of that object. Also see ValidatingObject.Rules |
| CValidationRuleCollection | Collection of validation rules. Simplifies adding new rules by abstracting the use of ValidationRule objects |
| CViaPoint | Base class representing a point through which a connection passes. There is a list of these in Connection.Via. These usually represent a state that a connection switch element/instrument can be in. Implementations include SwitchPosition and SwitchMatrixPath |
| CVisaAddressAttribute | Identifies a string as a VISA address and finds a list of discovered VISA addresses |
| CVisaDeviceDiscovery | Implements device address discovery for VISA Keysight instruments and searches for device aliases |
| CVisaFunctions | Collection of all visa functions |
| CWorkQueue | Work Queue used for result processing in sequence but asynchronously. It uses the ThreadManager to automatically clean up threads that have been idle for a while. When the WorkQueue is disposed, the used thread is immediately returned to the ThreadManager |
| CXmlError | Contains detailed information about what went wrong while loading or saving information to an XML file |
| CXmlMessage | Contains detailed information about something that occured while loading or saving information to an XML file |
| CLibDl | This class uses and resolves libdl, which dependning on the OS comes in a libdl.so or libdl.so.2 flavor |
OpenTAP 9.35 API built Thu Sep 3 2026 13:51:29