ParamType Property

Applies to TestComplete 14.91, last modified on July 20, 2021

Description

The ParamType returns the type of the property’s parameter specified by its index.

Declaration

aqObjPropertyObj.ParamType(Index)

Read-Only Property Integer
aqObjPropertyObj An expression, variable or parameter that specifies a reference to an aqObjProperty object
Index [in]    Required    Integer    

Applies To

The property is applied to the following object:

Parameters

The property has the following parameter:

Index

The zero-based index of the desired parameter in the list of property parameters. To get the total number of parameters, use the aqObjPropertyObj.ParamCount property.

Property Value

An integer that indicates the parameter's data type. The following types are possible:

Note: For the complete list of values, see the Microsoft documentation.

Constant Name Hex Value Integer Value Description
varEmpty 0000h 0 Empty (uninitialized).
varNull 0001h 1 Null (no valid data).
varSmallInt 0002h 2 Signed 16-bit integer.
varInteger 0003h 3 Signed 32-bit integer.
varSingle 0004h 4 Single-precision floating-point number. Number of significant digits: 7-8.
varDouble 0005h 5 Double-precision floating-point number. Number of significant digits: 15-16.
varCurrency 0006h 6 High-precision floating-point number. Number of significant digits: 19-20. Intended to minimize rounding errors in monetary calculations.
varDate 0007h 7 OLE-compatible TDateTime type.
varOleStr 0008h 8 String of 16-bit Unicode characters.
varDispatch 0009h 9 Automation object that implements IDispatch interface.
varError 000Ah 10 Code of an OS error.
varBoolean 000Bh 11 Boolean.
varVariant 000Ch 12 Variant.
varUnknown 000Dh 13 Reference to an unknown OLE object.
varShortInt 0010h 16 Signed 8-bit integer.
varByte 0011h 17 Unsigned 8-bit integer.
varWord 0012h 18 Unsigned 16-bit integer.
varLongWord 0013h 19 Unsigned 32-bit integer.
varInt64 0014h 20 Signed 64-bit integer.
varStrArg 48h 72 A COM-compatible string.
varString 100h 256 A reference to a dynamically allocated string (not COM-compatible).
varAny 101h 257 A Variant that can contain any value.
varArray 2000h 8192 Array. Type of array elements is specified by the lower bits. For example, 2003h is an array of integers.
varByRef 4000h 16384 Reference to a value of the type given by the lower bits. For example, 4007h is a reference to a date.

Remarks

If you use Python or DelphiScript, you should enclose the parameter of the ParamType property in square brackets: ParamType[Index].

Example

The code below obtains the type of the second parameter belonging to the specified property.

JavaScript, JScript

function ParameterType()
{

  // Specifies the object
  var Obj = Sys.Process("MyApplication");
  
  // Obtains information about the second property
  var sProperty = aqObject.GetProperties(Obj).Item(1);
  
  // Obtains the second parameter's type
  var sParamType = sProperty.ParamType(1);
  
  Log.Message("The specified property's second parameter is ");
  
  switch (sParamType)
  {
    case varEmpty :
    {
      Log.Message("an empty value.");
      break;
    }
    case varNull :
    {
      Log.Message("a null value.");
      break;
    }
    case varSmallInt :
    {
      Log.Message("a signed 16-bit integer value.");
      break;
    }
    case varInteger :
    {
      Log.Message("a signed 32-bit integer value.");
      break;
    }
    case varSingle :
    {
      Log.Message("a single-precision floating-point number.");
      break;
    }
    case varDouble :
    {
      Log.Message("a double-precision floating-point number.");
      break;
    }
    case varCurrency :
    {
      Log.Message("a high-precision floating-point number.");
      break;
    }
    case varDate :
    {
      Log.Message("a value of the OLE-compatible TDateTime type.");
      break;
    }
    case varOleStr :
    {
      Log.Message("a string of 16-bit Unicode characters.");
      break;
    }
    case varDispatch :
    {
      Log.Message("an automation object that implements the IDispatch interface.");
      break;
    }
    case varError :
    {
      Log.Message("a code of an OS error.");
      break;
    }
    case varBoolean :
    {
      Log.Message("a boolean value.");
      break;
    }
    case varVariant :
    {
      Log.Message("a variant value.");
      break;
    }
    case varUnknown :
    {
      Log.Message("a reference to an unknown OLE object.");
      break;
    }
    case varShortInt :
    {
      Log.Message("a signed 8-bit integer number.");
      break;
    }
    case varByte :
    {
      Log.Message("an unsigned 8-bit integer number.");
      break;
    }
    case varWord :
    {
      Log.Message("an unsigned 16-bit integer number.");
      break;
    }
    case varLongWord :
    {
      Log.Message("an unsigned 32-bit integer number.");
      break;
    }
    case varInt64 :
    {
      Log.Message("a signed 64-bit integer number.");
      break;
    }
    case varArray :
    {
      Log.Message("an array.");
      break;
    }
    case varByRef :
    {
      Log.Message("a reference to a value.");
      break
    }
  }
  
}

Python

def ParameterType():
  # Specifies the object
  Obj = Sys.Process("MyApplication")
  # Obtains information about the second property
  sProperty = aqObject.GetProperties(Obj).Item(1)
  # Obtains the second parameter's type
  sParamType = sProperty.ParamType[0]
  Log.Message("The specified property's second parameter is ")
  if sParamType == varEmpty: 
    Log.Message("an empty value.")
  elif sParamType == varNull: 
    Log.Message("a null value.")
  elif sParamType == varSmallInt: 
    Log.Message("a signed 16-bit integer value.")
  elif sParamType == varInteger:
    Log.Message("a signed 32-bit integer value.");
  elif sParamType == varSingle:
    Log.Message("a single-precision floating-point number.")
  elif sParamType == varDouble:
    Log.Message("a double-precision floating-point number.")
  elif sParamType == varCurrency: 
    Log.Message("a high-precision floating-point number.")
  elif sParamType == varDate:
    Log.Message("a value of the OLE-compatible TDateTime type.")
  elif sParamType == varOleStr:
    Log.Message("a string of 16-bit Unicode characters.")
  elif sParamType == varDispatch:
    Log.Message("an automation object that implements the IDispatch interface.")
  elif sParamType == varError:
    Log.Message("a code of an OS error.")
  elif sParamType == varBoolean:
    Log.Message("a boolean value.")
  elif sParamType == varVariant:
    Log.Message("a variant value.")
  elif sParamType == varUnknown:
    Log.Message("a reference to an unknown OLE object.")
  elif sParamType == varShortInt: 
    Log.Message("a signed 8-bit integer number.")
  elif sParamType == varByte: 
    Log.Message("an unsigned 8-bit integer number.")
  elif sParamType == varWord:
    Log.Message("an unsigned 16-bit integer number.")
  elif sParamType == varLongWord:
    Log.Message("an unsigned 32-bit integer number.")
  elif sParamType == varInt64:
    Log.Message("a signed 64-bit integer number.")
  elif sParamType == varArray:
    Log.Message("an array.")
  elif sParamType == varByRef:
    Log.Message("a reference to a value.")

VBScript

Sub ParameterType

  ' Specifies the object
  Set Obj = Sys.Process("MyApplication")
  
  ' Obtains information about the second property
  Set sProperty = aqObject.GetProperties(Obj).Item(1)
  
  ' Obtains the second parameter's type
  sParamType = sProperty.ParamType(1)
  
  Log.Message "The specified property's second parameter is "
  
  Select case sParamType
    case varEmpty : Log.Message "an empty value."
    case varNull : Log.Message "a null value."
    case varSmallInt : Log.Message "a signed 16-bit integer value."
    case varInteger : Log.Message "a signed 32-bit integer value."
    case varSingle : Log.Message "a single-precision floating-point number."
    case varDouble : Log.Message "a double-precision floating-point number."
    case varCurrency : Log.Message "a high-precision floating-point number."
    case varDate : Log.Message "a value of the OLE-compatible TDateTime type."
    case varOleStr : Log.Message "a string of 16-bit Unicode characters."
    case varDispatch : Log.Message "an automation object that implements the IDispatch interface."
    case varError : Log.Message "a code of an OS error."
    case varBoolean : Log.Message "a boolean value."
    case varVariant : Log.Message "a variant value."
    case varUnknown : Log.Message "a reference to an unknown OLE object."
    case varShortInt : Log.Message "a signed 8-bit integer number."
    case varByte : Log.Message "an unsigned 8-bit integer number."
    case varWord : Log.Message "an unsigned 16-bit integer number."
    case varLongWord : Log.Message "an unsigned 32-bit integer number."
    case varInt64 : Log.Message "a signed 64-bit integer number."
    case varArray : Log.Message "an array."
    case varByRef : Log.Message "a reference to a value."
  End Select
 
End Sub

DelphiScript

function ParameterType;
var Obj, sProperty,sParamType;
begin

  // Specifies the object
  Obj := Sys.Process('MyApplication');
  
  // Obtains information about the second property
  sProperty := aqObject.GetProperties(Obj).Item[1];
  
  // Obtains the second parameter's type
  sParamType := sProperty.ParamType[1];
  
  Log.Message('The specified property''s second parameter is ');
  
  case sParamType of
    varEmpty : Result := Log.Message('an empty value.');
    varNull : Result := Log.Message('a null value.');
    varSmallInt : Result := Log.Message('a signed 16-bit integer value.');
    varInteger : Result := Log.Message('a signed 32-bit integer value.');
    varSingle : Result := Log.Message('a single-precision floating-point number.');
    varDouble : Result := Log.Message('a double-precision floating-point number.');
    varCurrency : Result := Log.Message('a high-precision floating-point number.');
    varDate : Result := Log.Message('a value of the OLE-compatible TDateTime type.');
    varOleStr : Result := Log.Message('a string of 16-bit Unicode characters.')
    varDispatch : Result := Log.Message('an automation object that implements the IDispatch interface.');
    varError : Result := Log.Message('a code of an OS error.');
    varBoolean : Result := Log.Message('a boolean value.');
    varVariant : Result := Log.Message('a variant value.');
    varUnknown : Result := Log.Message('a reference to an unknown OLE object.');
    varShortInt : Result := Log.Message('a signed 8-bit integer number.');
    varByte : Result := Log.Message('an unsigned 8-bit integer number.');
    varWord : Result := Log.Message('an unsigned 16-bit integer number.');
    varLongWord : Result := Log.Message('an unsigned 32-bit integer number.');
    varInt64 : Result := Log.Message('a signed 64-bit integer number.');
    varArray : Result := Log.Message('an array.');
    varByRef : Result := Log.Message('a reference to a value.');
  end;
  
end;

C++Script, C#Script

function ParameterType()
{

  // Specifies the object
  var Obj = Sys["Process"]("MyApplication");
  
  // Obtains information about the second property
  var sProperty = aqObject["GetProperties"](Obj)["Item"](1);
  
  // Obtains the second parameter's type
  var sParamType = sProperty.ParamType(1);
   
  Log["Message"]("The specified property's second parameter is ");
  
  switch ( sParamType )
  {
    case varEmpty :
    {
      Log["Message"]("an empty value.");
      break;
    }
    case varNull :
    {
      Log["Message"]("a null value.");
      break;
    }
    case varSmallInt :
    {
      Log["Message"]("a signed 16-bit integer value.");
      break;
    }
    case varInteger :
    {
      Log["Message"]("a signed 32-bit integer value.");
      break;
    }
    case varSingle :
    {
      Log["Message"]("a single-precision floating-point number.");
      break;
    }
    case varDouble :
    {
      Log["Message"]("a double-precision floating-point number.");
      break;
    }
    case varCurrency :
    {
      Log["Message"]("a high-precision floating-point number.");
      break;
    }
    case varDate :
    {
      Log["Message"]("a value of the OLE-compatible TDateTime type.");
      break;
    }
    case varOleStr :
    {
      Log["Message"]("a string of 16-bit Unicode characters.");
      break;
    }
    case varDispatch :
    {
      Log["Message"]("an automation object that implements the IDispatch interface.");
      break;
    }
    case varError :
    {
      Log["Message"]("a code of an OS error.");
      break;
    }
    case varBoolean :
    {
      Log["Message"]("a boolean value.");
      break;
    }
    case varVariant :
    {
      Log["Message"]("a variant value.");
      break;
    }
    case varUnknown :
    {
      Log["Message"]("a reference to an unknown OLE object.");
      break;
    }
    case varShortInt :
    {
      Log["Message"]("a signed 8-bit integer number.");
      break;
    }
    case varByte :
    {
      Log["Message"]("an unsigned 8-bit integer number.");
      break;
    }
    case varWord :
    {
      Log["Message"]("an unsigned 16-bit integer number.");
      break;
    }
    case varLongWord :
    {
      Log["Message"]("an unsigned 32-bit integer number.");
      break;
    }
    case varInt64 :
    {
      Log["Message"]("a signed 64-bit integer number.");
      break;
    }
    case varArray :
    {
      Log["Message"]("an array.");
      break;
    }
    case varByRef :
    {
      Log["Message"]("a reference to a value.");
      break
    }
  }
   
}

See Also

Access Property
ParamName Property
ParamCount Property
Value Property

Highlight search results