[VBSCRIPT_WINETEST]

* Sync with Wine 1.7.27.
CORE-8540

svn path=/trunk/; revision=64609

diff --git a/rostests/winetests/vbscript/api.vbs b/rostests/winetests/vbscript/api.vbs
index 3c496b1..d688e17 100644 (file)
--- a/rostests/winetests/vbscript/api.vbs
+++ b/rostests/winetests/vbscript/api.vbs
@@ -1,4 +1,3 @@
-'
 ' Copyright 2011 Jacek Caban for CodeWeavers
 '
 ' This library is free software; you can redistribute it and/or
@@ -136,6 +135,31 @@ Call ok(Chr(120) = "x", "Chr(120) = " & Chr(120))
 Call ok(Chr(0) <> "", "Chr(0) = """"")
 Call ok(Chr(120.5) = "x", "Chr(120.5) = " & Chr(120.5))
 Call ok(Chr(119.5) = "x", "Chr(119.5) = " & Chr(119.5))
+Call ok(Chr("120") = "x", "Chr(""120"") = " & Chr("120"))
+
+sub testChrError
+    on error resume next
+
+    if isEnglishLang then
+        call Err.clear()
+        call Chr(-1)
+        call ok(Err.number = 5, "Err.number = " & Err.number)
+
+        call Err.clear()
+        call Chr(256)
+        call ok(Err.number = 5, "Err.number = " & Err.number)
+    end if
+
+    call Err.clear()
+    call Chr(65536)
+    call ok(Err.number = 5, "Err.number = " & Err.number)
+
+    call Err.clear()
+    call Chr(-32769)
+    call ok(Err.number = 5, "Err.number = " & Err.number)
+end sub
+
+call testChrError
 
 Call ok(isObject(new EmptyClass), "isObject(new EmptyClass) is not true?")
 Set x = new EmptyClass
@@ -170,6 +194,31 @@ Call ok(not isNull(4), "isNull(4) is true?")
 Call ok(not isNull("x"), "isNull(""x"") is true?")
 Call ok(isNull(Null), "isNull(Null) is not true?")
 
+Call ok(isNumeric(Empty), "isNumeric(empty) is not true?")
+Call ok(not isNumeric(Null), "isNumeric(Null) is not true?")
+Call ok(isNumeric(32767), "isNumeric(32767) is true?")
+Call ok(isNumeric(32768), "isNumeric(32768) is true?")
+Call ok(isNumeric(CSng(3242.4)), "isNumeric(CSng(3242.4)) is true?")
+Call ok(isNumeric(32768.4), "isNumeric(32768.4) is true?")
+Call ok(isNumeric(CCur(32768.4)), "isNumeric(CCur(32768.4)) is true?")
+Call ok(isNumeric("44"), "isNumeric(""44"") is true?")
+Call ok(not isNumeric("rwrf"), "isNumeric(""rwrf"") is not true?")
+Call ok(not isNumeric(Nothing), "isNumeric(Nothing) is not true?")
+Call ok(not isNumeric(New EmptyClass), "isNumeric(New EmptyClass) is not true?")
+Call ok(isNumeric(true), "isNumeric(true) is true?")
+Call ok(isNumeric(CByte(32)), "isNumeric(CByte(32)) is true?")
+Dim arr(2)
+arr(0) = 2
+arr(1) = 3
+Call ok(not isNumeric(arr), "isNumeric(arr) is not true?")
+
+Dim newObject
+Set newObject = New ValClass
+newObject.myval = 1
+Call ok(isNumeric(newObject), "isNumeric(newObject) is true?")
+newObject.myval = "test"
+Call ok(not isNumeric(newObject), "isNumeric(newObject) is not true?")
+
 Call ok(getVT(err) = "VT_DISPATCH", "getVT(err) = " & getVT(err))
 
 Sub TestHex(x, ex)
@@ -297,6 +346,7 @@ Call ok(Space(5.5) = "      ", "Space(5.5) = " & Space(5.5) & """")
 Call ok(Space(4.5) = "    ", "Space(4.5) = " & Space(4.5) & """")
 Call ok(Space(0.5) = "", "Space(0.5) = " & Space(0.5) & """")
 Call ok(Space(1.5) = "  ", "Space(1.5) = " & Space(1.5) & """")
+Call ok(Space("1") = " ", "Space(""1"") = " & Space("1") & """")
 
 Sub TestStrReverse(str, ex)
     Call ok(StrReverse(str) = ex, "StrReverse(" & str & ") = " & StrReverse(str))
@@ -317,6 +367,7 @@ TestLeft "test", 0, ""
 TestLeft 123, 2, "12"
 TestLeft "123456", 1.5, "12"
 TestLeft "123456", 2.5, "12"
+TestLeft "test", "2", "te"
 if isEnglishLang then TestLeft true, 2, "Tr"
 
 Sub TestRight(str, len, ex)
@@ -464,4 +515,729 @@ Call ok(getVT(CBool(0)) = "VT_BOOL", "getVT(CBool(0)) = " & getVT(CBool(0)))
 Call ok(CBool(-5) = true, "CBool(-5) = " & CBool(-5))
 Call ok(getVT(CBool(-5)) = "VT_BOOL", "getVT(CBool(-5)) = " & getVT(CBool(-5)))
 
+Sub testCBoolError(strings, error_num)
+    on error resume next
+
+    Call Err.clear()
+    Call CBool(strings)
+    Call ok(Err.number = error_num, "Err.number = " & Err.number)
+End Sub
+
+Class ValClass
+    Public myval
+
+    Public default Property Get defprop
+        defprop = myval
+    End Property
+End Class
+
+Dim MyObject
+Set MyObject = New ValClass
+
+Call ok(CBool(Empty) = False, "CBool(Empty) = " & CBool(Empty))
+Call ok(getVT(CBool(Empty)) = "VT_BOOL", "getVT(CBool(Empty)) = " & getVT(CBool(Empty)))
+Call ok(CBool(1) = True, "CBool(1) = " & CBool(1))
+Call ok(getVT(CBool(1)) = "VT_BOOL", "getVT(CBool(1)) = " & getVT(CBool(1)))
+Call ok(CBool(0) = False, "CBool(0) = " & CBool(0))
+Call ok(getVT(CBool(0)) = "VT_BOOL", "getVT(CBool(0)) = " & getVT(CBool(0)))
+Call ok(CBool(-0.56) = True, "CBool(-0.56) = " & CBool(-0.56))
+Call ok(getVT(CBool(-0.56)) = "VT_BOOL", "getVT(CBool(-0.56)) = " & getVT(CBool(-0.56)))
+Call testCBoolError("", 13)
+Call ok(CBool("0") = False, "CBool(""0"") = " & CBool("0"))
+Call ok(getVT(CBool("0")) = "VT_BOOL", "getVT(CBool(""0"")) = " & getVT(CBool("0")))
+If isEnglishLang Then
+    Call ok(CBool("0.1") = True, "CBool(""0.1"") = " & CBool("0.1"))
+    Call ok(getVT(CBool("0.1")) = "VT_BOOL", "getVT(CBool(""0.1"")) = " & getVT(CBool("0.1")))
+End If
+    Call ok(CBool("true") = True, "CBool(""true"") = " & CBool("true"))
+Call ok(getVT(CBool("true")) = "VT_BOOL", "getVT(CBool(""true"")) = " & getVT(CBool("true")))
+Call ok(CBool("false") = False, "CBool(""false"") = " & CBool("false"))
+Call ok(getVT(CBool("false")) = "VT_BOOL", "getVT(CBool(""false"")) = " & getVT(CBool("false")))
+Call ok(CBool("TRUE") = True, "CBool(""TRUE"") = " & CBool("TRUE"))
+Call ok(getVT(CBool("TRUE")) = "VT_BOOL", "getVT(CBool(""TRUE"")) = " & getVT(CBool("TRUE")))
+Call ok(CBool("FALSE") = False, "CBool(""FALSE"") = " & CBool("FALSE"))
+Call ok(getVT(CBool("FALSE")) = "VT_BOOL", "getVT(CBool(""FALSE"")) = " & getVT(CBool("FALSE")))
+Call ok(CBool("#TRUE#") = True, "CBool(""#TRUE#"") = " & CBool("#TRUE#"))
+Call ok(getVT(CBool("#TRUE#")) = "VT_BOOL", "getVT(CBool(""#TRUE#"")) = " & getVT(CBool("#TRUE#")))
+Call ok(CBool("#FALSE#") = False, "CBool(""#FALSE#"") = " & CBool("#FALSE#"))
+Call ok(getVT(CBool("#FALSE#")) = "VT_BOOL", "getVT(CBool(""#FALSE#"")) = " & getVT(CBool("#FALSE#")))
+Call ok(CBool(MyObject) = False, "CBool(MyObject) = " & CBool(MyObject))
+Call ok(getVT(CBool(MyObject)) = "VT_BOOL", "getVT(CBool(MyObject)) = " & getVT(CBool(MyObject)))
+MyObject.myval = 1
+Call ok(CBool(MyObject) = True, "CBool(MyObject) = " & CBool(MyObject))
+Call ok(getVT(CBool(MyObject)) = "VT_BOOL", "getVT(CBool(MyObject)) = " & getVT(CBool(MyObject)))
+MyObject.myval = 0
+Call ok(CBool(MyObject) = False, "CBool(MyObject) = " & CBool(MyObject))
+Call ok(getVT(CBool(MyObject)) = "VT_BOOL", "getVT(CBool(MyObject)) = " & getVT(CBool(MyObject)))
+
+Sub testCByteError(strings, error_num1,error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = CByte(strings)
+    Call ok(Err.number = error_num1, "Err.number = " & Err.number)
+
+    Call Err.clear()
+    Call CByte(strings)
+    Call ok(Err.number = error_num2, "Err.number = " & Err.number)
+End Sub
+
+Call ok(CByte(Empty) = 0, "CByte(Empty) = " & CByte(Empty))
+Call ok(getVT(CByte(Empty)) = "VT_UI1", "getVT(CByte(Empty)) = " & getVT(CByte(Empty)))
+Call ok(CByte(255) = 255, "CByte(255) = " & CByte(255))
+Call ok(getVT(CByte(255)) = "VT_UI1", "getVT(CByte(255)) = " & getVT(CByte(255)))
+Call ok(CByte(255.49) = 255, "CByte(255.49) = " & CByte(255.49))
+Call ok(getVT(CByte(255.49)) = "VT_UI1", "getVT(CByte(255.49)) = " & getVT(CByte(255.49)))
+Call testCByteError(1, 0, 458)
+Call testCByteError("", 13, 13)
+Call testCByteError("-1", 6, 6)
+Call testCByteError("258", 6, 6)
+Call testCByteError("TRUE", 13, 13)
+Call testCByteError("FALSE", 13, 13)
+Call testCByteError("#TRue#", 13, 13)
+Call testCByteError("#fAlSE#", 13, 13)
+If isEnglishLang Then
+    Call ok(CByte("-0.5") = 0, "CByte(""-0.5"") = " & CByte("-0.5"))
+    Call ok(getVT(CByte("-0.5")) = "VT_UI1", "getVT(CByte(""-0.5"")) = " & getVT(CByte("-0.5")))
+End If
+Call ok(CByte(True) = 255, "CByte(True) = " & CByte(True))
+Call ok(getVT(CByte(True)) = "VT_UI1", "getVT(CByte(True)) = " & getVT(CByte(True)))
+Call ok(CByte(False) = 0, "CByte(False) = " & CByte(False))
+Call ok(getVT(CByte(False)) = "VT_UI1", "getVT(CByte(False)) = " & getVT(CByte(False)))
+Call ok(CByte(MyObject) = 0, "CByte(MyObject) = " & CByte(MyObject))
+Call ok(getVT(CByte(MyObject)) = "VT_UI1", "getVT(CByte(MyObject)) = " & getVT(CByte(MyObject)))
+MyObject.myval = 1
+Call ok(CByte(MyObject) = 1, "CByte(MyObject) = " & CByte(MyObject))
+Call ok(getVT(CByte(MyObject)) = "VT_UI1", "getVT(CByte(MyObject)) = " & getVT(CByte(MyObject)))
+MyObject.myval = 0
+Call ok(CByte(MyObject) = 0, "CByte(MyObject) = " & CByte(MyObject))
+Call ok(getVT(CByte(MyObject)) = "VT_UI1", "getVT(CByte(MyObject)) = " & getVT(CByte(MyObject)))
+
+Sub testCCurError(strings, error_num1, error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = CCur(strings)
+    Call ok(Err.number = error_num1, "Err.number = " & Err.number)
+
+    Call Err.clear()
+    Call CCur(strings)
+    Call ok(Err.number = error_num2, "Err.number = " & Err.number)
+End Sub
+
+Call ok(CCur(Empty) = 0, "CCur(Empty) = " & CCur(Empty))
+Call ok(getVT(CCur(Empty)) = "VT_CY", "getVT(CCur(Empty)) = " & getVT(CCur(Empty)))
+Call ok(CCur(-32768) = -32768, "CCur(-32768) = " & CCur(-32768))
+Call ok(getVT(CCur(-32768)) = "VT_CY", "getVT(CCur(-32768)) = " & getVT(CCur(-32768)))
+Call ok(CCur(32768) = 32768, "CCur(32768) = " & CCur(32768))
+Call ok(getVT(CCur(32768)) = "VT_CY", "getVT(CCur(32768)) = " & getVT(CCur(32768)))
+Call ok(CCur(0.000149) = 0.0001, "CCur(0.000149) = " & CCur(0.000149))
+Call ok(getVT(CCur(0.000149)) = "VT_CY", "getVT(CCur(0.000149)) = " & getVT(CCur(0.000149)))
+Call ok(CCur(2147483647.99) = 2147483647.99, "CCur(2147483647.99) = " & CCur(2147483647.99))
+Call ok(getVT(CCur(2147483647.99)) = "VT_CY", "getVT(CCur(2147483647.99)) = " & getVT(CCur(2147483647.99)))
+Call ok(CCur("-1") = -1, "CCur(""-1"") = " & CCur("-1"))
+Call ok(getVT(CCur("-1")) = "VT_CY", "getVT(CCur(""-1"")) = " & getVT(CCur("-1")))
+If isEnglishLang Then
+    Call ok(CCur("-0.5") = -0.5, "CCur(""-0.5"") = " & CCur("-0.5"))
+    Call ok(getVT(CCur("-0.5")) = "VT_CY", "getVT(CCur(""-0.5"")) = " & getVT(CCur("-0.5")))
+End If
+Call testCCurError("", 13, 13)
+Call testCCurError("-1", 0, 458)
+Call testCCurError("TRUE", 13, 13)
+Call testCCurError("FALSE", 13, 13)
+Call testCCurError("#TRue#", 13, 13)
+Call testCCurError("#fAlSE#", 13, 13)
+Call testCCurError(1, 0, 458)
+Call ok(CCur(True) = -1, "CCur(True) = " & CCur(True))
+Call ok(getVT(CCur(True)) = "VT_CY", "getVT(CCur(True)) = " & getVT(CCur(True)))
+Call ok(CCur(False) = 0, "CCur(False) = " & CCur(False))
+Call ok(getVT(CCur(False)) = "VT_CY", "getVT(CCur(False)) = " & getVT(CCur(False)))
+MyObject.myval = 0.1
+Call ok(CCur(MyObject) = 0.1, "CCur(MyObject) = " & CCur(MyObject))
+Call ok(getVT(CCur(MyObject)) = "VT_CY", "getVT(CCur(MyObject)) = " & getVT(CCur(MyObject)))
+MyObject.myval = 0
+Call ok(CCur(MyObject) = 0, "CCur(MyObject) = " & CCur(MyObject))
+Call ok(getVT(CCur(MyObject)) = "VT_CY", "getVT(CCur(MyObject)) = " & getVT(CCur(MyObject)))
+
+Sub testCDblError(strings, error_num1, error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = CDbl(strings)
+    Call ok(Err.number = error_num1, "Err.number = " & Err.number)
+
+    Call Err.clear()
+    Call CDbl(strings)
+    Call ok(Err.number = error_num2, "Err.number = " & Err.number)
+End Sub
+
+Call ok(CDbl(Empty) = 0, "CDbl(Empty) = " & CDbl(Empty))
+Call ok(getVT(CDbl(Empty)) = "VT_R8", "getVT(CDbl(Empty)) = " & getVT(CDbl(Empty)))
+Call ok(CDbl(CByte(0)) = 0, "CDbl(CByte(0)) = " & CDbl(CByte(0)))
+Call ok(getVT(CDbl(CCur(0))) = "VT_R8", "getVT(CDbl(CCur(0))) = " & getVT(CDbl(CCur(0))))
+Call ok(CDbl(CCur(0)) = 0, "CDbl(CCur(0)) = " & CDbl(CCur(0)))
+Call ok(getVT(CDbl(CCur(0))) = "VT_R8", "getVT(CDbl(CCur(0))) = " & getVT(CDbl(CCur(0))))
+Call ok(CDbl(0) = 0, "CDbl(0) = " & CDbl(0))
+Call ok(getVT(CDbl(0)) = "VT_R8", "getVT(CDbl(0)) = " & getVT(CDbl(0)))
+Call ok(CDbl(32768) = 32768, "CDbl(32768) = " & CDbl(32768))
+Call ok(getVT(CDbl(32768)) = "VT_R8", "getVT(CDbl(32768)) = " & getVT(CDbl(32768)))
+Call ok(CDbl(0.001 * 0.001) = 0.000001, "CDbl(0.001 * 0.001) = " & CDbl(0.001 * 0.001))
+Call ok(getVT(CDbl(0.001 * 0.001)) = "VT_R8", "getVT(CDbl(0.001 * 0.001)) = " & getVT(CDbl(0.001 * 0.001)))
+Call ok(CDbl("-1") = -1, "CDbl(""-1"") = " & CDbl("-1"))
+Call ok(getVT(CDbl("-1")) = "VT_R8", "getVT(CDbl(""-1"")) = " & getVT(CDbl("-1")))
+If isEnglishLang Then
+    Call ok(CDbl("-0.5") = -0.5, "CDbl(""-0.5"") = " & CDbl("-0.5"))
+    Call ok(getVT(CDbl("-0.5")) = "VT_R8", "getVT(CDbl(""-0.5"")) = " & getVT(CDbl("-0.5")))
+End If
+Call testCDblError("", 13, 13)
+Call testCDblError("TRUE", 13, 13)
+Call testCDblError("FALSE", 13, 13)
+Call testCDblError("#TRue#", 13, 13)
+Call testCDblError("#fAlSE#", 13, 13)
+Call testCDblError(1, 0, 458)
+Call ok(CDbl(True) = -1, "CDbl(True) = " & CDbl(True))
+Call ok(getVT(CDbl(True)) = "VT_R8", "getVT(CDbl(True)) = " & getVT(CDbl(True)))
+Call ok(CDbl(False) = 0, "CDbl(False) = " & CDbl(False))
+Call ok(getVT(CDbl(False)) = "VT_R8", "getVT(CDbl(False)) = " & getVT(CDbl(False)))
+MyObject.myval = 0.1
+Call ok(CDbl(MyObject) = 0.1, "CDbl(MyObject) = " & CDbl(MyObject))
+Call ok(getVT(CDbl(MyObject)) = "VT_R8", "getVT(CDbl(MyObject)) = " & getVT(CDbl(MyObject)))
+MyObject.myval = 0
+Call ok(CDbl(MyObject) = 0, "CDbl(MyObject) = " & CDbl(MyObject))
+Call ok(getVT(CDbl(MyObject)) = "VT_R8", "getVT(CDbl(MyObject)) = " & getVT(CDbl(MyObject)))
+
+Sub testCLngError(strings, error_num1, error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = CLng(strings)
+    Call ok(Err.number = error_num1, "Err.number = " & Err.number)
+
+    Call Err.clear()
+    Call CLng(strings)
+    Call ok(Err.number = error_num2, "Err.number = " & Err.number)
+End Sub
+
+Call ok(CLng(Empty) = 0, "CLng(Empty) = " & CLng(Empty))
+Call ok(getVT(CLng(Empty)) = "VT_I4", "getVT(CLng(Empty)) = " & getVT(CLng(Empty)))
+Call ok(CLng(CByte(0)) = 0, "CLng(CByte(0)) = " & CLng(CByte(0)))
+Call ok(getVT(CLng(CCur(0))) = "VT_I4", "getVT(CLng(CCur(0))) = " & getVT(CLng(CCur(0))))
+Call ok(CLng(CCur(0)) = 0, "CLng(CCur(0)) = " & CLng(CCur(0)))
+Call ok(getVT(CLng(CCur(0))) = "VT_I4", "getVT(CLng(CCur(0))) = " & getVT(CLng(CCur(0))))
+Call ok(CLng(0) = 0, "CLng(0) = " & CLng(0))
+Call ok(getVT(CLng(0)) = "VT_I4", "getVT(CLng(0)) = " & getVT(CLng(0)))
+Call ok(CLng(0.49) = 0, "CLng(0.49) = " & CLng(0.49))
+Call ok(getVT(CLng(0.49)) = "VT_I4", "getVT(CLng(0.49)) = " & getVT(CLng(0.49)))
+Call ok(CLng(0.5) = 0, "CLng(0.5) = " & CLng(0.5))
+Call ok(getVT(CLng(0.5)) = "VT_I4", "getVT(CLng(0.5)) = " & getVT(CLng(0.5)))
+Call ok(CLng(0.51) = 1, "CLng(0.51) = " & CLng(0.51))
+Call ok(getVT(CLng(0.51)) = "VT_I4", "getVT(CLng(0.51)) = " & getVT(CLng(0.51)))
+Call ok(CLng(1.49) = 1, "CLng(1.49) = " & CLng(1.49))
+Call ok(getVT(CLng(1.49)) = "VT_I4", "getVT(CLng(1.49)) = " & getVT(CLng(1.49)))
+Call ok(CLng(1.5) = 2, "CLng(1.5) = " & CLng(1.5))
+Call ok(getVT(CLng(1.5)) = "VT_I4", "getVT(CLng(1.5)) = " & getVT(CLng(1.5)))
+Call ok(CLng(1.51) = 2, "CLng(1.51) = " & CLng(1.51))
+Call ok(getVT(CLng(1.51)) = "VT_I4", "getVT(CLng(1.51)) = " & getVT(CLng(1.51)))
+Call ok(CLng("-1") = -1, "CLng(""-1"") = " & CLng("-1"))
+Call ok(getVT(CLng("-1")) = "VT_I4", "getVT(CLng(""-1"")) = " & getVT(CLng("-1")))
+If isEnglishLang Then
+    Call ok(CLng("-0.5") = 0, "CLng(""-0.5"") = " & CLng("-0.5"))
+    Call ok(getVT(CLng("-0.5")) = "VT_I4", "getVT(CLng(""-0.5"")) = " & getVT(CLng("-0.5")))
+End If
+Call testCLngError("", 13, 13)
+Call testCLngError("TRUE", 13, 13)
+Call testCLngError("FALSE", 13, 13)
+Call testCLngError("#TRue#", 13, 13)
+Call testCLngError("#fAlSE#", 13, 13)
+Call testCLngError(1, 0, 458)
+Call ok(CLng(True) = -1, "CLng(True) = " & CLng(True))
+Call ok(getVT(CLng(True)) = "VT_I4", "getVT(CLng(True)) = " & getVT(CLng(True)))
+Call ok(CLng(False) = 0, "CLng(False) = " & CLng(False))
+Call ok(getVT(CLng(False)) = "VT_I4", "getVT(CLng(False)) = " & getVT(CLng(False)))
+MyObject.myval = 1
+Call ok(CLng(MyObject) = 1, "CLng(MyObject) = " & CLng(MyObject))
+Call ok(getVT(CLng(MyObject)) = "VT_I4", "getVT(CLng(MyObject)) = " & getVT(CLng(MyObject)))
+MyObject.myval = 0
+Call ok(CLng(MyObject) = 0, "CLng(MyObject) = " & CLng(MyObject))
+Call ok(getVT(CLng(MyObject)) = "VT_I4", "getVT(CLng(MyObject)) = " & getVT(CLng(MyObject)))
+
+Sub testCIntError(strings, error_num1, error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = CInt(strings)
+    Call ok(Err.number = error_num1, "Err.number = " & Err.number)
+
+    Call Err.clear()
+    Call CInt(strings)
+    Call ok(Err.number = error_num2, "Err.number = " & Err.number)
+End Sub
+
+Call ok(CInt(Empty) = 0, "CInt(Empty) = " & CInt(Empty))
+Call ok(getVT(CInt(Empty)) = "VT_I2", "getVT(CInt(Empty)) = " & getVT(CInt(Empty)))
+Call ok(CInt(CByte(0)) = 0, "CInt(CByte(0)) = " & CInt(CByte(0)))
+Call ok(getVT(CInt(CByte(0))) = "VT_I2", "getVT(CInt(CByte(0))) = " & getVT(CInt(CByte(0))))
+Call ok(CInt(CCur(0)) = 0, "CInt(CCur(0)) = " & CInt(CCur(0)))
+Call ok(getVT(CInt(CCur(0))) = "VT_I2", "getVT(CInt(CCur(0))) = " & getVT(CInt(CCur(0))))
+Call ok(CInt(0.49) = 0, "CInt(0.49) = " & CInt(0.49))
+Call ok(getVT(CInt(0.49)) = "VT_I2", "getVT(CInt(0.49)) = " & getVT(CInt(0.49)))
+Call ok(CInt(0.5) = 0, "CInt(0.5) = " & CInt(0.5))
+Call ok(getVT(CInt(0.5)) = "VT_I2", "getVT(CInt(0.5)) = " & getVT(CInt(0.5)))
+Call ok(CInt(0.51) = 1, "CInt(0.51) = " & CInt(0.51))
+Call ok(getVT(CInt(0.51)) = "VT_I2", "getVT(CInt(0.51)) = " & getVT(CInt(0.51)))
+Call ok(CInt(1.49) = 1, "CInt(0.49) = " & CInt(0.49))
+Call ok(getVT(CInt(0.49)) = "VT_I2", "getVT(CInt(0.49)) = " & getVT(CInt(0.49)))
+Call ok(CInt(1.5) = 2, "CInt(1.5) = " & CInt(1.5))
+Call ok(getVT(CInt(1.5)) = "VT_I2", "getVT(CInt(1.5)) = " & getVT(CInt(1.5)))
+Call ok(CInt(1.51) = 2, "CInt(1.51) = " & CInt(1.51))
+Call ok(getVT(CInt(1.51)) = "VT_I2", "getVT(CInt(1.51)) = " & getVT(CInt(1.51)))
+Call ok(CInt("-1") = -1, "CInt(""-1"") = " & CInt("-1"))
+Call ok(getVT(CInt("-1")) = "VT_I2", "getVT(CInt(""-1"")) = " & getVT(CInt("-1")))
+If isEnglishLang Then
+    Call ok(CInt("-0.5") = 0, "CInt(""-0.5"") = " & CInt("-0.5"))
+    Call ok(getVT(CInt("-0.5")) = "VT_I2", "getVT(CInt(""-0.5"")) = " & getVT(CInt("-0.5")))
+End If
+Call testCIntError("", 13, 13)
+Call testCIntError("-1", 0, 458)
+Call testCIntError("TRUE", 13, 13)
+Call testCIntError("FALSE", 13, 13)
+Call testCIntError("#TRue#", 13, 13)
+Call testCIntError("#fAlSE#", 13, 13)
+Call testCIntError(1, 0, 458)
+Call testCIntError(32767.49, 0, 458)
+Call testCIntError(32767.5, 6, 6)
+Call testCIntError(-32768.5, 0, 458)
+Call testCIntError(-32768.51, 6, 6)
+Call ok(CInt(True) = -1, "CInt(True) = " & CInt(True))
+Call ok(getVT(CInt(True)) = "VT_I2", "getVT(CInt(True)) = " & getVT(CInt(True)))
+Call ok(CInt(False) = 0, "CInt(False) = " & CInt(False))
+Call ok(getVT(CInt(False)) = "VT_I2", "getVT(CInt(False)) = " & getVT(CInt(False)))
+MyObject.myval = 2.5
+Call ok(CInt(MyObject) = 2, "CInt(MyObject) = " & CInt(MyObject))
+Call ok(getVT(CInt(MyObject)) = "VT_I2", "getVT(CInt(MyObject)) = " & getVT(CInt(MyObject)))
+MyObject.myval = 1.5
+Call ok(CInt(MyObject) = 2, "CInt(MyObject) = " & CInt(MyObject))
+Call ok(getVT(CInt(MyObject)) = "VT_I2", "getVT(CInt(MyObject)) = " & getVT(CInt(MyObject)))
+
+Sub testCSngError(strings, error_num1, error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = CSng(strings)
+    Call ok(Err.number = error_num1, "Err.number = " & Err.number)
+
+    Call Err.clear()
+    Call CSng(strings)
+    Call ok(Err.number = error_num2, "Err.number = " & Err.number)
+End Sub
+
+Call ok(CSng(Empty) = 0, "CSng(Empty) = " & CSng(Empty))
+Call ok(getVT(CSng(Empty)) = "VT_R4", "getVT(CSng(Empty)) = " & getVT(CSng(Empty)))
+Call ok(CSng(CByte(0)) = 0, "CSng(CByte(0)) = " & CSng(CByte(0)))
+Call ok(getVT(CSng(CCur(0))) = "VT_R4", "getVT(CSng(CCur(0))) = " & getVT(CSng(CCur(0))))
+Call ok(CSng(CCur(0)) = 0, "CSng(CCur(0)) = " & CSng(CCur(0)))
+Call ok(getVT(CSng(CCur(0))) = "VT_R4", "getVT(CSng(CCur(0))) = " & getVT(CSng(CCur(0))))
+Call ok(CSng(0) = 0, "CSng(0) = " & CSng(0))
+Call ok(getVT(CSng(0)) = "VT_R4", "getVT(CSng(0)) = " & getVT(CSng(0)))
+Call ok(CSng(32768) = 32768, "CSng(32768) = " & CSng(32768))
+Call ok(getVT(CSng(32768)) = "VT_R4", "getVT(CSng(32768)) = " & getVT(CSng(32768)))
+Call ok(CSng(0.001 * 0.001) = 0.000001, "CSng(0.001 * 0.001) = " & CSng(0.001 * 0.001))
+Call ok(getVT(CSng(0.001 * 0.001)) = "VT_R4", "getVT(CSng(0.001 * 0.001)) = " & getVT(CSng(0.001 * 0.001)))
+Call ok(CSng("-1") = -1, "CSng(""-1"") = " & CSng("-1"))
+Call ok(getVT(CSng("-1")) = "VT_R4", "getVT(CSng(""-1"")) = " & getVT(CSng("-1")))
+If isEnglishLang Then
+    Call ok(CSng("-0.5") = -0.5, "CSng(""-0.5"") = " & CSng("-0.5"))
+    Call ok(getVT(CSng("-0.5")) = "VT_R4", "getVT(CSng(""-0.5"")) = " & getVT(CSng("-0.5")))
+End If
+Call testCSngError("", 13, 13)
+Call testCSngError("TRUE", 13, 13)
+Call testCSngError("FALSE", 13, 13)
+Call testCSngError("#TRue#", 13, 13)
+Call testCSngError("#fAlSE#", 13, 13)
+Call testCSngError(1, 0, 458)
+Call ok(CSng(True) = -1, "CSng(True) = " & CSng(True))
+Call ok(getVT(CSng(True)) = "VT_R4", "getVT(CSng(True)) = " & getVT(CSng(True)))
+Call ok(CSng(False) = 0, "CSng(False) = " & CSng(False))
+Call ok(getVT(CSng(False)) = "VT_R4", "getVT(CSng(False)) = " & getVT(CSng(False)))
+MyObject.myval = 0.1
+Call ok(CSng(MyObject) = 0.1, "CSng(MyObject) = " & CSng(MyObject))
+Call ok(getVT(CSng(MyObject)) = "VT_R4", "getVT(CSng(MyObject)) = " & getVT(CSng(MyObject)))
+MyObject.myval = 0
+Call ok(CSng(MyObject) = 0, "CSng(MyObject) = " & CSng(MyObject))
+Call ok(getVT(CSng(MyObject)) = "VT_R4", "getVT(CSng(MyObject)) = " & getVT(CSng(MyObject)))
+
+Call ok(TypeName(Empty) = "Empty", "TypeName(MyEmpty) = " & TypeName(Empty))
+Call ok(getVT(TypeName(Empty)) = "VT_BSTR", "getVT(TypeName(Empty)) = " & getVT(TypeName(Empty)))
+Call ok(TypeName(Null) = "Null", "TypeName(Null) = " & TypeName(Null))
+Call ok(getVT(TypeName(Null)) = "VT_BSTR", "getVT(TypeName(Null)) = " & getVT(TypeName(Null)))
+Call ok(TypeName(CByte(255)) = "Byte", "TypeName(CByte(255)) = " & TypeName(CByte(255)))
+Call ok(getVT(TypeName(CByte(255))) = "VT_BSTR", "getVT(TypeName(CByte(255))) = " & getVT(TypeName(CByte(255))))
+Call ok(TypeName(255) = "Integer", "TypeName(255) = " & TypeName(255))
+Call ok(getVT(TypeName(255)) = "VT_BSTR", "getVT(TypeName(255)) = " & getVT(TypeName(255)))
+Call ok(TypeName(32768) = "Long", "TypeName(32768) = " & TypeName(32768))
+Call ok(getVT(TypeName(32768)) = "VT_BSTR", "getVT(TypeName(32768)) = " & getVT(TypeName(32768)))
+Call ok(TypeName(CSng(0.5)) = "Single", "TypeName(CSng(0.5)) = " & TypeName(CSng(0.5)))
+Call ok(getVT(TypeName(CSng(0.5))) = "VT_BSTR", "getVT(TypeName(CSng(0.5))) = " & getVT(TypeName(CSng(0.5))))
+Call ok(TypeName(-0.5) = "Double", "TypeName(-0.5) = " & TypeName(-0.5))
+Call ok(getVT(TypeName(-0.5)) = "VT_BSTR", "getVT(TypeName(-0.5)) = " & getVT(TypeName(-0.5)))
+Call ok(TypeName(CCur(0.5)) = "Currency", "TypeName(CCur(0.5)) = " & TypeName(CCur(0.5)))
+Call ok(getVT(TypeName(CCur(0.5))) = "VT_BSTR", "getVT(TypeName(CCur(0.5))) = " & getVT(TypeName(CCur(0.5))))
+Call ok(TypeName(CStr(0.5)) = "String", "TypeName(CStr(0.5)) = " & TypeName(CStr(0.5)))
+Call ok(getVT(TypeName(CStr(0.5))) = "VT_BSTR", "getVT(TypeName(CStr(0.5))) = " & getVT(TypeName(CStr(0.5))))
+Call ok(TypeName(True) = "Boolean", "TypeName(True) = " & TypeName(True))
+Call ok(getVT(TypeName(True)) = "VT_BSTR", "getVT(TypeName(True)) = " & getVT(TypeName(True)))
+
+Call ok(VarType(Empty) = vbEmpty, "VarType(Empty) = " & VarType(Empty))
+Call ok(getVT(VarType(Empty)) = "VT_I2", "getVT(VarType(Empty)) = " & getVT(VarType(Empty)))
+Call ok(VarType(Null) = vbNull, "VarType(Null) = " & VarType(Null))
+Call ok(getVT(VarType(Null)) = "VT_I2", "getVT(VarType(Null)) = " & getVT(VarType(Null)))
+Call ok(VarType(255) = vbInteger, "VarType(255) = " & VarType(255))
+Call ok(getVT(VarType(255)) = "VT_I2", "getVT(VarType(255)) = " & getVT(VarType(255)))
+Call ok(VarType(32768) = vbLong, "VarType(32768) = " & VarType(32768))
+Call ok(getVT(VarType(32768)) = "VT_I2", "getVT(VarType(32768)) = " & getVT(VarType(32768)))
+Call ok(VarType(CSng(0.5)) = vbSingle, "VarType(CSng(0.5)) = " & VarType(CSng(0.5)))
+Call ok(getVT(VarType(CSng(0.5))) = "VT_I2", "getVT(VarType(CSng(0.5))) = " & getVT(VarType(CSng(0.5))))
+Call ok(VarType(-0.5) = vbDouble, "VarType(-0.5) = " & VarType(-0.5))
+Call ok(getVT(VarType(-0.5)) = "VT_I2", "getVT(VarType(-0.5)) = " & getVT(VarType(-0.5)))
+Call ok(VarType(CCur(0.5)) = vbCurrency, "VarType(CCur(0.5)) = " & VarType(CCur(0.5)))
+Call ok(getVT(VarType(CCur(0.5))) = "VT_I2", "getVT(VarType(CCur(0.5))) = " & getVT(VarType(CCur(0.5))))
+Call ok(VarType(CStr(0.5)) = vbString, "VarType(CStr(0.5)) = " & VarType(CStr(0.5)))
+Call ok(getVT(VarType(CStr(0.5))) = "VT_I2", "getVT(VarType(CStr(0.5))) = " & getVT(VarType(CStr(0.5))))
+Call ok(VarType(CBool(0.5)) = vbBoolean, "VarType(CBool(0.5)) = " & VarType(CBool(0.5)))
+Call ok(getVT(VarType(CBool(0.5))) = "VT_I2", "getVT(VarType(CBool(0.5))) = " & getVT(VarType(CBool(0.5))))
+Call ok(VarType(CByte(255)) = vbByte, "VarType(CByte(255)) = " & VarType(CByte(255)))
+Call ok(getVT(VarType(CByte(255))) = "VT_I2", "getVT(VarType(CByte(255))) = " & getVT(VarType(CByte(255))))
+
+Call ok(Sgn(Empty) = 0, "Sgn(MyEmpty) = " & Sgn(Empty))
+Call ok(getVT(Sgn(Empty)) = "VT_I2", "getVT(Sgn(MyEmpty)) = " & getVT(Sgn(Empty)))
+Call ok(Sgn(0) = 0, "Sgn(0) = " & Sgn(0))
+Call ok(getVT(Sgn(0)) = "VT_I2", "getVT(Sgn(0)) = " & getVT(Sgn(0)))
+Call ok(Sgn(-32769) = -1, "Sgn(-32769) = " & Sgn(-32769))
+Call ok(getVT(Sgn(-32769)) = "VT_I2", "getVT(Sgn(-32769)) = " & getVT(Sgn(-32769)))
+Call ok(Sgn(CSng(-0.5)) = -1, "Sgn(CSng(-0.5)) = " & Sgn(CSng(-0.5)))
+Call ok(getVT(Sgn(CSng(-0.5))) = "VT_I2", "getVT(Sgn(CSng(-0.5))) = " & getVT(Sgn(CSng(-0.5))))
+Call ok(Sgn(0.5) = 1, "Sgn(0.5) = " & Sgn(0.5))
+Call ok(getVT(Sgn(0.5)) = "VT_I2", "getVT(Sgn(0.5)) = " & getVT(Sgn(0.5)))
+Call ok(Sgn(CCur(-1)) = -1, "Sgn(CCur(-1)) = " & Sgn(CCur(-1)))
+Call ok(getVT(Sgn(CCur(-1))) = "VT_I2", "getVT(Sgn(CCur(-1))) = " & getVT(Sgn(CCur(-1))))
+Call ok(Sgn(CStr(-1)) = -1, "Sgn(CStr(-1)) = " & Sgn(CStr(-1)))
+Call ok(getVT(Sgn(CStr(-1))) = "VT_I2", "getVT(Sgn(CStr(-1))) = " & getVT(Sgn(CStr(-1))))
+Call ok(Sgn(False) = 0, "Sgn(False) = " & Sgn(False))
+Call ok(getVT(Sgn(False)) = "VT_I2", "getVT(Sgn(False)) = " & getVT(Sgn(False)))
+Call ok(Sgn(True) = -1, "Sgn(True) = " & Sgn(True))
+Call ok(getVT(Sgn(True)) = "VT_I2", "getVT(Sgn(True)) = " & getVT(Sgn(True)))
+Call ok(Sgn(CByte(1)) = 1, "Sgn(CByte(1)) = " & Sgn(CByte(1)))
+Call ok(getVT(Sgn(CByte(1))) ="VT_I2", "getVT(Sgn(CByte(1))) = " & getVT(Sgn(CByte(1))))
+
+Sub testSgnError(strings, error_num)
+    on error resume next
+
+    Call Err.clear()
+    Call Sgn(strings)
+    Call ok(Err.number = error_num, "Err.number = " & Err.number)
+End Sub
+
+Call testSgnError(Null, 94)
+
+Call ok(Abs(Empty) = 0, "Abs(Empty) = " & Abs(Empty))
+Call ok(getVT(Abs(Empty)) = "VT_I2", "getVT(Abs(Empty)) = " & getVT(Abs(Empty)))
+Call ok(IsNull(Abs(Null)), "Is Abs(Null) not Null?")
+Call ok(getVT(Abs(Null)) = "VT_NULL", "getVT(Abs(Null)) = " & getVT(Abs(Null)))
+Call ok(Abs(0) = 0, "Abs(0) = " & Abs(0))
+Call ok(getVT(Abs(0)) = "VT_I2", "getVT(Abs(0)) = " & getVT(Abs(0)))
+Call ok(Abs(-32769) = 32769, "Abs(-32769) = " & Abs(-32769))
+Call ok(getVT(Abs(-32769)) = "VT_I4", "getVT(Abs(-32769)) = " & getVT(Abs(-32769)))
+Call ok(Abs(CSng(-0.5)) = 0.5, "Abs(CSng(-0.5)) = " & Abs(CSng(-0.5)))
+Call ok(getVT(Abs(CSng(-0.5))) = "VT_R4", "getVT(Abs(CSng(-0.5))) = " & getVT(Abs(CSng(-0.5))))
+Call ok(Abs(0.5) = 0.5, "Abs(0.5) = " & Abs(0.5))
+Call ok(getVT(Abs(0.5)) = "VT_R8", "getVT(Abs(0.5)) = " & getVT(Abs(0.5)))
+Call ok(Abs(CCur(-1)) = 1, "Abs(CCur(-1)) = " & Abs(CCur(-1)))
+Call ok(getVT(Abs(CCur(-1))) = "VT_CY", "getVT(Abs(CCur(-1))) = " & getVT(Abs(CCur(-1))))
+Call ok(Abs("-1") = 1, "Abs(""-1"") = " & Abs("-1"))
+Call ok(getVT(Abs("-1")) = "VT_R8", "getVT(Abs(""-1"")) = " & getVT(Abs("-1")))
+Call ok(Abs(False) = 0, "Abs(False) = " & Abs(False))
+Call ok(getVT(Abs(False)) = "VT_I2", "getVT(Abs(False)) = " & getVT(Abs(False)))
+Call ok(Abs(True) = 1, "Abs(True) = " & Abs(True))
+Call ok(getVT(Abs(True)) = "VT_I2", "getVT(Abs(True)) = " & getVT(Abs(True)))
+Call ok(Abs(CByte(1)) = 1, "Abs(CByte(1)) = " & Abs(CByte(1)))
+Call ok(getVT(Abs(CByte(1))) = "VT_UI1", "getVT(Abs(CByte(1))) = " & getVT(Abs(CByte(1))))
+
+Sub testAbsError(strings, error_num1, error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = Abs(strings)
+    Call ok(Err.number = error_num1, "Err.number1 = " & Err.number)
+
+    Call Err.clear()
+    Call Abs(strings)
+    Call ok(Err.number = error_num2, "Err.number2 = " & Err.number)
+End Sub
+
+Call testAbsError("strings", 13, 13)
+Call testAbsError(-4, 0, 0)
+
+Call ok(ScriptEngine = "VBScript", "Is scriptengine not VBScript?")
+Call ok(getVT(ScriptEngine) = "VT_BSTR", "getVT(ScriptEngine) = " & getVT(ScriptEngine))
+
+Call ok(getVT(ScriptEngineBuildVersion) = "VT_I4", "getVT(ScriptEngineBuildVersion) = " & getVT(ScriptEngineBuildVersion))
+
+Call ok(getVT(ScriptEngineMajorVersion) = "VT_I4", "getVT(ScriptEngineMajorVersion) = " & getVT(ScriptEngineMajorVersion))
+
+Call ok(getVT(ScriptEngineMinorVersion) = "VT_I4", "getVT(ScriptEngineMinorVersion) = " & getVT(ScriptEngineMinorVersion))
+
+Call ok(Fix(Empty) = 0, "Fix(Empty) = " & Fix(Empty))
+Call ok(getVT(Fix(Empty)) = "VT_I2", "getVT(Fix(Empty)) = " & getVT(Fix(Empty)))
+Call ok(Fix(CCur(-0.99)) = 0, "Fix(CCur(-0.99)) = " & Fix(CCur(-0.99)))
+Call ok(getVT(Fix(CCur(-0.99))) = "VT_CY", "getVT(Fix(CCur(-0.99))) = " & getVT(Fix(CCur(-0.99))))
+Call ok(Fix(1.99) = 1, "Fix(1.99) = " & Fix(1.99))
+Call ok(getVT(Fix(1.99)) = "VT_R8", "getVT(Fix(1.99)) = " & getVT(Fix(1.99)))
+Call ok(Fix(-1.99) = -1, "Fix(-1.99) = " & Fix(-1.99))
+Call ok(getVT(Fix(-1.99)) = "VT_R8", "getVT(Fix(-1.99)) = " & getVT(Fix(-1.99)))
+If isEnglishLang Then
+    Call ok(Fix("1.99") = 1, "Fix(""1.99"") = " & Fix("1.99"))
+    Call ok(getVT(Fix("1.99")) = "VT_R8", "getVT(Fix(""1.99"")) = " & getVT(Fix("1.99")))
+    Call ok(Fix("-1.99") = -1, "Fix(""-1.99"") = " & Fix("-1.99"))
+    Call ok(getVT(Fix("-1.99")) = "VT_R8", "getVT(Fix(""-1.99"")) = " & getVT(Fix("-1.99")))
+End If
+Call ok(Fix(True) = -1, "Fix(True) = " & Fix(True))
+Call ok(getVT(Fix(True)) = "VT_I2", "getVT(Fix(True)) = " & getVT(Fix(True)))
+Call ok(Fix(False) = 0, "Fix(False) = " & Fix(False))
+Call ok(getVT(Fix(False)) = "VT_I2", "getVT(Fix(False)) = " & getVT(Fix(False)))
+MyObject.myval = 2.5
+Call ok(Fix(MyObject) = 2, "Fix(MyObject) = " & Fix(MyObject))
+Call ok(getVT(Fix(MyObject)) = "VT_R8", "getVT(Fix(MyObject)) = " & getVT(Fix(MyObject)))
+MyObject.myval = -2.5
+Call ok(Fix(MyObject) = -2, "Fix(MyObject) = " & Fix(MyObject))
+Call ok(getVT(Fix(MyObject)) = "VT_R8", "getVT(Fix(MyObject)) = " & getVT(Fix(MyObject)))
+
+Call ok(Int(Empty) = 0, "Int(Empty) = " & Int(Empty))
+Call ok(getVT(Int(Empty)) = "VT_I2", "getVT(Int(Empty)) = " & getVT(Int(Empty)))
+Call ok(Int(CCur(-0.99)) = -1, "Int(CCur(-0.99)) = " & Int(CCur(-0.99)))
+Call ok(getVT(Int(CCur(-0.99))) = "VT_CY", "getVT(Int(CCur(-0.99))) = " & getVT(Int(CCur(-0.99))))
+Call ok(Int(1.99) = 1, "Int(1.99) = " & Int(1.99))
+Call ok(getVT(Int(1.99)) = "VT_R8", "getVT(Int(1.99)) = " & getVT(Int(1.99)))
+Call ok(Int(-1.99) = -2, "Int(-1.99) = " & Int(-1.99))
+Call ok(getVT(Int(-1.99)) = "VT_R8", "getVT(Int(-1.99)) = " & getVT(Int(-1.99)))
+If isEnglishLang Then
+    Call ok(Int("1.99") = 1, "Int(""1.99"") = " & Int("1.99"))
+    Call ok(getVT(Int("1.99")) = "VT_R8", "getVT(Int(""1.99"")) = " & getVT(Int("1.99")))
+    Call ok(Int("-1.99") = -2, "Int(""-1.99"") = " & Int("-1.99"))
+    Call ok(getVT(Int("-1.99")) = "VT_R8", "getVT(Int(""-1.99"")) = " & getVT(Int("-1.99")))
+End If
+Call ok(Int(True) = -1, "Int(True) = " & Int(True))
+Call ok(getVT(Int(True)) = "VT_I2", "getVT(Int(True)) = " & getVT(Int(True)))
+Call ok(Int(False) = 0, "Int(False) = " & Int(False))
+Call ok(getVT(Int(False)) = "VT_I2", "getVT(Int(False)) = " & getVT(Int(False)))
+MyObject.myval = 2.5
+Call ok(Int(MyObject) = 2, "Int(MyObject) = " & Int(MyObject))
+Call ok(getVT(Int(MyObject)) = "VT_R8", "getVT(Int(MyObject)) = " & getVT(Int(MyObject)))
+MyObject.myval = -2.5
+Call ok(Int(MyObject) = -3, "Int(MyObject) = " & Int(MyObject))
+Call ok(getVT(Int(MyObject)) = "VT_R8", "getVT(Int(MyObject)) = " & getVT(Int(MyObject)))
+
+Sub testSqrError(strings, error_num1, error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = Sqr(strings)
+    Call ok(Err.number = error_num1, "Err.number1 = " & Err.number)
+
+    Call Err.clear()
+    Call Sqr(strings)
+    Call ok(Err.number = error_num2, "Err.number2 = " & Err.number)
+End Sub
+
+Call testSqrError(-2, 5, 5)
+Call testSqrError(True, 5, 5)
+
+Call ok(Sqr(Empty) = 0, "Sqr(Empty) = " & Sqr(Empty))
+Call ok(getVT(Sqr(Empty)) = "VT_R8", "getVT(Sqr(Empty)) = " & getVT(Sqr(Empty)))
+Call ok(Sqr(0) = 0, "Sqr(0) = " & Sqr(0))
+Call ok(getVT(Sqr(0)) = "VT_R8", "getVT(Sqr(0)) = " & getVT(Sqr(0)))
+Call ok(Sqr(1) = 1, "Sqr(1) = " & Sqr(1))
+Call ok(getVT(Sqr(1)) = "VT_R8", "getVT(Sqr(1)) = " & getVT(Sqr(1)))
+Call ok(Sqr(CSng(121)) = 11, "Sqr(CSng(121)) = " & Sqr(CSng(121)))
+Call ok(getVT(Sqr(CSng(121))) = "VT_R8", "getVT(Sqr(CSng(121))) = " & getVT(Sqr(CSng(121))))
+Call ok(Sqr(36100) = 190, "Sqr(36100) = " & Sqr(36100))
+Call ok(getVT(Sqr(36100)) = "VT_R8", "getVT(Sqr(36100)) = " & getVT(Sqr(36100)))
+Call ok(Sqr(CCur(0.0625)) = 0.25, "Sqr(CCur(0.0625)) = " & Sqr(CCur(0.0625)))
+Call ok(getVT(Sqr(CCur(0.0625))) = "VT_R8", "getVT(Sqr(CCur(0.0625))) = " & getVT(Sqr(CCur(0.0625))))
+Call ok(Sqr("100000000") = 10000, "Sqr(""100000000"") = " & Sqr("100000000"))
+Call ok(getVT(Sqr("100000000")) = "VT_R8", "getVT(Sqr(""100000000"")) = " & getVT(Sqr("100000000")))
+Call ok(Sqr(False) = 0, "Sqr(False) = " & Sqr(False))
+Call ok(getVT(Sqr(False)) = "VT_R8", "getVT(Sqr(False)) = " & getVT(Sqr(False)))
+Call ok(Sqr(CByte(225)) = 15, "Sqr(CByte(225)) = " & Sqr(CByte(225)))
+Call ok(getVT(Sqr(CByte(225))) = "VT_R8", "getVT(Sqr(CByte(225))) = " & getVT(Sqr(CByte(225))))
+
+Function Approch(func, res)
+    If Abs(func - res) < 0.001 Then
+        Approch = True
+    Else
+        Approch = False
+    End If
+End Function
+
+Const PI = 3.1415926
+
+Call ok(Approch(Cos(Empty), 1), "Cos(Empty) = " & Cos(Empty))
+Call ok(getVT(Cos(Empty)) = "VT_R8", "getVT(Cos(Empty)) = " & getVT(Cos(Empty)))
+Call ok(Approch(Cos(PI / 6), Sqr(3) / 2), "Cos(PI / 6) = " & Cos(PI / 6))
+Call ok(getVT(Cos(PI / 6)) = "VT_R8", "getVT(Cos(PI / 6)) = " & getVT(Cos(PI / 6)))
+Call ok(Approch(Cos(CCur(PI / 4)), Sqr(2) / 2), "Cos(CCur(PI / 4)) = " & Cos(CCur(PI / 4)))
+Call ok(getVT(Cos(CCur(PI / 4))) = "VT_R8", "getVT(Cos(CCur(PI / 4))) = " & getVT(Cos(CCur(PI / 4))))
+Call ok(Approch(Cos(CSng(PI / 3)), 1 / 2), "Cos(CSng(PI / 3)) = " & Cos(CSng(PI / 3)))
+Call ok(getVT(Cos(CSng(PI / 3))) = "VT_R8", "getVT(Cos(CSng(PI))) = " & getVT(Cos(CSng(PI))))
+Call ok(Approch(Cos(PI / 2), 0), "Cos(0) = " & Cos(PI / 2))
+Call ok(getVT(Cos(PI / 2)) = "VT_R8", "getVT(Cos(PI / 2)) = " & getVT(Cos(PI / 2)))
+Call ok(Approch(Cos(PI), -1), "Cos(PI) = " & Cos(PI))
+Call ok(getVT(Cos(PI)) = "VT_R8", "getVT(Cos(PI)) = " & getVT(Cos(PI)))
+Call ok(Approch(Cos(5 * PI / 4), -Sqr(2) / 2), "Cos(5 * PI / 4) = " & Cos(5 * PI / 4))
+Call ok(getVT(Cos(5 * PI / 4)) = "VT_R8", "getVT(Cos(5 * PI / 4)) = " & getVT(Cos(5 * PI / 4)))
+Call ok(Approch(Cos(3 * PI / 2), 0), "Cos(3 * PI / 2) = " & Cos(3 * PI / 2))
+Call ok(getVT(Cos(3 * PI / 2)) = "VT_R8", "getVT(Cos(3 * PI / 2)) = " & getVT(Cos(3 * PI / 2)))
+Call ok(Approch(Cos(2 * PI), 1), "Cos(2 * PI) = " & Cos(2 * PI))
+Call ok(getVT(Cos(2 * PI)) = "VT_R8", "getVT(Cos(2 * PI)) = " & getVT(Cos(2 * PI)))
+Call ok(Approch(Cos("-32768"), 0.3729), "Cos(""-32768"") = " & Cos("-32768"))
+Call ok(getVT(Cos("-32768")) = "VT_R8", "getVT(Cos(""-32768"")) = " & getVT(Cos("-32768")))
+Call ok(Approch(Cos(False), 1), "Cos(False) = " & Cos(False))
+Call ok(getVT(Cos(False)) = "VT_R8", "getVT(Cos(False)) = " & getVT(Cos(False)))
+Call ok(Approch(Cos(True), 0.5403), "Cos(True) = " & Cos(True))
+Call ok(getVT(Cos(True)) = "VT_R8", "getVT(Cos(True)) = " & getVT(Cos(True)))
+Call ok(Approch(Cos(CByte(255)), -0.8623), "Cos(CByte(255)) = " & Cos(CByte(255)))
+Call ok(getVT(Cos(CByte(255))) = "VT_R8", "getVT(Cos(CByte(255))) = " & getVT(Cos(CByte(255))))
+
+Call ok(Approch(Sin(Empty), 0), "Sin(Empty) = " & Sin(Empty))
+Call ok(getVT(Sin(Empty)) = "VT_R8", "getVT(Sin(Empty)) = " & getVT(Sin(Empty)))
+Call ok(Approch(Sin(PI / 6), 1 / 2), "Sin(PI / 6) = " & Sin(PI / 6))
+Call ok(getVT(Sin(PI / 6)) = "VT_R8", "getVT(Sin(PI / 6)) = " & getVT(Sin(PI / 6)))
+Call ok(Approch(Sin(CCur(PI / 4)), Sqr(2) / 2), "Sin(CCur(PI / 4)) = " & Sin(CCur(PI / 4)))
+Call ok(getVT(Sin(CCur(PI / 4))) = "VT_R8", "getVT(Sin(CCur(PI / 4))) = " & getVT(Sin(CCur(PI / 4))))
+Call ok(Approch(Sin(CSng(PI / 3)), Sqr(3) / 2), "Sin(CSng(PI / 3)) = " & Sin(CSng(PI / 3)))
+Call ok(getVT(Sin(CSng(PI / 3))) = "VT_R8", "getVT(Sin(CSng(PI))) = " & getVT(Sin(CSng(PI))))
+Call ok(Approch(Sin(PI / 2), 1), "Sin(0) = " & Sin(PI / 2))
+Call ok(getVT(Sin(PI / 2)) = "VT_R8", "getVT(Sin(PI / 2)) = " & getVT(Sin(PI / 2)))
+Call ok(Approch(Sin(PI), 0), "Sin(PI) = " & Sin(PI))
+Call ok(getVT(Sin(PI)) = "VT_R8", "getVT(Sin(PI)) = " & getVT(Sin(PI)))
+Call ok(Approch(Sin(5 * PI / 4), -Sqr(2) / 2), "Sin(5 * PI / 4) = " & Sin(5 * PI / 4))
+Call ok(getVT(Sin(5 * PI / 4)) = "VT_R8", "getVT(Sin(5 * PI / 4)) = " & getVT(Sin(5 * PI / 4)))
+Call ok(Approch(Sin(3 * PI / 2), -1), "Sin(3 * PI / 2) = " & Sin(3 * PI / 2))
+Call ok(getVT(Sin(3 * PI / 2)) = "VT_R8", "getVT(Sin(3 * PI / 2)) = " & getVT(Sin(3 * PI / 2)))
+Call ok(Approch(Sin(2 * PI), 0), "Sin(2 * PI) = " & Sin(2 * PI))
+Call ok(getVT(Sin(2 * PI)) = "VT_R8", "getVT(Sin(2 * PI)) = " & getVT(Sin(2 * PI)))
+Call ok(Approch(Sin("-32768"), -0.9278), "Sin(""-32768"") = " & Sin("-32768"))
+Call ok(getVT(Sin("-32768")) = "VT_R8", "getVT(Sin(""-32768"")) = " & getVT(Sin("-32768")))
+Call ok(Approch(Sin(False), 0), "Sin(False) = " & Sin(False))
+Call ok(getVT(Sin(False)) = "VT_R8", "getVT(Sin(False)) = " & getVT(Sin(False)))
+Call ok(Approch(Sin(True), -0.84147), "Sin(True) = " & Sin(True))
+Call ok(getVT(Sin(True)) = "VT_R8", "getVT(Sin(True)) = " & getVT(Sin(True)))
+Call ok(Approch(Sin(CByte(255)), -0.5063), "Sin(CByte(255)) = " & Sin(CByte(255)))
+Call ok(getVT(Sin(CByte(255))) = "VT_R8", "getVT(Sin(CByte(255))) = " & getVT(Sin(CByte(255))))
+
+Call ok(Approch(Tan(Empty), 0), "Tan(Empty) = " & Tan(Empty))
+Call ok(getVT(Tan(Empty)) = "VT_R8", "getVT(Tan(Empty)) = " & getVT(Tan(Empty)))
+Call ok(Approch(Tan(PI / 6), Sqr(3) / 3), "Tan(PI / 6) = " & Tan(PI / 6))
+Call ok(getVT(Tan(PI / 6)) = "VT_R8", "getVT(Tan(PI / 6)) = " & getVT(Tan(PI / 6)))
+Call ok(Approch(Tan(CCur(PI / 4)), 1), "Tan(CCur(PI / 4)) = " & Tan(CCur(PI / 4)))
+Call ok(getVT(Tan(CCur(PI / 4))) = "VT_R8", "getVT(Tan(CCur(PI / 4))) = " & getVT(Tan(CCur(PI / 4))))
+Call ok(Approch(Tan(CSng(PI / 3)), Sqr(3)), "Tan(CSng(PI / 3)) = " & Tan(CSng(PI / 3)))
+Call ok(getVT(Tan(CSng(PI / 3))) = "VT_R8", "getVT(Tan(CSng(PI))) = " & getVT(Tan(CSng(PI))))
+Call ok(Approch(Tan(PI), 0), "Tan(PI) = " & Tan(PI))
+Call ok(getVT(Tan(PI)) = "VT_R8", "getVT(Tan(PI)) = " & getVT(Tan(PI)))
+Call ok(Approch(Tan(3 * PI / 4), -1), "Tan(3 * PI / 4) = " & Tan(3 * PI / 4))
+Call ok(getVT(Tan(3 * PI / 4)) = "VT_R8", "getVT(Tan(3 * PI / 4)) = " & getVT(Tan(3 * PI / 4)))
+Call ok(Approch(Tan(5 * PI / 4), 1), "Tan(5 * PI / 4) = " & Tan(5 * PI / 4))
+Call ok(getVT(Tan(5 * PI / 4)) = "VT_R8", "getVT(Tan(5 * PI / 4)) = " & getVT(Tan(5 * PI / 4)))
+Call ok(Approch(Tan(2 * PI), 0), "Tan(2 * PI) = " & Tan(2 * PI))
+Call ok(getVT(Tan(2 * PI)) = "VT_R8", "getVT(Tan(2 * PI)) = " & getVT(Tan(2 * PI)))
+Call ok(Approch(Tan("-32768"), -2.4879), "Tan(""-32768"") = " & Tan("-32768"))
+Call ok(getVT(Tan("-32768")) = "VT_R8", "getVT(Tan(""-32768"")) = " & getVT(Tan("-32768")))
+Call ok(Approch(Tan(False), 0), "Tan(False) = " & Tan(False))
+Call ok(getVT(Tan(False)) = "VT_R8", "getVT(Tan(False)) = " & getVT(Tan(False)))
+Call ok(Approch(Tan(True), -1.5574), "Tan(True) = " & Tan(True))
+Call ok(getVT(Tan(True)) = "VT_R8", "getVT(Tan(True)) = " & getVT(Tan(True)))
+Call ok(Approch(Tan(CByte(255)), 0.5872), "Tan(CByte(255)) = " & Tan(CByte(255)))
+Call ok(getVT(Tan(CByte(255))) = "VT_R8", "getVT(Tan(CByte(255))) = " & getVT(Tan(CByte(255))))
+
+Call ok(Approch(Atn(Empty), 0), "Atn(Empty) = " & Atn(Empty))
+Call ok(getVT(Atn(Empty)) = "VT_R8", "getVT(Atn(Empty)) = " & getVT(Atn(Empty)))
+Call ok(Approch(Atn(Sqr(3) / 3), PI / 6), "Atn(Sqr(3) / 3) = " & Atn(Sqr(3) / 3))
+Call ok(getVT(Atn(Sqr(3) / 3)) = "VT_R8", "getVT(Atn(Sqr(3) / 3)) = " & getVT(Atn(Sqr(3) / 3)))
+Call ok(Approch(Atn(CCur(1)), PI / 4), "Atn(CCur(1)) = " & Atn(CCur(1)))
+Call ok(getVT(Atn(CCur(1))) = "VT_R8", "getVT(Atn(CCur(1))) = " & getVT(Atn(CCur(1))))
+Call ok(Approch(Atn(CSng(Sqr(3))), PI / 3), "Atn(CSng(Sqr(3))) = " & Atn(CSng(Sqr(3))))
+Call ok(getVT(Atn(CSng(Sqr(3)))) = "VT_R8", "getVT(Atn(CSng(PI))) = " & getVT(Atn(CSng(PI))))
+Call ok(Approch(Atn(0), 0), "Atn(0) = " & Atn(0))
+Call ok(getVT(Atn(0)) = "VT_R8", "getVT(Atn(0)) = " & getVT(Atn(0)))
+Call ok(Approch(Atn(-1), -PI / 4), "Atn(-1) = " & Atn(-1))
+Call ok(getVT(Atn(-1)) = "VT_R8", "getVT(Atn(-1)) = " & getVT(Atn(-1)))
+Call ok(Approch(Atn("-32768"), -1.5707), "Atn(""-32768"") = " & Atn("-32768"))
+Call ok(getVT(Atn("-32768")) = "VT_R8", "getVT(Atn(""-32768"")) = " & getVT(Atn("-32768")))
+Call ok(Approch(Atn(False), 0), "Atn(False) = " & Atn(False))
+Call ok(getVT(Atn(False)) = "VT_R8", "getVT(Atn(False)) = " & getVT(Atn(False)))
+Call ok(Approch(Atn(True), -0.7853), "Atn(True) = " & Atn(True))
+Call ok(getVT(Atn(True)) = "VT_R8", "getVT(Atn(True)) = " & getVT(Atn(True)))
+Call ok(Approch(Atn(CByte(255)), 1.5668), "Atn(CByte(255)) = " & Atn(CByte(255)))
+Call ok(getVT(Atn(CByte(255))) = "VT_R8", "getVT(Atn(CByte(255))) = " & getVT(Atn(CByte(255))))
+
+Call ok(Approch(Exp(Empty), 1), "Exp(Empty) = " & Exp(Empty))
+Call ok(getVT(Exp(Empty)) = "VT_R8", "getVT(Exp(Empty)) = " & getVT(Exp(Empty)))
+Call ok(Approch(Exp(1), 2.7182), "Exp(1) = " & Exp(1))
+Call ok(getVT(Exp(1)) = "VT_R8", "getVT(Exp(1)) = " & getVT(Exp(1)))
+Call ok(Approch(Exp(CCur(-1)), 0.3678), "Exp(CCur(-1)) = " & Exp(CCur(-1)))
+Call ok(getVT(Exp(CCur(-1))) = "VT_R8", "getVT(Exp(CCur(-1))) = " & getVT(Exp(CCur(-1))))
+Call ok(Approch(Exp(CSng(0.5)), 1.6487), "Exp(CSng(0.5)) = " & Exp(CSng(0.5)))
+Call ok(getVT(Exp(CSng(0.5))) = "VT_R8", "getVT(Exp(CSng(PI))) = " & getVT(Exp(CSng(PI))))
+Call ok(Approch(Exp(-0.5), 0.6065), "Exp(-0.5) = " & Exp(-0.5))
+Call ok(getVT(Exp(-0.5)) = "VT_R8", "getVT(Exp(-0.5)) = " & getVT(Exp(-0.5)))
+Call ok(Approch(Exp("-2"), 0.1353), "Exp(""-2"") = " & Exp("-2"))
+Call ok(getVT(Exp("-2")) = "VT_R8", "getVT(Exp(""-2"")) = " & getVT(Exp("-2")))
+Call ok(Approch(Exp(False), 1), "Exp(False) = " & Exp(False))
+Call ok(getVT(Exp(False)) = "VT_R8", "getVT(Exp(False)) = " & getVT(Exp(False)))
+Call ok(Approch(Exp(True), 0.3678), "Exp(True) = " & Exp(True))
+Call ok(getVT(Exp(True)) = "VT_R8", "getVT(Exp(True)) = " & getVT(Exp(True)))
+Call ok(Approch(Exp(CByte(2)), 7.389), "Exp(CByte(2)) = " & Exp(CByte(2)))
+Call ok(getVT(Exp(CByte(2))) = "VT_R8", "getVT(Exp(CByte(2))) = " & getVT(Exp(CByte(2))))
+
+Sub testLogError(strings, error_num1, error_num2)
+    on error resume next
+    Dim x
+
+    Call Err.clear()
+    x = Log(strings)
+    Call ok(Err.number = error_num1, "Err.number1 = " & Err.number)
+
+    Call Err.clear()
+    Call Log(strings)
+    Call ok(Err.number = error_num2, "Err.number2 = " & Err.number)
+End Sub
+
+Call testLogError(0, 5, 5)
+Call testLogError(-2, 5, 5)
+Call testLogError(False, 5, 5)
+Call testLogError(True, 5, 5)
+Call ok(Approch(Log(1), 0), "Log(1) = " & Log(1))
+Call ok(getVT(Log(1)) = "VT_R8", "getVT(Log(1)) = " & getVT(Log(1)))
+Call ok(Approch(Log(CCur(0.5)), -0.6931), "Log(CCur(0.5)) = " & Log(CCur(0.5)))
+Call ok(getVT(Log(CCur(0.5))) = "VT_R8", "getVT(Log(CCur(0.5))) = " & getVT(Log(CCur(0.5))))
+Call ok(Approch(Log(CSng(2.7182)), 1), "Log(CSng(2.7182)) = " & Log(CSng(2.7182)))
+Call ok(getVT(Log(CSng(2.7182))) = "VT_R8", "getVT(Log(CSng(PI))) = " & getVT(Log(CSng(PI))))
+Call ok(Approch(Log(32768), 10.3972), "Log(32768) = " & Log(32768))
+Call ok(getVT(Log(32768)) = "VT_R8", "getVT(Log(32768)) = " & getVT(Log(32768)))
+Call ok(Approch(Log("10"), 2.3025), "Log(""10"") = " & Log("10"))
+Call ok(getVT(Log("10")) = "VT_R8", "getVT(Log(""10"")) = " & getVT(Log("10")))
+Call ok(Approch(Log(CByte(2)), 0.6931), "Log(CByte(2)) = " & Log(CByte(2)))
+Call ok(getVT(Log(CByte(2))) = "VT_R8", "getVT(Log(CByte(2))) = " & getVT(Log(CByte(2))))
+
+Call ok(getVT(Date) = "VT_DATE", "getVT(Date) = " & getVT(Date))
+Call ok(getVT(Time) = "VT_DATE", "getVT(Time) = " & getVT(Time))
+
 Call reportSuccess()

diff --git a/rostests/winetests/vbscript/error.vbs b/rostests/winetests/vbscript/error.vbs
index afe9da2..830344c 100644 (file)
--- a/rostests/winetests/vbscript/error.vbs
+++ b/rostests/winetests/vbscript/error.vbs
@@ -284,6 +284,20 @@ x = 0
 call callTestOnError(false)
 call ok(x = 1, "x = " & x)
 
+sub testOnErrorClear()
+    on error resume next
+    call ok(Err.Number = 0, "Err.Number = " & Err.Number)
+    throwInt(E_TESTERROR)
+    call ok(Err.Number = E_TESTERROR, "Err.Number = " & Err.Number)
+
+    on error goto 0
+    call ok(Err.Number = 0, "Err.Number = " & Err.Number)
+    x = "ok"
+end sub
+
+call testOnErrorClear()
+call ok(x = "ok", "testOnErrorClear failed")
+
 sub testForEachError()
     on error resume next
 

diff --git a/rostests/winetests/vbscript/lang.vbs b/rostests/winetests/vbscript/lang.vbs
index d3e8318..3ee445c 100644 (file)
--- a/rostests/winetests/vbscript/lang.vbs
+++ b/rostests/winetests/vbscript/lang.vbs
@@ -40,6 +40,12 @@ Call ok(010 = 10, "010 <> 10")
 Call ok(10. = 10, "10. <> 10")
 Call ok(&hffFFffFF& = -1, "&hffFFffFF& <> -1")
 Call ok(&hffFFffFF& = -1, "&hffFFffFF& <> -1")
+Call ok(34e5 = 3400000, "34e5 <> 3400000")
+Call ok(56.789e5 = 5678900, "56.789e5 = 5678900")
+Call ok(56.789e-2 = 0.56789, "56.789e-2 <> 0.56789")
+Call ok(1e-94938484 = 0, "1e-... <> 0")
+Call ok(34e0 = 34, "34e0 <> 34")
+Call ok(34E1 = 340, "34E0 <> 340")
 Call ok(--1 = 1, "--1 = " & --1)
 Call ok(-empty = 0, "-empty = " & (-empty))
 Call ok(true = -1, "! true = -1")
@@ -78,6 +84,9 @@ Call ok(getVT(&h10&) = "VT_I2", "getVT(&h10&) is not VT_I2")
 Call ok(getVT(&h10000&) = "VT_I4", "getVT(&h10000&) is not VT_I4")
 Call ok(getVT(&H10000&) = "VT_I4", "getVT(&H10000&) is not VT_I4")
 Call ok(getVT(&hffFFffFF&) = "VT_I2", "getVT(&hffFFffFF&) is not VT_I2")
+Call ok(getVT(1e2) = "VT_R8", "getVT(1e2) is not VT_R8")
+Call ok(getVT(1e0) = "VT_R8", "getVT(1e0) is not VT_R8")
+Call ok(getVT(0.1e2) = "VT_R8", "getVT(0.1e2) is not VT_R8")
 Call ok(getVT(1 & 100000) = "VT_BSTR", "getVT(1 & 100000) is not VT_BSTR")
 Call ok(getVT(-empty) = "VT_I2", "getVT(-empty) = " & getVT(-empty))
 Call ok(getVT(-null) = "VT_NULL", "getVT(-null) = " & getVT(-null))
@@ -187,6 +196,7 @@ Call ok(2*3 = 6, "2*3 = " & (2*3))
 Call ok(3/2 = 1.5, "3/2 = " & (3/2))
 Call ok(5\4/2 = 2, "5\4/2 = " & (5\2/1))
 Call ok(12/3\2 = 2, "12/3\2 = " & (12/3\2))
+Call ok(5/1000000 = 0.000005, "5/1000000 = " & (5/1000000))
 
 Call ok(2^3 = 8, "2^3 = " & (2^3))
 Call ok(2^3^2 = 64, "2^3^2 = " & (2^3^2))
@@ -849,6 +859,10 @@ Class TestClass
         Call ok(getVT(publicProp2) = "VT_I2*", "getVT(publicProp2) = " & getVT(publicProp2))
         Call ok(getVT(Me.publicProp2) = "VT_I2", "getVT(Me.publicProp2) = " & getVT(Me.publicProp2))
     End Sub
+
+    Property Get gsGetProp(x)
+        gsGetProp = x
+    End Property
 End Class
 
 Call testDisp(new testClass)
@@ -916,6 +930,29 @@ Call ok(funcCalled = "terminate", "funcCalled = " & funcCalled)
 Call (New testclass).publicSub()
 Call (New testclass).publicSub
 
+class PropTest
+    property get prop0()
+        prop0 = 1
+    end property
+
+    property get prop1(x)
+        prop1 = x+1
+    end property
+
+    property get prop2(x, y)
+        prop2 = x+y
+    end property
+end class
+
+set obj = new PropTest
+
+call ok(obj.prop0 = 1, "obj.prop0 = " & obj.prop0)
+call ok(obj.prop1(3) = 4, "obj.prop1(3) = " & obj.prop1(3))
+call ok(obj.prop2(3,4) = 7, "obj.prop2(3,4) = " & obj.prop2(3,4))
+call obj.prop0()
+call obj.prop1(2)
+call obj.prop2(3,4)
+
 x = "following ':' is correct syntax" :
 x = "following ':' is correct syntax" :: :
 :: x = "also correct syntax"

diff --git a/rostests/winetests/vbscript/run.c b/rostests/winetests/vbscript/run.c
index 3a130ed..e3d3308 100644 (file)
--- a/rostests/winetests/vbscript/run.c
+++ b/rostests/winetests/vbscript/run.c
@@ -94,6 +94,7 @@ DEFINE_EXPECT(testobj_propget_d);
 DEFINE_EXPECT(testobj_propget_i);
 DEFINE_EXPECT(testobj_propput_d);
 DEFINE_EXPECT(testobj_propput_i);
+DEFINE_EXPECT(testobj_value_i);
 DEFINE_EXPECT(global_propargput_d);
 DEFINE_EXPECT(global_propargput_i);
 DEFINE_EXPECT(global_propargput1_d);
@@ -174,8 +175,12 @@ static const char *vt2a(VARIANT *v)
         return "VT_I2";
     case VT_I4:
         return "VT_I4";
+    case VT_R4:
+        return "VT_R4";
     case VT_R8:
         return "VT_R8";
+    case VT_CY:
+        return "VT_CY";
     case VT_DATE:
         return "VT_DATE";
     case VT_BSTR:
@@ -188,6 +193,8 @@ static const char *vt2a(VARIANT *v)
         return "VT_ARRAY|VT_VARIANT";
     case VT_ARRAY|VT_BYREF|VT_VARIANT:
         return "VT_ARRAY|VT_BYREF|VT_VARIANT";
+    case VT_UI1:
+        return "VT_UI1";
     default:
         ok(0, "unknown vt %d\n", V_VT(v));
         return NULL;
@@ -251,7 +258,7 @@ static IServiceProvider caller_sp = { &ServiceProviderVtbl };
 
 static void test_disp(IDispatch *disp)
 {
-    DISPID id, public_prop_id, public_prop2_id, public_func_id, public_sub_id, defvalget_id;
+    DISPID id, public_prop_id, public_prop2_id, public_func_id, public_sub_id, defvalget_id, gs_getter_id;
     DISPID named_args[5] = {DISPID_PROPERTYPUT};
     VARIANT v, args[5];
     DISPPARAMS dp = {args, named_args};
@@ -314,6 +321,12 @@ static void test_disp(IDispatch *disp)
     ok(V_VT(&v) == VT_BOOL, "V_VT(v) = %d\n", V_VT(&v));
     ok(V_BOOL(&v), "V_BOOL(v) = %x\n", V_BOOL(&v));
 
+    dp.cArgs = dp.cNamedArgs = 0;
+    hres = IDispatchEx_Invoke(dispex, public_prop_id, &IID_NULL, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
+    ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
+    ok(V_VT(&v) == VT_BOOL, "V_VT(v) = %d\n", V_VT(&v));
+    ok(V_BOOL(&v), "V_BOOL(v) = %x\n", V_BOOL(&v));
+
     dp.cArgs = dp.cNamedArgs = 0;
     hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
@@ -394,6 +407,12 @@ static void test_disp(IDispatch *disp)
     ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
     ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
 
+    dp.cArgs = dp.cNamedArgs = 0;
+    hres = IDispatchEx_Invoke(dispex, public_func_id, &IID_NULL, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
+    ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
+    ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
+    ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
+
     dp.cArgs = dp.cNamedArgs = 0;
     hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
@@ -438,6 +457,40 @@ static void test_disp(IDispatch *disp)
     ok(hres == S_OK, "GetDispID(publicProp) failed: %08x\n", hres);
     ok(id == public_prop_id, "id = %d, expected %d\n", id, public_prop_id);
 
+    str = a2bstr("gsGetProp");
+    hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &gs_getter_id);
+    SysFreeString(str);
+    ok(hres == S_OK, "GetDispID(publicFunction) failed: %08x\n", hres);
+    ok(gs_getter_id != -1, "gs_getter_id = -1\n");
+
+    V_VT(args) = VT_BOOL;
+    V_BOOL(args) = VARIANT_TRUE;
+    dp.cNamedArgs = 0;
+    dp.cArgs = 1;
+    V_VT(&v) = VT_I8;
+    hres = IDispatchEx_InvokeEx(dispex, gs_getter_id, 0, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
+    ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
+    ok(V_VT(&v) == VT_BOOL && V_BOOL(&v), "V_VT(v) = %d\n", V_VT(&v));
+
+    hres = IDispatchEx_InvokeEx(dispex, gs_getter_id, 0, DISPATCH_PROPERTYGET, &dp, NULL, &ei, NULL);
+    ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
+
+    V_VT(args) = VT_BOOL;
+    V_BOOL(args) = VARIANT_FALSE;
+    dp.cArgs = 1;
+    V_VT(&v) = VT_I8;
+    hres = IDispatchEx_InvokeEx(dispex, gs_getter_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
+    ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
+    ok(V_VT(&v) == VT_BOOL && !V_BOOL(&v), "V_VT(v) = %d\n", V_VT(&v));
+
+    V_VT(args) = VT_BOOL;
+    V_BOOL(args) = VARIANT_TRUE;
+    V_VT(&v) = VT_I8;
+    dp.cArgs = 1;
+    hres = IDispatchEx_InvokeEx(dispex, gs_getter_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
+    ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
+    ok(V_VT(&v) == VT_BOOL && V_BOOL(&v), "V_VT(v) = %d\n", V_VT(&v));
+
     IDispatchEx_Release(dispex);
 }
 
@@ -673,6 +726,29 @@ static HRESULT WINAPI testObj_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid,
         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 {
     switch(id) {
+    case DISPID_VALUE: {
+        VARIANT *arg;
+        int i;
+
+        CHECK_EXPECT(testobj_value_i);
+
+        ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
+        ok(pdp != NULL, "pdp == NULL\n");
+        ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
+        ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
+        ok(pvarRes != NULL, "pvarRes == NULL\n");
+        ok(pei != NULL, "pei == NULL\n");
+
+        for(i=0; i<pdp->cArgs; i++) {
+            arg = pdp->rgvarg+pdp->cArgs-i-1;
+            ok(V_VT(arg) == VT_I2, "V_VT(arg) = %d\n", V_VT(arg));
+            ok(V_I2(arg) == i+1, "V_I2(arg) = %d\n", V_I2(arg));
+        }
+
+        V_VT(pvarRes) = VT_I2;
+        V_I2(pvarRes) = pdp->cArgs;
+        return S_OK;
+    }
     case DISPID_TESTOBJ_PROPGET:
         CHECK_EXPECT(testobj_propget_i);
 
@@ -2008,6 +2084,14 @@ static void run_tests(void)
 
     strict_dispid_check = FALSE;
 
+    SET_EXPECT(testobj_value_i);
+    parse_script_a("dim n,o\n set o = testObj\n n = o(1,2)\n call ok(n=2, \"n = \" & n)\n");
+    CHECK_CALLED(testobj_value_i);
+
+    SET_EXPECT(testobj_value_i);
+    parse_script_a("dim n,o\n set o = testObj\n n = o\n call ok(n=0, \"n = \" & n)\n");
+    CHECK_CALLED(testobj_value_i);
+
     parse_script_a("Sub testsub\n"
                    "x = 1\n"
                    "Call ok(x = 1, \"x = \" & x)\n"