ValueType Property

Applies to TestComplete 15.47, last modified on January 20, 2023

Description

Use ValueType to get the data type of the property value. To get the actual value of the property that the given aqObjPropertyObj object provides information about, use the aqObjPropertyObj.Value property.

Declaration

aqObjPropertyObj.ValueType

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

Applies To

The property is applied to the following object:

aqObjProperty

Property Value

An integer that indicates the type of the property value. 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.

Example

The code below obtains the type of the value returned by the specified property.

JavaScript, JScript
Python
VBScript
DelphiScript
C++Script, C#Script
Copy Code

JavaScript, JScript

function ValueType()
{

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

VBScript

Sub ValueType

  ' Specifies the object
  Set Obj = Sys.Process("MyApplication")
  
  ' Obtains information about the second property
  Set sProperty = aqObject.GetProperties(Obj).Item(1)
  
  Log.Message "The specified property returns "
  
  ' Obtains the type of the property's return value
  Select case sProperty.ValueType
    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 ValueType;
var Obj, Property;
begin

  // Specifies the object
  Obj := Sys.Process('MyApplication');
  
  // Obtains information about the second property
  sProperty := aqObject.GetProperties(Obj).Item[1];
  
  Log.Message('The specified property returns ');
  
  // Obtains the type of the property's return value
  case sProperty.ValueType 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 ValueType()
{

  // Specifies the object
  var Obj = Sys["Process"]("MyApplication");
  
  // Obtains information about the second property
  var sProperty = aqObject["GetProperties"](Obj)["Item"](1);
  
  Log["Message"]("The specified property returns ");
  
  // Obtains the type of property's return value
  switch ( sProperty["ValueType"] )
  {
    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

Value Property
Access Property
ParamName Property
ParamCount Property

Highlight search results