ValueType Property

Applies to TestComplete 15.31, last modified on March 17, 2022

Description

Use the ValueType property to get the data type of the value returned by the method that the given aqObjMethodObj object provides information about. To check whether the method returns a value, use the HasRetValue property.

Declaration

aqObjMethodObj.ValueType

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

Applies To

The property is applied to the following object:

aqObjMethod

Property Value

An integer that indicates the type of the method's return 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 specifies the type of the value that is returned by the Click method.

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

JavaScript, JScript

function ValueType()
{

  // Launches notepad.exe
  WshShell.Run("notepad.exe", SW_NORMAL);
  
  // Specifies the object
  var Obj = Sys.Process("notepad").Window("Notepad", "Untitled - Notepad", 1);
  
  // Obtains information about the Click method
  var Method = aqObject.GetMethods(Obj).Item(1);
  
  Log.Message("The specified method returns ");
  
  // Obtains the type of the method's return value
  if (Method.HasRetValue() )
    switch (Method.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
      }
    }
  else 
    Log.Message("The specified method does not have a return value.");
  
 // Closes notepad.exe
  Sys.Process("notepad").Close();
   
}

Python

def ValueType():
  # Launches notepad.exe
  WshShell.Run("notepad.exe", SW_NORMAL)
  # Specifies the object
  Obj = Sys.Process("notepad").Window("Notepad", "Untitled - Notepad", 1)
  # Obtains information about the Click method
  Method = aqObject.GetMethods(Obj).Item(1)
  Log.Message("The specified method returns ")
  # Obtains the type of the method's return value
  if Method.HasRetValue():
    if Method.ValueType == varEmpty: 
      Log.Message("an empty value.");
    elif Method.ValueType == varNull:
      Log.Message("a null value.");
    elif Method.ValueType == varSmallInt:
      Log.Message("a signed 16-bit integer value.");
    elif Method.ValueType == varInteger: 
      Log.Message("a signed 32-bit integer value.");
    elif Method.ValueType == varSingle:
      Log.Message("a single-precision floating-point number.")
    elif Method.ValueType == varDouble:
      Log.Message("a double-precision floating-point number.")
    elif Method.ValueType == varCurrency: 
      Log.Message("a high-precision floating-point number.")
    elif Method.ValueType == varDate:
      Log.Message("a value of the OLE-compatible TDateTime type.")
    elif Method.ValueType == varOleStr: 
      Log.Message("a string of 16-bit Unicode characters.")
    elif Method.ValueType == varDispatch:
      Log.Message("an automation object that implements the IDispatch interface.")
    elif Method.ValueType == varError:
      Log.Message("a code of an OS error.")
    elif Method.ValueType == varBoolean:
      Log.Message("a boolean value.")
    elif Method.ValueType == varVariant:
      Log.Message("a variant value.")
    elif Method.ValueType == varUnknown:
      Log.Message("a reference to an unknown OLE object.")
    elif Method.ValueType == varShortInt:
      Log.Message("a signed 8-bit integer number.")
    elif Method.ValueType == varByte:
      Log.Message("an unsigned 8-bit integer number.")
    elif Method.ValueType == varWord:
      Log.Message("an unsigned 16-bit integer number.")
    elif Method.ValueType == varLongWord:
      Log.Message("an unsigned 32-bit integer number.")
    elif Method.ValueType == varInt64:
      Log.Message("a signed 64-bit integer number.")
    elif Method.ValueType == varArray:
      Log.Message("an array.")
    elif Method.ValueType == varByRef:
      Log.Message("a reference to a value.")
  else:
    Log.Message("The specified method does not have a return value.")
  # Closes notepad.exe
  Sys.Process("notepad").Close()

VBScript

Sub ValueType

  ' Launches notepad.exe
  Call WshShell.Run("notepad.exe", SW_NORMAL)
  
  ' Specifies the object
  Set Obj = Sys.Process("notepad").Window("Notepad", "Untitled - Notepad", 1)
  
  ' Obtains information about the Click method
  Set Method = aqObject.GetMethods(Obj).Item(1)
  
  Log.Message "The specified method returns "
  
  ' Obtains the type of the method's return value
  If Method.HasRetValue Then
    Select case Method.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
  Else 
    Log.Message "The specified method does not have a return value."
  End If
  
 ' Closes notepad.exe
  Sys.Process("notepad").Close
   
End Sub

DelphiScript

function ValueType;
var Obj, Method;
begin

  // Launches notepad.exe
  WshShell.Run('notepad.exe', SW_NORMAL);
  
  // Specifies the object
  Obj := Sys.Process('notepad').Window('Notepad', 'Untitled - Notepad', 1);
  
  // Obtains information about the Click method
  Method := aqObject.GetMethods(Obj).Item[1];
  
  Log.Message('The specified method returns ');
  
  // Obtains the type of the method's return value
  if (Method.HasRetValue() ) then
    case Method.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
   else 
    Log.Message('The specified method does not have a return value.');
  
  // Closes notepad.exe
  Sys.Process('notepad').Close();
   
end;

C++Script, C#Script

function ValueType()
{

  // Launches notepad.exe
  WshShell["Run"]("notepad.exe", SW_NORMAL);
  
  // Specifies the object
  var Obj = Sys["Process"]("notepad")["Window"]("Notepad", "Untitled - Notepad", 1);
  
  // Obtains information about the Click method
  var Method = aqObject["GetMethods"](Obj)["Item"](1);
  
  Log["Message"]("The specified method returns ");
  
  // Obtains the type of the method's return value
  if ( Method["HasRetValue"]() )
    switch ( Method["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
      }
    }
  else 
    Log["Message"]("The specified method does not have a returned value.");
  
 // Closes notepad.exe
  Sys["Process"]("notepad")["Close"]();
   
}

See Also

HasRetValue Method
Name Property
ParamCount Property
ParamName Property
ParamType Property

Highlight search results