1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
{$mode objfpc}{$H+}
uses
Classes, SysUtils, Variants;
var
err : boolean;
function IsVariantOfType( pVariant : Variant ; pVarType : TVarType ) :
boolean ;
var
xVT : TVarType;
xVTHigh : TVarType;
// xVTLow : TVarType;
begin
// result := ( varType( pVariant ) and pVarType ) = pVarType ;
// Contr: VarType is varDate = 0007, pVarType is varInteger=0003.
// 0007 and 0003 = 0003. WRONG!
xVT := VarType(pVariant);
// xVTLow:=xVT and varTypeMask;
xVTHigh := xVT and (not varTypeMask);
// in true pVarType can be and OR of two types: varArray and varString (or others)
// we have to recognize it.
// there shouldn't be xVTLow because when we have array of string (normal) then
// xVT=$2008 = $2000 (var Array) or $0008 (var String)
// then when we asked:
// is $2000 (varArray)? we should receive TRUE (xVTHigh=pVarType)
// is $2008 (varArray of varString)? we should receive TRUE (xVT=pVarType)
// is $0008 (varString)? we should receive FALSE
Result := (xVT=pVarType) or ((xVTHigh=pVarType) and (xVTHigh<>varEmpty));
end ;
procedure TestIsVariantOfType ;
procedure _tiIsVariantOfType(xVar : variant; xExpected : TVarType; xMsg : string);
procedure __tiIsVariantOfType(xxCheck : TVarType; xxMsg : string);
begin
if xxCheck=xExpected then
begin
If not IsVariantOfType( xVar, xxCheck ) then
begin
Writeln(xMsg);
err:=true;
end;
end
else
begin
If IsVariantOfType( xVar, xxCheck ) then
begin
Writeln(xMsg + ' - ' + xxMsg);
err:=true;
end;
end;
end;
begin
__tiIsVariantOfType(varEmpty,'varEmpty');
__tiIsVariantOfType(varNull,'varNull');
__tiIsVariantOfType(varSmallint,'varSmallInt');
__tiIsVariantOfType(varInteger,'varInteger');
__tiIsVariantOfType(varSingle,'varSingle');
__tiIsVariantOfType(varDouble,'varDouble');
__tiIsVariantOfType(varDate,'varDate');
__tiIsVariantOfType(varBoolean,'varBoolean');
__tiIsVariantOfType(varOleStr,'varOleStr');
end;
var
lVar : Variant ;
lSmallInt : Smallint;
lInteger : Integer;
lDouble : Double;
lDateTimeNow : TDateTime;
lDateTimeDate : TDateTime;
lOleString : WideString;
lString : string;
lBoolean : boolean;
lCurrency : Currency;
begin
lSmallInt := 123;
lInteger := High(Integer);
lDouble := 123.45678901234567890;
lDateTimeNow := Now;
lDateTimeDate := Date;
lOleString := 'OLE STRING TEST';
lString := 'STRING TEST';
lBoolean := true;
lCurrency := 12345678.9876;
lVar := Unassigned;
_tiIsVariantOfType(lVar,varEmpty,'Failed with varEmpty');
lVar := Null ;
_tiIsVariantOfType(lVar,varNull,'Failed with varNull');
// There is no other way to receive variant of type small int...
lVar:=VarAsType(lSmallInt,varSmallint);
_tiIsVariantOfType(lVar,varSmallInt,'Failed with VarSmallint');
lVar:=lInteger;
_tiIsVariantOfType(lVar,varInteger,'Failed with Integer');
// Can't make this one work
lVar:=VarAsType(123.456,varSingle);
_tiIsVariantOfType(lVar,varSingle,'Failed with VarSingle');
lVar:=lDouble;
_tiIsVariantOfType(lVar,varDouble,'Failed with VarDouble');
lVar:=lDateTimeDate;
_tiIsVariantOfType(lVar,varDate,'Failed with varDate - DATE');
lVar:=lDateTimeNow;
_tiIsVariantOfType(lVar,varDate,'Failed with varDate - NOW');
lVar:=lBoolean;
_tiIsVariantOfType(lVar,varBoolean,'Failed with varBoolean');
lVar:=lOleString;
_tiIsVariantOfType(lVar,varOLEStr,'Failed with varOLEStr');
lVar := lString;
_tiIsVariantOfType(lVar, varString, 'Failed with varString');
lVar:=lCurrency;
_tiIsVariantOfType(lVar,varCurrency,'Failed with varCurrency');
// These ones have not been tested
// varCurrency Currency floating-point value (type Currency).
// varDispatch Reference to an Automation object (an IDispatch interface pointer).
// varError Operating system error code.
// varUnknown Reference to an unknown COM object (an IUnknown interface pointer).
// varByte 8-bit unsigned integer (type Byte).
// varTypeMask Bit mask for extracting type code.
// varArray Bit indicating variant array.
// varByRef Bit indicating variant contains a reference (rather than a value).
end;
begin
TestIsVariantOfType;
if err then
halt(1);
end.
|
