Menu
▾
▴
[Oorexx-svn] SF.net SVN: oorexx:[3217] test/trunk/ooRexx
|
From: <bi...@us...> - 2008-09-07 19:48:20
|
Revision: 3217
http://oorexx.svn.sourceforge.net/oorexx/?rev=3217&view=rev
Author: bigrixx
Date: 2008-09-07 19:48:29 +0000 (Sun, 07 Sep 2008)
Log Message:
-----------
major rxmath cleanup
Modified Paths:
--------------
test/trunk/ooRexx/base/class/String/subword.testGroup
test/trunk/ooRexx/extensions/rxmath/RxMath.testGroup
Modified: test/trunk/ooRexx/base/class/String/subword.testGroup
===================================================================
--- test/trunk/ooRexx/base/class/String/subword.testGroup 2008-09-07 19:48:02 UTC (rev 3216)
+++ test/trunk/ooRexx/base/class/String/subword.testGroup 2008-09-07 19:48:29 UTC (rev 3217)
@@ -100,7 +100,7 @@
if digits() == 9 then
self~assertSame('SUBWORD2', 'SUBWORD1 SUBWORD2'~subWord(2.000000004))
else
- self~assertSame('SUBWORD2', 'SUBWORD1 SUBWORD2'~subWord(2.00000000000000004))
+ self~assertSame('SUBWORD2', 'SUBWORD1 SUBWORD2'~subWord(2.000000000000000004))
::method 'test005'
self~assertSame('J', '4a'x~subWord(.zeros1))
Modified: test/trunk/ooRexx/extensions/rxmath/RxMath.testGroup
===================================================================
--- test/trunk/ooRexx/extensions/rxmath/RxMath.testGroup 2008-09-07 19:48:02 UTC (rev 3216)
+++ test/trunk/ooRexx/extensions/rxmath/RxMath.testGroup 2008-09-07 19:48:29 UTC (rev 3217)
@@ -127,17 +127,17 @@
1.732050807568877)
-- Test each possible value of precision
do i = 1 to 16
- self~assertEquals(sqrt_expected[i], RxCalcSqrt(3,i))
+ self~assertSame(sqrt_expected[i], RxCalcSqrt(3,i))
end
-- Test that default numeric digits' value is used if expression is not specified
expected = sqrt_expected[self~digits]
- self~assertEquals(expected, RxCalcSqrt(3))
+ self~assertSame(expected, RxCalcSqrt(3))
-- Test that manually set numeric digits' value is used if expression is not specified
numeric digits 5
expected = sqrt_expected[digits()]
- self~assertEquals(expected, RxCalcSqrt(3))
+ self~assertSame(expected, RxCalcSqrt(3))
::method 'test_RxCalcSqrtB'
-- Test syntax on precision value of 0
@@ -146,41 +146,43 @@
::method 'test_RxCalcSqrtC'
-- Test syntax on precision value > 16
- self~assertEquals(RxCalcSqrt(3, 16), RxCalcSqrt(3,17))
+ self~assertSame(RxCalcSqrt(3, 16), RxCalcSqrt(3,17))
::method 'test_RxCalcSqrtD'
-- Test syntax on no argument supplied
- self~expectSyntax('40.1')
+ self~expectSyntax('88.901')
rv = RxCalcSqrt()
::method 'test_RxCalcSqrtE'
-- Test syntax when numeric digits is > than max allowed by RxMath
numeric digits 20
- self~assertEquals(RxCalcSqrt(3, 16), RxCalcSqrt(3))
+ self~assertSame(RxCalcSqrt(3, 16), RxCalcSqrt(3))
::method 'test_RxCalcSqrtF'
-- Test significant digits when square root is a whole number
expected = 5
do i = 1 to 16
- self~assertEquals(expected, RxCalcSqrt(25,i))
+ self~assertSame(expected, RxCalcSqrt(25,i))
end
-------------------------------------------------------------------------------------------
-- This set of unitTests is brought to you by the Exponential function
::method 'test_RxCalcExpA'
-- Test default precision
- expected = 1.64872127
- self~assertEquals(expected, RxCalcExp(.5))
+ numeric digits 9
+ self~assertSame(1.64872127, RxCalcExp(.5))
+ numeric digits 16
+ self~assertSame(1.648721270700128, RxCalcExp(.5))
::method 'test_RxCalcExpB'
-- Test lowest precision
expected = 2
- self~assertEquals(expected, RxCalcExp(.5,1))
+ self~assertSame(expected, RxCalcExp(.5,1))
::method 'test_RxCalcExpC'
-- Test highest precision
expected = 1.648721270700128
- self~assertEquals(expected, RxCalcExp(.5,16))
+ self~assertSame(expected, RxCalcExp(.5,16))
::method 'testRxCalcExpD'
-- Test invalid low precision
@@ -189,34 +191,31 @@
::method 'testRxCalcExpE'
-- Test invalid high precision
- self~assertEquals(RxCalcExp(.5,16), RxCalcExp(.5,17))
+ self~assertSame(RxCalcExp(.5,16), RxCalcExp(.5,17))
::method 'testRxCalcExpF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcExp(.5,16), RxCalcExp(.5))
+ self~assertSame(RxCalcExp(.5,16), RxCalcExp(.5))
-::method 'testRxCalcExpG'
--- Test default precision not equals
- expected = 1.64872128
- self~assertNotEquals(expected, RxCalcExp(.5))
-
-------------------------------------------------------------------------------------------
-- This set of unitTests is brought to you by the Natural Logarithm (base e) function
::method 'test_RxCalcLogA'
-- Test default precision
- expected = 2.77258872
- self~assertEquals(expected, RxCalcLog(16))
+ numeric digits 9
+ self~assertSame(2.77258872, RxCalcLog(16))
+ numeric digits 18
+ self~assertSame(2.772588722239781, RxCalcLog(16))
::method 'test_RxCalcLogB'
-- Test lowest precision
expected = 3
- self~assertEquals(expected, RxCalcLog(16,1))
+ self~assertSame(expected, RxCalcLog(16,1))
::method 'test_RxCalcLogC'
-- Test highest precision
expected = 2.772588722239781
- self~assertEquals(expected, RxCalcLog(16,16))
+ self~assertSame(expected, RxCalcLog(16,16))
::method 'testRxCalcLogD'
-- Test invalid low precision
@@ -225,34 +224,31 @@
::method 'testRxCalcLogE'
-- Test invalid high precision
- self~assertEquals(RxCalcLog(16,16), RxCalcLog(16,17))
+ self~assertSame(RxCalcLog(16,16), RxCalcLog(16,17))
::method 'testRxCalcLogF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcLog(16,16), RxCalcLog(16))
+ self~assertSame(RxCalcLog(16,16), RxCalcLog(16))
-::method 'testRxCalcLogG'
--- Test default precision not equals
- expected = 2.77258871
- self~assertNotEquals(expected, RxCalcLog(16))
-
-------------------------------------------------------------------------------------------
-- This set of unitTests is brought to you by the Natural Logarithm (base 10) function
::method 'test_RxCalcLog10A'
-- Test default precision
- expected = 1.20411998
- self~assertEquals(expected, RxCalcLog10(16))
+ numeric digits 9
+ self~assertSame(1.20411998, RxCalcLog10(16))
+ numeric digits 18
+ self~assertSame(1.204119982655925, RxCalcLog10(16))
::method 'test_RxCalcLog10B'
-- Test lowest precision
expected = 1
- self~assertEquals(expected, RxCalcLog10(16,1))
+ self~assertSame(expected, RxCalcLog10(16,1))
::method 'test_RxCalcLog10C'
-- Test highest precision
expected = 1.204119982655925
- self~assertEquals(expected, RxCalcLog10(16,16))
+ self~assertSame(expected, RxCalcLog10(16,16))
::method 'testRxCalcLog10D'
-- Test invalid low precision
@@ -261,34 +257,31 @@
::method 'testRxCalcLog10E'
-- Test invalid high precision
- self~assertEquals(RxCalcLog10(16,16), RxCalcLog10(16,17))
+ self~assertSame(RxCalcLog10(16,16), RxCalcLog10(16,17))
::method 'testRxCalcLog10F'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcLog10(16,16), RxCalcLog10(16))
+ self~assertSame(RxCalcLog10(16,16), RxCalcLog10(16))
-::method 'testRxCalcLog10G'
--- Test default precision not equals
- expected = 1.20411997
- self~assertNotEquals(expected, RxCalcLog10(16))
-
-------------------------------------------------------------------------------------------
-- This set of unitTests is brought to you by the Hyperbolic Sine function
::method 'test_RxCalcSinhA'
-- Test default precision
- expected = 0.252612317
- self~assertEquals(expected, RxCalcSinh(.25))
+ numeric digits 9
+ self~assertSame(0.252612317, RxCalcSinh(.25))
+ numeric digits 18
+ self~assertSame(0.2526123168081683, RxCalcSinh(.25))
::method 'test_RxCalcSinhB'
-- Test lowest precision
expected = 0.3
- self~assertEquals(expected, RxCalcSinh(.25,1))
+ self~assertSame(expected, RxCalcSinh(.25,1))
::method 'test_RxCalcSinhC'
-- Test highest precision
expected = 0.2526123168081683
- self~assertEquals(expected, RxCalcSinh(.25,16))
+ self~assertSame(expected, RxCalcSinh(.25,16))
::method 'testRxCalcSinhD'
-- Test invalid low precision
@@ -297,34 +290,31 @@
::method 'testRxCalcSinhE'
-- Test invalid high precision
- self~assertEquals(RxCalcSinh(.25,16), RxCalcSinh(.25,17))
+ self~assertSame(RxCalcSinh(.25,16), RxCalcSinh(.25,17))
::method 'testRxCalcSinhF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcSinh(.25,16), RxCalcSinh(.25))
+ self~assertSame(RxCalcSinh(.25,16), RxCalcSinh(.25))
-::method 'testRxCalcSinhG'
--- Test default precision not equals
- expected = 0.252612318
- self~assertNotEquals(expected, RxCalcSinh(.25))
-
-------------------------------------------------------------------------------------------
-- This set of unitTests is brought to you by the Hyperbolic Cosine function
::method 'test_RxCalcCoshA'
-- Test default precision
- expected = 1.0314131
- self~assertEquals(expected, RxCalcCosh(.25))
+ numeric digits 9
+ self~assertSame(1.03141310, RxCalcCosh(.25))
+ numeric digits 18
+ self~assertSame(1.031413099879573, RxCalcCosh(.25))
::method 'test_RxCalcCoshB'
-- Test lowest precision
expected = 1
- self~assertEquals(expected, RxCalcCosh(.25,1))
+ self~assertSame(expected, RxCalcCosh(.25,1))
::method 'test_RxCalcCoshC'
-- Test highest precision
expected = 1.031413099879573
- self~assertEquals(expected, RxCalcCosh(.25,16))
+ self~assertSame(expected, RxCalcCosh(.25,16))
::method 'testRxCalcCoshD'
-- Test invalid low precision
@@ -333,34 +323,31 @@
::method 'testRxCalcCoshE'
-- Test invalid high precision, capped at 16
- self~assertEquals(RxCalcCosh(.25,16), RxCalcCosh(.25,17))
+ self~assertSame(RxCalcCosh(.25,16), RxCalcCosh(.25,17))
::method 'testRxCalcCoshF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcCosh(.25,16), RxCalcCosh(.25))
+ self~assertSame(RxCalcCosh(.25,16), RxCalcCosh(.25))
-::method 'testRxCalcCoshG'
--- Test default precision not equals
- expected = 1.0314130
- self~assertNotEquals(expected, RxCalcCosh(.25))
-
-------------------------------------------------------------------------------------------
-- This set of unitTests is brought to you by the Hyperbolic Tangent function
::method 'test_RxCalcTanhA'
-- Test default precision
- expected = 0.244918662
- self~assertEquals(expected, RxCalcTanh(.25))
+ numeric digits 9
+ self~assertSame(0.244918662, RxCalcTanh(.25))
+ numeric digits 18
+ self~assertSame(0.2449186624037091, RxCalcTanh(.25))
::method 'test_RxCalcTanhB'
-- Test lowest precision
expected = 0.2
- self~assertEquals(expected, RxCalcTanh(.25,1))
+ self~assertSame(expected, RxCalcTanh(.25,1))
::method 'test_RxCalcTanhC'
-- Test highest precision
expected = 0.2449186624037091
- self~assertEquals(expected, RxCalcTanh(.25,16))
+ self~assertSame(expected, RxCalcTanh(.25,16))
::method 'testRxCalcTanhD'
-- Test invalid low precision
@@ -369,34 +356,29 @@
::method 'testRxCalcTanhE'
-- Test invalid high precision
- self~assertEquals(RxCalcTanh(.25,16), RxCalcTanh(.25,17))
+ self~assertSame(RxCalcTanh(.25,16), RxCalcTanh(.25,17))
::method 'testRxCalcTanhF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcTanh(.25,16), RxCalcTanh(.25))
+ self~assertSame(RxCalcTanh(.25,16), RxCalcTanh(.25))
-::method 'testRxCalcTanhG'
--- Test default precision not equals
- expected = 0.244918661
- self~assertNotEquals(expected, RxCalcTanh(.25))
-
-------------------------------------------------------------------------------------------
-- This set of unitTests is brought to you by the Power function
::method 'test_RxCalcPowerA'
-- Test default precision
expected = 6.13**3
- self~assertEquals(expected, RxCalcPower(6.13,3))
+ self~assertSame(expected, RxCalcPower(6.13,3))
::method 'test_RxCalcPowerB'
-- Test lowest precision
- expected = 2e+002
- self~assertEquals(expected, RxCalcPower(6.13,3,1))
+ expected = 2E+2
+ self~assertSame(expected, RxCalcPower(6.13,3,1))
::method 'test_RxCalcPowerC'
-- Test highest precision
expected = 230.346397
- self~assertEquals(expected, RxCalcPower(6.13,3,16))
+ self~assertSame(expected, RxCalcPower(6.13,3,16))
::method 'testRxCalcPowerD'
-- Test invalid low precision
@@ -405,34 +387,31 @@
::method 'testRxCalcPowerE'
-- Test invalid high precision
- self~assertEquals(RxCalcPower(6.13,3,16), RxCalcPower(6.13,3,17))
+ self~assertSame(RxCalcPower(6.13,3,16), RxCalcPower(6.13,3,17))
::method 'testRxCalcPowerF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcPower(6.13,3,16), RxCalcPower(6.13,3))
+ self~assertSame(RxCalcPower(6.13,3,16), RxCalcPower(6.13,3))
-::method 'testRxCalcPowerG'
--- Test default precision not equals
- expected = 6.13**4
- self~assertNotEquals(expected, RxCalcPower(6.13,3))
-
-------------------------------------------------------------------------------------------
-- This set of unitTests is brought to you by the Sine Degrees function
::method 'test_RxCalcSinA'
-- Test default precision
- expected = 0.207911691
- self~assertEquals(expected, RxCalcSin(12))
+ numeric digits 9
+ self~assertSame(0.207911691, RxCalcSin(12))
+ numeric digits 18
+ self~assertSame(0.2079116908177593, RxCalcSin(12))
::method 'test_RxCalcSinB'
-- Test lowest precision
expected = 0.2
- self~assertEquals(expected, RxCalcSin(12,1))
+ self~assertSame(expected, RxCalcSin(12,1))
::method 'test_RxCalcSinC'
-- Test highest precision
- expected = 0.2079116908177594
- self~assertEquals(expected, RxCalcSin(12,16))
+ expected = 0.2079116908177593
+ self~assertSame(expected, RxCalcSin(12,16))
::method 'testRxCalcSinD'
-- Test invalid low precision
@@ -441,37 +420,40 @@
::method 'testRxCalcSinE'
-- Test invalid high precision
- self~assertEquals(RxCalcSin(12,16), RxCalcSin(12,17))
+ self~assertSame(RxCalcSin(12,16), RxCalcSin(12,17))
::method 'testRxCalcSinF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcSin(12,16), RxCalcSin(12))
+ self~assertSame(RxCalcSin(12,16), RxCalcSin(12))
-::method 'testRxCalcSinG'
--- Test default precision not equals
- expected = 0.207911690
- self~assertNotEquals(expected, RxCalcSin(12))
-
::method 'testRxCalcSinH'
-- Test supplying Degree as 'd'
- expected = 0.207911691
- self~assertEquals(expected, RxCalcSin(12,,'d'))
+ numeric digits 9
+ self~assertSame(0.207911691, RxCalcSin(12,,'d'))
+ numeric digits 18
+ self~assertSame(0.2079116908177593, RxCalcSin(12,,'d'))
::method 'testRxCalcSinI'
-- Test supplying Degree as 'D'
- expected = 0.207911691
- self~assertEquals(expected, RxCalcSin(12,,'D'))
+ numeric digits 9
+ self~assertSame(0.207911691, RxCalcSin(12,,'D'))
+ numeric digits 18
+ self~assertSame(0.2079116908177593, RxCalcSin(12,,'D'))
::method 'testRxCalcSinJ'
-- Test supplying Degree as 'degree'
- expected = 0.207911691
- self~assertEquals(expected, RxCalcSin(12,,'degree'))
+ numeric digits 9
+ self~assertSame(0.207911691, RxCalcSin(12,,'degree'))
+ numeric digits 18
+ self~assertSame(0.2079116908177593, RxCalcSin(12,,'degree'))
::method 'testRxCalcSinK'
-- Test supplying Degree as 'DEGREE'
- expected = 0.207911691
- self~assertEquals(expected, RxCalcSin(12,,'DEGREE'))
+ numeric digits 9
+ self~assertSame(0.207911691, RxCalcSin(12,,'DEGREE'))
+ numeric digits 18
+ self~assertSame(0.2079116908177593, RxCalcSin(12,,'DEGREE'))
::method 'testRxCalcSinL'
-- Test supplying Degree as an invalid expression
@@ -481,18 +463,18 @@
-- This set of unitTests is brought to you by the Sine Radians function
::method 'test_RxCalcSin_rA'
-- Test default precision
- expected = -0.536572918
- self~assertEquals(expected, RxCalcSin(12,,'r'))
+ numeric digits 9
+ self~assertSame(-0.536572918, RxCalcSin(12,,'r'))
+ numeric digits 18
+ self~assertSame(-0.5365729180004349, RxCalcSin(12,,'r'))
::method 'test_RxCalcSin_rB'
-- Test lowest precision
expected = -0.5
- self~assertEquals(expected, RxCalcSin(12,1,'r'))
+ self~assertSame(expected, RxCalcSin(12,1,'r'))
::method 'test_RxCalcSin_rC'
--- Test highest precision
- expected = -0.5365729180004349
- self~assertEquals(expected, RxCalcSin(12,16,'r'))
+ self~assertSame('-0.5365729180004349', RxCalcSin(12,16,'r'))
::method 'testRxCalcSin_rD'
-- Test invalid low precision
@@ -501,37 +483,40 @@
::method 'testRxCalcSin_rE'
-- Test invalid high precision
- self~assertEquals(RxCalcSin(12,16,'r'), RxCalcSin(12,17,'r'))
+ self~assertSame(RxCalcSin(12,16,'r'), RxCalcSin(12,17,'r'))
::method 'testRxCalcSin_rF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcSin(12,16,'r'), RxCalcSin(12,,'r'))
+ self~assertSame(RxCalcSin(12,16,'r'), RxCalcSin(12,,'r'))
-::method 'testRxCalcSin_rG'
--- Test default precision not equals
- expected = 0.536572918
- self~assertNotEquals(expected, RxCalcSin(12))
-
::method 'testRxCalcSin_rH'
-- Test supplying Radian as 'r'
- expected = -0.536572918
- self~assertEquals(expected, RxCalcSin(12,,'r'))
+ numeric digits 9
+ self~assertSame(-0.536572918, RxCalcSin(12,,'r'))
+ numeric digits 18
+ self~assertSame(-0.5365729180004349, RxCalcSin(12,,'r'))
::method 'testRxCalcSin_rI'
-- Test supplying Radian as 'R'
- expected = -0.536572918
- self~assertEquals(expected, RxCalcSin(12,,'R'))
+ numeric digits 9
+ self~assertSame(-0.536572918, RxCalcSin(12,,'R'))
+ numeric digits 18
+ self~assertSame(-0.5365729180004349, RxCalcSin(12,,'R'))
::method 'testRxCalcSin_rJ'
-- Test supplying Radian as 'radian'
- expected = -0.536572918
- self~assertEquals(expected, RxCalcSin(12,,'radian'))
+ numeric digits 9
+ self~assertSame(-0.536572918, RxCalcSin(12,,'radian'))
+ numeric digits 18
+ self~assertSame(-0.5365729180004349, RxCalcSin(12,,'radian'))
::method 'testRxCalcSin_rK'
-- Test supplying Radian as 'RADIAN'
- expected = -0.536572918
- self~assertEquals(expected, RxCalcSin(12,,'RADIAN'))
+ numeric digits 9
+ self~assertSame(-0.536572918, RxCalcSin(12,,'RADIAN'))
+ numeric digits 18
+ self~assertSame(-0.5365729180004349, RxCalcSin(12,,'RADIAN'))
::method 'testRxCalcSin_rL'
-- Test supplying Radian as an invalid expression
@@ -541,18 +526,20 @@
-- This set of unitTests is brought to you by the Sine Grades function
::method 'test_RxCalcSin_gA'
-- Test default precision
- expected = 0.187381315
- self~assertEquals(expected, RxCalcSin(12,,'g'))
+ numeric digits 9
+ self~assertSame(0.187381315, RxCalcSin(12,,'g'))
+ numeric digits 18
+ self~assertSame(0.1873813145857246, RxCalcSin(12,,'g'))
::method 'test_RxCalcSin_gB'
-- Test lowest precision
expected = 0.2
- self~assertEquals(expected, RxCalcSin(12,1,'g'))
+ self~assertSame(expected, RxCalcSin(12,1,'g'))
::method 'test_RxCalcSin_gC'
-- Test highest precision
expected = 0.1873813145857246
- self~assertEquals(expected, RxCalcSin(12,16,'g'))
+ self~assertSame(expected, RxCalcSin(12,16,'g'))
::method 'testRxCalcSin_gD'
-- Test invalid low precision
@@ -561,37 +548,40 @@
::method 'testRxCalcSin_gE'
-- Test invalid high precision
- self~assertEquals(RxCalcSin(12,16,'g'), RxCalcSin(12,17,'g'))
+ self~assertSame(RxCalcSin(12,16,'g'), RxCalcSin(12,17,'g'))
::method 'testRxCalcSin_gF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcSin(12,16,'g'), RxCalcSin(12,,'g'))
+ self~assertSame(RxCalcSin(12,16,'g'), RxCalcSin(12,,'g'))
-::method 'testRxCalcSin_gG'
--- Test default precision not equals
- expected = -0.187381315
- self~assertNotEquals(expected, RxCalcSin(12))
-
::method 'testRxCalcSin_gH'
-- Test supplying Grade as 'g'
- expected = 0.187381315
- self~assertEquals(expected, RxCalcSin(12,,'g'))
+ numeric digits 9
+ self~assertSame(0.187381315, RxCalcSin(12,,'g'))
+ numeric digits 18
+ self~assertSame(0.1873813145857246, RxCalcSin(12,,'g'))
::method 'testRxCalcSin_gI'
-- Test supplying Grade as 'G'
- expected = 0.187381315
- self~assertEquals(expected, RxCalcSin(12,,'G'))
+ numeric digits 9
+ self~assertSame(0.187381315, RxCalcSin(12,,'G'))
+ numeric digits 18
+ self~assertSame(0.1873813145857246, RxCalcSin(12,,'G'))
::method 'testRxCalcSin_gJ'
-- Test supplying Grade as 'grade'
- expected = 0.187381315
- self~assertEquals(expected, RxCalcSin(12,,'grade'))
+ numeric digits 9
+ self~assertSame(0.187381315, RxCalcSin(12,,'grade'))
+ numeric digits 18
+ self~assertSame(0.1873813145857246, RxCalcSin(12,,'grade'))
::method 'testRxCalcSin_gK'
-- Test supplying Grade as 'GRADE'
- expected = 0.187381315
- self~assertEquals(expected, RxCalcSin(12,,'GRADE'))
+ numeric digits 9
+ self~assertSame(0.187381315, RxCalcSin(12,,'GRADE'))
+ numeric digits 18
+ self~assertSame(0.1873813145857246, RxCalcSin(12,,'GRADE'))
::method 'testRxCalcSin_gL'
-- Test supplying Grade as an invalid expression
@@ -601,18 +591,20 @@
-- This set of unitTests is brought to you by the Cosine Degrees function
::method 'test_RxCalcCosA'
-- Test default precision
- expected = 0.978147601
- self~assertEquals(expected, RxCalcCos(12))
+ numeric digits 9
+ self~assertSame(0.978147601, RxCalcCos(12))
+ numeric digits 18
+ self~assertSame(0.9781476007338057, RxCalcCos(12))
::method 'test_RxCalcCosB'
-- Test lowest precision
expected = 1
- self~assertEquals(expected, RxCalcCos(12,1))
+ self~assertSame(expected, RxCalcCos(12,1))
::method 'test_RxCalcCosC'
-- Test highest precision
expected = 0.9781476007338057
- self~assertEquals(expected, RxCalcCos(12,16))
+ self~assertSame(expected, RxCalcCos(12,16))
::method 'testRxCalcCosD'
-- Test invalid low precision
@@ -621,37 +613,40 @@
::method 'testRxCalcCosE'
-- Test invalid high precision
- self~assertEquals(RxCalcCos(12,16), RxCalcCos(12,17))
+ self~assertSame(RxCalcCos(12,16), RxCalcCos(12,17))
::method 'testRxCalcCosF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcCos(12,16), RxCalcCos(12))
+ self~assertSame(RxCalcCos(12,16), RxCalcCos(12))
-::method 'testRxCalcCosG'
--- Test default precision not equals
- expected = 0.978147600
- self~assertNotEquals(expected, RxCalcCos(12))
-
::method 'testRxCalcCosH'
-- Test supplying Degree as 'd'
- expected = 0.978147601
- self~assertEquals(expected, RxCalcCos(12,,'d'))
+ numeric digits 9
+ self~assertSame(0.978147601, RxCalcCos(12,,'d'))
+ numeric digits 18
+ self~assertSame(0.9781476007338057, RxCalcCos(12,,'d'))
::method 'testRxCalcCosI'
-- Test supplying Degree as 'D'
- expected = 0.978147601
- self~assertEquals(expected, RxCalcCos(12,,'D'))
+ numeric digits 9
+ self~assertSame(0.978147601, RxCalcCos(12,,'D'))
+ numeric digits 18
+ self~assertSame(0.9781476007338057, RxCalcCos(12,,'D'))
::method 'testRxCalcCosJ'
-- Test supplying Degree as 'degree'
- expected = 0.978147601
- self~assertEquals(expected, RxCalcCos(12,,'degree'))
+ numeric digits 9
+ self~assertSame(0.978147601, RxCalcCos(12,,'degree'))
+ numeric digits 18
+ self~assertSame(0.9781476007338057, RxCalcCos(12,,'degree'))
::method 'testRxCalcCosK'
-- Test supplying Degree as 'DEGREE'
- expected = 0.978147601
- self~assertEquals(expected, RxCalcCos(12,,'DEGREE'))
+ numeric digits 9
+ self~assertSame(0.978147601, RxCalcCos(12,,'DEGREE'))
+ numeric digits 18
+ self~assertSame(0.9781476007338057, RxCalcCos(12,,'DEGREE'))
::method 'testRxCalcCosL'
-- Test supplying Degree as an invalid expression
@@ -661,18 +656,20 @@
-- This set of unitTests is brought to you by the Cosine Radians function
::method 'test_RxCalcCos_rA'
-- Test default precision
- expected = 0.843853959
- self~assertEquals(expected, RxCalcCos(12,,'r'))
+ numeric digits 9
+ self~assertSame(0.843853959, RxCalcCos(12,,'r'))
+ numeric digits 18
+ self~assertSame(0.8438539587324921, RxCalcCos(12,,'r'))
::method 'test_RxCalcCos_rB'
-- Test lowest precision
expected = 0.8
- self~assertEquals(expected, RxCalcCos(12,1,'r'))
+ self~assertSame(expected, RxCalcCos(12,1,'r'))
::method 'test_RxCalcCos_rC'
-- Test highest precision
expected = 0.8438539587324921
- self~assertEquals(expected, RxCalcCos(12,16,'r'))
+ self~assertSame(expected, RxCalcCos(12,16,'r'))
::method 'testRxCalcCos_rD'
-- Test invalid low precision
@@ -681,37 +678,40 @@
::method 'testRxCalcCos_rE'
-- Test invalid high precision
- self~assertEquals(RxCalcCos(12,16,'r'), RxCalcCos(12,17,'r'))
+ self~assertSame(RxCalcCos(12,16,'r'), RxCalcCos(12,17,'r'))
::method 'testRxCalcCos_rF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcCos(12,16,'r'), RxCalcCos(12,,'r'))
+ self~assertSame(RxCalcCos(12,16,'r'), RxCalcCos(12,,'r'))
-::method 'testRxCalcCos_rG'
--- Test default precision not equals
- expected = 0.843853958
- self~assertNotEquals(expected, RxCalcCos(12))
-
::method 'testRxCalcCos_rH'
-- Test supplying Radian as 'r'
- expected = 0.843853959
- self~assertEquals(expected, RxCalcCos(12,,'r'))
+ numeric digits 9
+ self~assertSame(0.843853959, RxCalcCos(12,,'r'))
+ numeric digits 18
+ self~assertSame(0.8438539587324921, RxCalcCos(12,,'r'))
::method 'testRxCalcCos_rI'
-- Test supplying Radian as 'R'
- expected = 0.843853959
- self~assertEquals(expected, RxCalcCos(12,,'R'))
+ numeric digits 9
+ self~assertSame(0.843853959, RxCalcCos(12,,'R'))
+ numeric digits 18
+ self~assertSame(0.8438539587324921, RxCalcCos(12,,'R'))
::method 'testRxCalcCos_rJ'
-- Test supplying Radian as 'radian'
- expected = 0.843853959
- self~assertEquals(expected, RxCalcCos(12,,'radian'))
+ numeric digits 9
+ self~assertSame(0.843853959, RxCalcCos(12,,'radian'))
+ numeric digits 18
+ self~assertSame(0.8438539587324921, RxCalcCos(12,,'radian'))
::method 'testRxCalcCos_rK'
-- Test supplying Radian as 'RADIAN'
- expected = 0.843853959
- self~assertEquals(expected, RxCalcCos(12,,'RADIAN'))
+ numeric digits 9
+ self~assertSame(0.843853959, RxCalcCos(12,,'RADIAN'))
+ numeric digits 18
+ self~assertSame(0.8438539587324921, RxCalcCos(12,,'RADIAN'))
::method 'testRxCalcCos_rL'
-- Test supplying Radian as an invalid expression
@@ -721,18 +721,20 @@
-- This set of unitTests is brought to you by the Cosine Grades function
::method 'test_RxCalcCos_gA'
-- Test default precision
- expected = 0.982287251
- self~assertEquals(expected, RxCalcCos(12,,'g'))
+ numeric digits 9
+ self~assertSame(0.982287251, RxCalcCos(12,,'g'))
+ numeric digits 18
+ self~assertSame(0.9822872507286887, RxCalcCos(12,,'g'))
::method 'test_RxCalcCos_gB'
-- Test lowest precision
expected = 1
- self~assertEquals(expected, RxCalcCos(12,1,'g'))
+ self~assertSame(expected, RxCalcCos(12,1,'g'))
::method 'test_RxCalcCos_gC'
-- Test highest precision
expected = 0.9822872507286887
- self~assertEquals(expected, RxCalcCos(12,16,'g'))
+ self~assertSame(expected, RxCalcCos(12,16,'g'))
::method 'testRxCalcCos_gD'
-- Test invalid low precision
@@ -741,37 +743,40 @@
::method 'testRxCalcCos_gE'
-- Test invalid high precision
- self~assertEquals(RxCalcCos(12,16,'g'), RxCalcCos(12,17,'g'))
+ self~assertSame(RxCalcCos(12,16,'g'), RxCalcCos(12,17,'g'))
::method 'testRxCalcCos_gF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcCos(12,16,'g'), RxCalcCos(12,,'g'))
+ self~assertSame(RxCalcCos(12,16,'g'), RxCalcCos(12,,'g'))
-::method 'testRxCalcCos_gG'
--- Test default precision not equals
- expected = 0.982287250
- self~assertNotEquals(expected, RxCalcCos(12))
-
::method 'testRxCalcCos_gH'
-- Test supplying Grade as 'g'
- expected = 0.982287251
- self~assertEquals(expected, RxCalcCos(12,,'g'))
+ numeric digits 9
+ self~assertSame(0.982287251, RxCalcCos(12,,'g'))
+ numeric digits 18
+ self~assertSame(0.9822872507286887, RxCalcCos(12,,'g'))
::method 'testRxCalcCos_gI'
-- Test supplying Grade as 'G'
- expected = 0.982287251
- self~assertEquals(expected, RxCalcCos(12,,'G'))
+ numeric digits 9
+ self~assertSame(0.982287251, RxCalcCos(12,,'G'))
+ numeric digits 18
+ self~assertSame(0.9822872507286887, RxCalcCos(12,,'G'))
::method 'testRxCalcCos_gJ'
-- Test supplying Grade as 'grade'
- expected = 0.982287251
- self~assertEquals(expected, RxCalcCos(12,,'grade'))
+ numeric digits 9
+ self~assertSame(0.982287251, RxCalcCos(12,,'grade'))
+ numeric digits 18
+ self~assertSame(0.9822872507286887, RxCalcCos(12,,'grade'))
::method 'testRxCalcCos_gK'
-- Test supplying Grade as 'GRADE'
- expected = 0.982287251
- self~assertEquals(expected, RxCalcCos(12,,'GRADE'))
+ numeric digits 9
+ self~assertSame(0.982287251, RxCalcCos(12,,'GRADE'))
+ numeric digits 18
+ self~assertSame(0.9822872507286887, RxCalcCos(12,,'GRADE'))
::method 'testRxCalcCos_gL'
-- Test supplying Grade as an invalid expression
@@ -781,18 +786,20 @@
-- This set of unitTests is brought to you by the Tangent Degrees function
::method 'test_RxCalcTanA'
-- Test default precision
- expected = 0.212556562
- self~assertEquals(expected, RxCalcTan(12))
+ numeric digits 9
+ self~assertSame(0.212556562, RxCalcTan(12))
+ numeric digits 18
+ self~assertSame(0.2125565616700221, RxCalcTan(12))
::method 'test_RxCalcTanB'
-- Test lowest precision
- expected = .2
- self~assertEquals(expected, RxCalcTan(12,1))
+ expected = 0.2
+ self~assertSame(expected, RxCalcTan(12,1))
::method 'test_RxCalcTanC'
-- Test highest precision
- expected = 0.2125565616700222
- self~assertEquals(expected, RxCalcTan(12,16))
+ expected = 0.2125565616700221
+ self~assertSame(expected, RxCalcTan(12,16))
::method 'testRxCalcTanD'
-- Test invalid low precision
@@ -801,37 +808,40 @@
::method 'testRxCalcTanE'
-- Test invalid high precision
- self~assertEquals(RxCalcTan(12,16), RxCalcTan(12,17))
+ self~assertSame(RxCalcTan(12,16), RxCalcTan(12,17))
::method 'testRxCalcTanF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcTan(12,16), RxCalcTan(12))
+ self~assertSame(RxCalcTan(12,16), RxCalcTan(12))
-::method 'testRxCalcTanG'
--- Test default precision not equals
- expected = 0.212556561
- self~assertNotEquals(expected, RxCalcTan(12))
-
::method 'testRxCalcTanH'
-- Test supplying Degree as 'd'
- expected = 0.212556562
- self~assertEquals(expected, RxCalcTan(12,,'d'))
+ numeric digits 9
+ self~assertSame(0.212556562, RxCalcTan(12,,'d'))
+ numeric digits 18
+ self~assertSame(0.2125565616700221, RxCalcTan(12,,'d'))
::method 'testRxCalcTanI'
-- Test supplying Degree as 'D'
- expected = 0.212556562
- self~assertEquals(expected, RxCalcTan(12,,'D'))
+ numeric digits 9
+ self~assertSame(0.212556562, RxCalcTan(12,,'D'))
+ numeric digits 18
+ self~assertSame(0.2125565616700221, RxCalcTan(12,,'D'))
::method 'testRxCalcTanJ'
-- Test supplying Degree as 'degree'
- expected = 0.212556562
- self~assertEquals(expected, RxCalcTan(12,,'degree'))
+ numeric digits 9
+ self~assertSame(0.212556562, RxCalcTan(12,,'degree'))
+ numeric digits 18
+ self~assertSame(0.2125565616700221, RxCalcTan(12,,'degree'))
::method 'testRxCalcTanK'
-- Test supplying Degree as 'DEGREE'
- expected = 0.212556562
- self~assertEquals(expected, RxCalcTan(12,,'DEGREE'))
+ numeric digits 9
+ self~assertSame(0.212556562, RxCalcTan(12,,'DEGREE'))
+ numeric digits 18
+ self~assertSame(0.2125565616700221, RxCalcTan(12,,'DEGREE'))
::method 'testRxCalcTanL'
-- Test supplying Degree as an invalid expression
@@ -841,18 +851,20 @@
-- This set of unitTests is brought to you by the Tangent Radians function
::method 'test_RxCalcTan_rA'
-- Test default precision
- expected = -0.635859929
- self~assertEquals(expected, RxCalcTan(12,,'r'))
+ numeric digits 9
+ self~assertSame(-0.635859929, RxCalcTan(12,,'r'))
+ numeric digits 18
+ self~assertSame(-0.6358599286615808, RxCalcTan(12,,'r'))
::method 'test_RxCalcTan_rB'
-- Test lowest precision
expected = -0.6
- self~assertEquals(expected, RxCalcTan(12,1,'r'))
+ self~assertSame(expected, RxCalcTan(12,1,'r'))
::method 'test_RxCalcTan_rC'
-- Test highest precision
- expected = -0.6358599286615808
- self~assertEquals(expected, RxCalcTan(12,16,'r'))
+ expected = '-0.6358599286615808'
+ self~assertSame(expected, RxCalcTan(12,16,'r'))
::method 'testRxCalcTan_rD'
-- Test invalid low precision
@@ -861,37 +873,40 @@
::method 'testRxCalcTan_rE'
-- Test invalid high precision
- self~assertEquals(RxCalcTan(12,16,'r'), RxCalcTan(12,17,'r'))
+ self~assertSame(RxCalcTan(12,16,'r'), RxCalcTan(12,17,'r'))
::method 'testRxCalcTan_rF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcTan(12,16,'r'), RxCalcTan(12,,'r'))
+ self~assertSame(RxCalcTan(12,16,'r'), RxCalcTan(12,,'r'))
-::method 'testRxCalcTan_rG'
--- Test default precision not equals
- expected = -0.635859928
- self~assertNotEquals(expected, RxCalcTan(12))
-
::method 'testRxCalcTan_rH'
-- Test supplying Radian as 'r'
- expected = -0.635859929
- self~assertEquals(expected, RxCalcTan(12,,'r'))
+ numeric digits 9
+ self~assertSame(-0.635859929, RxCalcTan(12,,'r'))
+ numeric digits 18
+ self~assertSame(-0.6358599286615808, RxCalcTan(12,,'r'))
::method 'testRxCalcTan_rI'
-- Test supplying Radian as 'R'
- expected = -0.635859929
- self~assertEquals(expected, RxCalcTan(12,,'R'))
+ numeric digits 9
+ self~assertSame(-0.635859929, RxCalcTan(12,,'R'))
+ numeric digits 18
+ self~assertSame(-0.6358599286615808, RxCalcTan(12,,'R'))
::method 'testRxCalcTan_rJ'
-- Test supplying Radian as 'radian'
- expected = -0.635859929
- self~assertEquals(expected, RxCalcTan(12,,'radian'))
+ numeric digits 9
+ self~assertSame(-0.635859929, RxCalcTan(12,,'radian'))
+ numeric digits 18
+ self~assertSame(-0.6358599286615808, RxCalcTan(12,,'radian'))
::method 'testRxCalcTan_rK'
-- Test supplying Radian as 'RADIAN'
- expected = -0.635859929
- self~assertEquals(expected, RxCalcTan(12,,'RADIAN'))
+ numeric digits 9
+ self~assertSame(-0.635859929, RxCalcTan(12,,'RADIAN'))
+ numeric digits 18
+ self~assertSame(-0.6358599286615808, RxCalcTan(12,,'RADIAN'))
::method 'testRxCalcTan_rL'
-- Test supplying Radian as an invalid expression
@@ -901,18 +916,20 @@
-- This set of unitTests is brought to you by the Tangent Grades function
::method 'test_RxCalcTan_gA'
-- Test default precision
- expected = 0.190760202
- self~assertEquals(expected, RxCalcTan(12,,'g'))
+ numeric digits 9
+ self~assertSame(0.190760202, RxCalcTan(12,,'g'))
+ numeric digits 18
+ self~assertSame(0.1907602022185667, RxCalcTan(12,,'g'))
::method 'test_RxCalcTan_gB'
-- Test lowest precision
expected = 0.2
- self~assertEquals(expected, RxCalcTan(12,1,'g'))
+ self~assertSame(expected, RxCalcTan(12,1,'g'))
::method 'test_RxCalcTan_gC'
-- Test highest precision
expected = 0.1907602022185667
- self~assertEquals(expected, RxCalcTan(12,16,'g'))
+ self~assertSame(expected, RxCalcTan(12,16,'g'))
::method 'testRxCalcTan_gD'
-- Test invalid low precision
@@ -921,37 +938,40 @@
::method 'testRxCalcTan_gE'
-- Test invalid high precision
- self~assertEquals(RxCalcTan(12,16,'g'), RxCalcTan(12,17,'g'))
+ self~assertSame(RxCalcTan(12,16,'g'), RxCalcTan(12,17,'g'))
::method 'testRxCalcTan_gF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcTan(12,16,'g'), RxCalcTan(12,,'g'))
+ self~assertSame(RxCalcTan(12,16,'g'), RxCalcTan(12,,'g'))
-::method 'testRxCalcTan_gG'
--- Test default precision not equals
- expected = 0.190760201
- self~assertNotEquals(expected, RxCalcTan(12))
-
::method 'testRxCalcTan_gH'
-- Test supplying Grade as 'g'
- expected = 0.190760202
- self~assertEquals(expected, RxCalcTan(12,,'g'))
+ numeric digits 9
+ self~assertSame(0.190760202, RxCalcTan(12,,'g'))
+ numeric digits 18
+ self~assertSame(0.1907602022185667, RxCalcTan(12,,'g'))
::method 'testRxCalcTan_gI'
-- Test supplying Grade as 'G'
- expected = 0.190760202
- self~assertEquals(expected, RxCalcTan(12,,'G'))
+ numeric digits 9
+ self~assertSame(0.190760202, RxCalcTan(12,,'G'))
+ numeric digits 18
+ self~assertSame(0.1907602022185667, RxCalcTan(12,,'G'))
::method 'testRxCalcTan_gJ'
-- Test supplying Grade as 'grade'
- expected = 0.190760202
- self~assertEquals(expected, RxCalcTan(12,,'grade'))
+ numeric digits 9
+ self~assertSame(0.190760202, RxCalcTan(12,,'grade'))
+ numeric digits 18
+ self~assertSame(0.1907602022185667, RxCalcTan(12,,'grade'))
::method 'testRxCalcTan_gK'
-- Test supplying Grade as 'GRADE'
- expected = 0.190760202
- self~assertEquals(expected, RxCalcTan(12,,'GRADE'))
+ numeric digits 9
+ self~assertSame(0.190760202, RxCalcTan(12,,'GRADE'))
+ numeric digits 18
+ self~assertSame(0.1907602022185667, RxCalcTan(12,,'GRADE'))
::method 'testRxCalcTan_gL'
-- Test supplying Grade as an invalid expression
@@ -961,18 +981,20 @@
-- This set of unitTests is brought to you by the Cotangent Degrees function
::method 'test_RxCalcCotanA'
-- Test default precision
- expected = 4.70463011
- self~assertEquals(expected, RxCalcCotan(12))
+ numeric digits 9
+ self~assertSame(4.70463011, RxCalcCotan(12))
+ numeric digits 18
+ self~assertSame(4.704630109478455, RxCalcCotan(12))
::method 'test_RxCalcCotanB'
-- Test lowest precision
expected = 5
- self~assertEquals(expected, RxCalcCotan(12,1))
+ self~assertSame(expected, RxCalcCotan(12,1))
::method 'test_RxCalcCotanC'
-- Test highest precision
- expected = 4.704630109478453
- self~assertEquals(expected, RxCalcCotan(12,16))
+ expected = 4.704630109478455
+ self~assertSame(expected, RxCalcCotan(12,16))
::method 'testRxCalcCotanD'
-- Test invalid low precision
@@ -981,37 +1003,40 @@
::method 'testRxCalcCotanE'
-- Test invalid high precision
- self~assertEquals(RxCalcCotan(12,16), RxCalcCotan(12,17))
+ self~assertSame(RxCalcCotan(12,16), RxCalcCotan(12,17))
::method 'testRxCalcCotanF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcCotan(12,16), RxCalcCotan(12))
+ self~assertSame(RxCalcCotan(12,16), RxCalcCotan(12))
-::method 'testRxCalcCotanG'
--- Test default precision not equals
- expected = 4.70463010
- self~assertNotEquals(expected, RxCalcCotan(12))
-
::method 'testRxCalcCotanH'
-- Test supplying Degree as 'd'
- expected = 4.70463011
- self~assertEquals(expected, RxCalcCotan(12,,'d'))
+ numeric digits 9
+ self~assertSame(4.70463011, RxCalcCotan(12,,'d'))
+ numeric digits 18
+ self~assertSame(4.704630109478455, RxCalcCotan(12,,'d'))
::method 'testRxCalcCotanI'
-- Test supplying Degree as 'D'
- expected = 4.70463011
- self~assertEquals(expected, RxCalcCotan(12,,'D'))
+ numeric digits 9
+ self~assertSame(4.70463011, RxCalcCotan(12,,'D'))
+ numeric digits 18
+ self~assertSame(4.704630109478455, RxCalcCotan(12,,'D'))
::method 'testRxCalcCotanJ'
-- Test supplying Degree as 'degree'
- expected = 4.70463011
- self~assertEquals(expected, RxCalcCotan(12,,'degree'))
+ numeric digits 9
+ self~assertSame(4.70463011, RxCalcCotan(12,,'degree'))
+ numeric digits 18
+ self~assertSame(4.704630109478455, RxCalcCotan(12,,'degree'))
::method 'testRxCalcCotanK'
-- Test supplying Degree as 'DEGREE'
- expected = 4.70463011
- self~assertEquals(expected, RxCalcCotan(12,,'DEGREE'))
+ numeric digits 9
+ self~assertSame(4.70463011, RxCalcCotan(12,,'DEGREE'))
+ numeric digits 18
+ self~assertSame(4.704630109478455, RxCalcCotan(12,,'DEGREE'))
::method 'testRxCalcCotanL'
-- Test supplying Degree as an invalid expression
@@ -1021,18 +1046,19 @@
-- This set of unitTests is brought to you by the Cotangent Radians function
::method 'test_RxCalcCotan_rA'
-- Test default precision
- expected = -1.57267341
- self~assertEquals(expected, RxCalcCotan(12,,'r'))
+ numeric digits 9
+ self~assertSame(-1.57267341, RxCalcCotan(12,,'r'))
+ numeric digits 18
+ self~assertSame(-1.572673406397689, RxCalcCotan(12,,'r'))
::method 'test_RxCalcCotan_rB'
-- Test lowest precision
expected = -2
- self~assertEquals(expected, RxCalcCotan(12,1,'r'))
+ self~assertSame(expected, RxCalcCotan(12,1,'r'))
::method 'test_RxCalcCotan_rC'
-- Test highest precision
- expected = -1.572673406397689
- self~assertEquals(expected, RxCalcCotan(12,16,'r'))
+ self~assertSame('-1.572673406397689', RxCalcCotan(12,16,'r'))
::method 'testRxCalcCotan_rD'
-- Test invalid low precision
@@ -1041,37 +1067,39 @@
::method 'testRxCalcCotan_rE'
-- Test invalid high precision
- self~assertEquals(RxCalcCotan(12,16,'r'), RxCalcCotan(12,17,'r'))
+ self~assertSame(RxCalcCotan(12,16,'r'), RxCalcCotan(12,17,'r'))
::method 'testRxCalcCotan_rF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcCotan(12,16,'r'), RxCalcCotan(12,,'r'))
+ self~assertSame(RxCalcCotan(12,16,'r'), RxCalcCotan(12,,'r'))
-::method 'testRxCalcCotan_rG'
--- Test default precision not equals
- expected = 1.57267341
- self~assertNotEquals(expected, RxCalcCotan(12))
-
::method 'testRxCalcCotan_rH'
-- Test supplying Radian as 'r'
- expected = -1.57267341
- self~assertEquals(expected, RxCalcCotan(12,,'r'))
+ numeric digits 9
+ self~assertSame(-1.57267341, RxCalcCotan(12,,'r'))
+ numeric digits 18
+ self~assertSame(-1.572673406397689, RxCalcCotan(12,,'r'))
::method 'testRxCalcCotan_rI'
-- Test supplying Radian as 'R'
- expected = -1.57267341
- self~assertEquals(expected, RxCalcCotan(12,,'R'))
+ numeric digits 9
+ self~assertSame(-1.57267341, RxCalcCotan(12,,'R'))
+ numeric digits 18
+ self~assertSame(-1.572673406397689, RxCalcCotan(12,,'R'))
::method 'testRxCalcCotan_rJ'
--- Test supplying Radian as 'radian'
- expected = -1.57267341
- self~assertEquals(expected, RxCalcCotan(12,,'radian'))
+ numeric digits 9
+ self~assertSame(-1.57267341, RxCalcCotan(12,,'radian'))
+ numeric digits 18
+ self~assertSame(-1.572673406397689, RxCalcCotan(12,,'radian'))
::method 'testRxCalcCotan_rK'
-- Test supplying Radian as 'RADIAN'
- expected = -1.57267341
- self~assertEquals(expected, RxCalcCotan(12,,'RADIAN'))
+ numeric digits 9
+ self~assertSame(-1.57267341, RxCalcCotan(12,,'RADIAN'))
+ numeric digits 18
+ self~assertSame(-1.572673406397689, RxCalcCotan(12,,'RADIAN'))
::method 'testRxCalcCotan_rL'
-- Test supplying Radian as an invalid expression
@@ -1081,18 +1109,20 @@
-- This set of unitTests is brought to you by the Cotangent Grades function
::method 'test_RxCalcCotan_gA'
-- Test default precision
- expected = 5.24218358
- self~assertEquals(expected, RxCalcCotan(12,,'g'))
+ numeric digits 9
+ self~assertSame(5.24218358, RxCalcCotan(12,,'g'))
+ numeric digits 18
+ self~assertSame(5.242183581113177, RxCalcCotan(12,,'g'))
::method 'test_RxCalcCotan_gB'
-- Test lowest precision
expected = 5
- self~assertEquals(expected, RxCalcCotan(12,1,'g'))
+ self~assertSame(expected, RxCalcCotan(12,1,'g'))
::method 'test_RxCalcCotan_gC'
-- Test highest precision
expected = 5.242183581113177
- self~assertEquals(expected, RxCalcCotan(12,16,'g'))
+ self~assertSame(expected, RxCalcCotan(12,16,'g'))
::method 'testRxCalcCotan_gD'
-- Test invalid low precision
@@ -1101,37 +1131,40 @@
::method 'testRxCalcCotan_gE'
-- Test invalid high precision
- self~assertEquals(RxCalcCotan(12,16,'g'), RxCalcCotan(12,17,'g'))
+ self~assertSame(RxCalcCotan(12,16,'g'), RxCalcCotan(12,17,'g'))
::method 'testRxCalcCotan_gF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcCotan(12,16,'g'), RxCalcCotan(12,,'g'))
+ self~assertSame(RxCalcCotan(12,16,'g'), RxCalcCotan(12,,'g'))
-::method 'testRxCalcCotan_gG'
--- Test default precision not equals
- expected = -5.24218358
- self~assertNotEquals(expected, RxCalcCotan(12))
-
::method 'testRxCalcCotan_gH'
-- Test supplying Grade as 'g'
- expected = 5.24218358
- self~assertEquals(expected, RxCalcCotan(12,,'g'))
+ numeric digits 9
+ self~assertSame(5.24218358, RxCalcCotan(12,,'g'))
+ numeric digits 18
+ self~assertSame(5.242183581113177, RxCalcCotan(12,,'g'))
::method 'testRxCalcCotan_gI'
-- Test supplying Grade as 'G'
- expected = 5.24218358
- self~assertEquals(expected, RxCalcCotan(12,,'G'))
+ numeric digits 9
+ self~assertSame(5.24218358, RxCalcCotan(12,,'G'))
+ numeric digits 18
+ self~assertSame(5.242183581113177, RxCalcCotan(12,,'G'))
::method 'testRxCalcCotan_gJ'
-- Test supplying Grade as 'grade'
- expected = 5.24218358
- self~assertEquals(expected, RxCalcCotan(12,,'grade'))
+ numeric digits 9
+ self~assertSame(5.24218358, RxCalcCotan(12,,'grade'))
+ numeric digits 18
+ self~assertSame(5.242183581113177, RxCalcCotan(12,,'grade'))
::method 'testRxCalcCotan_gK'
-- Test supplying Grade as 'GRADE'
- expected = 5.24218358
- self~assertEquals(expected, RxCalcCotan(12,,'GRADE'))
+ numeric digits 9
+ self~assertSame(5.24218358, RxCalcCotan(12,,'GRADE'))
+ numeric digits 18
+ self~assertSame(5.242183581113177, RxCalcCotan(12,,'GRADE'))
::method 'testRxCalcCotan_gL'
-- Test supplying Grade as an invalid expression
@@ -1141,18 +1174,20 @@
-- This set of unitTests is brought to you by the Pi function
::method 'test_RxCalcPiA'
-- Test default precision
- expected = 3.14159265
- self~assertEquals(expected, RxCalcPi())
+ numeric digits 9
+ self~assertSame(3.14159265, RxCalcPi())
+ numeric digits 18
+ self~assertSame(3.141592653589793, RxCalcPi())
::method 'test_RxCalcPiB'
-- Test lowest precision
expected = 3
- self~assertEquals(expected, RxCalcPi(1))
+ self~assertSame(expected, RxCalcPi(1))
::method 'test_RxCalcPiC'
-- Test highest precision
expected = 3.141592653589793
- self~assertEquals(expected, RxCalcPi(16))
+ self~assertSame(expected, RxCalcPi(16))
::method 'testRxCalcPiD'
-- Test invalid low precision
@@ -1161,33 +1196,30 @@
::method 'testRxCalcPiE'
-- Test invalid high precision
- self~assertEquals(RxCalcPi(16), RxCalcPi(17))
+ self~assertSame(RxCalcPi(16), RxCalcPi(17))
::method 'testRxCalcPiF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcPi(16), RxCalcPi())
+ self~assertSame(RxCalcPi(16), RxCalcPi())
-::method 'testRxCalcPiG'
--- Test default precision not equals
- expected = 3.14159264
- self~assertNotEquals(expected, RxCalcPi(12))
-
-- This set of unitTests is brought to you by the Arcsine Degrees function
::method 'test_RxCalcArcSinA'
-- Test default precision
- expected = 8.77763055
- self~assertEquals(expected, RxCalcArcSin(.1526))
+ numeric digits 9
+ self~assertSame(8.77763055, RxCalcArcSin(.1526))
+ numeric digits 18
+ self~assertSame(8.777630552223764, RxCalcArcSin(.1526))
::method 'test_RxCalcArcSinB'
-- Test lowest precision
expected = 9
- self~assertEquals(expected, RxCalcArcSin(.1526,1))
+ self~assertSame(expected, RxCalcArcSin(.1526,1))
::method 'test_RxCalcArcSinC'
-- Test highest precision
expected = 8.777630552223764
- self~assertEquals(expected, RxCalcArcSin(.1526,16))
+ self~assertSame(expected, RxCalcArcSin(.1526,16))
::method 'testRxCalcArcSinD'
-- Test invalid low precision
@@ -1196,37 +1228,40 @@
::method 'testRxCalcArcSinE'
-- Test invalid high precision
- self~assertEquals(RxCalcArcSin(.1526,16), RxCalcArcSin(.1526,17))
+ self~assertSame(RxCalcArcSin(.1526,16), RxCalcArcSin(.1526,17))
::method 'testRxCalcArcSinF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcArcSin(.1526,16), RxCalcArcSin(.1526))
+ self~assertSame(RxCalcArcSin(.1526,16), RxCalcArcSin(.1526))
-::method 'testRxCalcArcSinG'
--- Test default precision not equals
- expected = 8.77763054
- self~assertNotEquals(expected, RxCalcArcSin(.1526))
-
::method 'testRxCalcArcSinH'
-- Test supplying Degree as 'd'
- expected = 8.77763055
- self~assertEquals(expected, RxCalcArcSin(.1526,,'d'))
+ numeric digits 9
+ self~assertSame(8.77763055, RxCalcArcSin(.1526,,'d'))
+ numeric digits 18
+ self~assertSame(8.777630552223764, RxCalcArcSin(.1526,,'d'))
::method 'testRxCalcArcSinI'
-- Test supplying Degree as 'D'
- expected = 8.77763055
- self~assertEquals(expected, RxCalcArcSin(.1526,,'D'))
+ numeric digits 9
+ self~assertSame(8.77763055, RxCalcArcSin(.1526,,'D'))
+ numeric digits 18
+ self~assertSame(8.777630552223764, RxCalcArcSin(.1526,,'D'))
::method 'testRxCalcArcSinJ'
-- Test supplying Degree as 'degree'
- expected = 8.77763055
- self~assertEquals(expected, RxCalcArcSin(.1526,,'degree'))
+ numeric digits 9
+ self~assertSame(8.77763055, RxCalcArcSin(.1526,,'degree'))
+ numeric digits 18
+ self~assertSame(8.777630552223764, RxCalcArcSin(.1526,,'degree'))
::method 'testRxCalcArcSinK'
-- Test supplying Degree as 'DEGREE'
- expected = 8.77763055
- self~assertEquals(expected, RxCalcArcSin(.1526,,'DEGREE'))
+ numeric digits 9
+ self~assertSame(8.77763055, RxCalcArcSin(.1526,,'DEGREE'))
+ numeric digits 18
+ self~assertSame(8.777630552223764, RxCalcArcSin(.1526,,'DEGREE'))
::method 'testRxCalcArcSinL'
-- Test supplying Degree as an invalid expression
@@ -1236,18 +1271,20 @@
-- This set of unitTests is brought to you by the Arcsine Radians function
::method 'test_RxCalcArcSin_rA'
-- Test default precision
- expected = 0.153198554
- self~assertEquals(expected, RxCalcArcSin(.1526,,'r'))
+ numeric digits 9
+ self~assertSame(0.153198554, RxCalcArcSin(.1526,,'r'))
+ numeric digits 18
+ self~assertSame(0.1531985536599528, RxCalcArcSin(.1526,,'r'))
::method 'test_RxCalcArcSin_rB'
-- Test lowest precision
expected = 0.2
- self~assertEquals(expected, RxCalcArcSin(.1526,1,'r'))
+ self~assertSame(expected, RxCalcArcSin(.1526,1,'r'))
::method 'test_RxCalcArcSin_rC'
-- Test highest precision
expected = 0.1531985536599528
- self~assertEquals(expected, RxCalcArcSin(.1526,16,'r'))
+ self~assertSame(expected, RxCalcArcSin(.1526,16,'r'))
::method 'testRxCalcArcSin_rD'
-- Test invalid low precision
@@ -1256,37 +1293,40 @@
::method 'testRxCalcArcSin_rE'
-- Test invalid high precision
- self~assertEquals(RxCalcArcSin(.1526,16,'r'), RxCalcArcSin(.1526,17,'r'))
+ self~assertSame(RxCalcArcSin(.1526,16,'r'), RxCalcArcSin(.1526,17,'r'))
::method 'testRxCalcArcSin_rF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcArcSin(.1526,16,'r'), RxCalcArcSin(.1526,,'r'))
+ self~assertSame(RxCalcArcSin(.1526,16,'r'), RxCalcArcSin(.1526,,'r'))
-::method 'testRxCalcArcSin_rG'
--- Test default precision not equals
- expected = -0.153198554
- self~assertNotEquals(expected, RxCalcArcSin(.1526))
-
::method 'testRxCalcArcSin_rH'
-- Test supplying Radian as 'r'
- expected = 0.153198554
- self~assertEquals(expected, RxCalcArcSin(.1526,,'r'))
+ numeric digits 9
+ self~assertSame(0.153198554, RxCalcArcSin(.1526,,'r'))
+ numeric digits 18
+ self~assertSame(0.1531985536599528, RxCalcArcSin(.1526,,'r'))
::method 'testRxCalcArcSin_rI'
-- Test supplying Radian as 'R'
- expected = 0.153198554
- self~assertEquals(expected, RxCalcArcSin(.1526,,'R'))
+ numeric digits 9
+ self~assertSame(0.153198554, RxCalcArcSin(.1526,,'R'))
+ numeric digits 18
+ self~assertSame(0.1531985536599528, RxCalcArcSin(.1526,,'R'))
::method 'testRxCalcArcSin_rJ'
-- Test supplying Radian as 'radian'
- expected = 0.153198554
- self~assertEquals(expected, RxCalcArcSin(.1526,,'radian'))
+ numeric digits 9
+ self~assertSame(0.153198554, RxCalcArcSin(.1526,,'radian'))
+ numeric digits 18
+ self~assertSame(0.1531985536599528, RxCalcArcSin(.1526,,'radian'))
::method 'testRxCalcArcSin_rK'
-- Test supplying Radian as 'RADIAN'
- expected = 0.153198554
- self~assertEquals(expected, RxCalcArcSin(.1526,,'RADIAN'))
+ numeric digits 9
+ self~assertSame(0.153198554, RxCalcArcSin(.1526,,'RADIAN'))
+ numeric digits 18
+ self~assertSame(0.1531985536599528, RxCalcArcSin(.1526,,'RADIAN'))
::method 'testRxCalcArcSin_rL'
-- Test supplying Radian as an invalid expression
@@ -1296,18 +1336,20 @@
-- This set of unitTests is brought to you by the Arcsine Grades function
::method 'test_RxCalcArcSin_gA'
-- Test default precision
- expected = 9.75292284
- self~assertEquals(expected, RxCalcArcSin(.1526,,'g'))
+ numeric digits 9
+ self~assertSame(9.75292284, RxCalcArcSin(.1526,,'g'))
+ numeric digits 18
+ self~assertSame(9.752922835804183, RxCalcArcSin(.1526,,'g'))
::method 'test_RxCalcArcSin_gB'
-- Test lowest precision
- expected = 1e+001
- self~assertEquals(expected, RxCalcArcSin(.1526,1,'g'))
+ expected = 1E+1
+ self~assertSame(expected, RxCalcArcSin(.1526,1,'g'))
::method 'test_RxCalcArcSin_gC'
-- Test highest precision
- expected = 9.752922835804185
- self~assertEquals(expected, RxCalcArcSin(.1526,16,'g'))
+ expected = 9.752922835804183
+ self~assertSame(expected, RxCalcArcSin(.1526,16,'g'))
::method 'testRxCalcArcSin_gD'
-- Test invalid low precision
@@ -1316,37 +1358,40 @@
::method 'testRxCalcArcSin_gE'
-- Test invalid high precision
- self~assertEquals(RxCalcArcSin(.1526,16,'g'), RxCalcArcSin(.1526,17,'g'))
+ self~assertSame(RxCalcArcSin(.1526,16,'g'), RxCalcArcSin(.1526,17,'g'))
::method 'testRxCalcArcSin_gF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcArcSin(.1526,16,'g'), RxCalcArcSin(.1526,,'g'))
+ self~assertSame(RxCalcArcSin(.1526,16,'g'), RxCalcArcSin(.1526,,'g'))
-::method 'testRxCalcArcSin_gG'
--- Test default precision not equals
- expected = 9.75292283
- self~assertNotEquals(expected, RxCalcArcSin(.1526))
-
::method 'testRxCalcArcSin_gH'
-- Test supplying Grade as 'g'
- expected = 9.75292284
- self~assertEquals(expected, RxCalcArcSin(.1526,,'g'))
+ numeric digits 9
+ self~assertSame(9.75292284, RxCalcArcSin(.1526,,'g'))
+ numeric digits 18
+ self~assertSame(9.752922835804183, RxCalcArcSin(.1526,,'g'))
::method 'testRxCalcArcSin_gI'
-- Test supplying Grade as 'G'
- expected = 9.75292284
- self~assertEquals(expected, RxCalcArcSin(.1526,,'G'))
+ numeric digits 9
+ self~assertSame(9.75292284, RxCalcArcSin(.1526,,'G'))
+ numeric digits 18
+ self~assertSame(9.752922835804183, RxCalcArcSin(.1526,,'G'))
::method 'testRxCalcArcSin_gJ'
-- Test supplying Grade as 'grade'
- expected = 9.75292284
- self~assertEquals(expected, RxCalcArcSin(.1526,,'grade'))
+ numeric digits 9
+ self~assertSame(9.75292284, RxCalcArcSin(.1526,,'grade'))
+ numeric digits 18
+ self~assertSame(9.752922835804183, RxCalcArcSin(.1526,,'grade'))
::method 'testRxCalcArcSin_gK'
-- Test supplying Grade as 'GRADE'
- expected = 9.75292284
- self~assertEquals(expected, RxCalcArcSin(.1526,,'GRADE'))
+ numeric digits 9
+ self~assertSame(9.75292284, RxCalcArcSin(.1526,,'GRADE'))
+ numeric digits 18
+ self~assertSame(9.752922835804183, RxCalcArcSin(.1526,,'GRADE'))
::method 'testRxCalcArcSin_gL'
-- Test supplying Grade as an invalid expression
@@ -1356,18 +1401,20 @@
-- This set of unitTests is brought to you by the ArcCosine Degrees function
::method 'test_RxCalcArcCosA'
-- Test default precision
- expected = 81.2223694
- self~assertEquals(expected, RxCalcArcCos(.1526))
+ numeric digits 9
+ self~assertSame(81.2223694, RxCalcArcCos(.1526))
+ numeric digits 18
+ self~assertSame(81.22236944777625, RxCalcArcCos(.1526))
::method 'test_RxCalcArcCosB'
-- Test lowest precision
- expected = 80
- self~assertEquals(expected, RxCalcArcCos(.1526,1))
+ expected = 8E+1
+ self~assertSame(expected, RxCalcArcCos(.1526,1))
::method 'test_RxCalcArcCosC'
-- Test highest precision
- expected = 81.2223694477762
- self~assertEquals(expected, RxCalcArcCos(.1526,16))
+ expected = 81.22236944777625
+ self~assertSame(expected, RxCalcArcCos(.1526,16))
::method 'testRxCalcArcCosD'
-- Test invalid low precision
@@ -1376,37 +1423,40 @@
::method 'testRxCalcArcCosE'
-- Test invalid high precision
- self~assertEquals(RxCalcArcCos(.1526,16), RxCalcArcCos(.1526,17))
+ self~assertSame(RxCalcArcCos(.1526,16), RxCalcArcCos(.1526,17))
::method 'testRxCalcArcCosF'
-- Test invalid high precision base on numeric digits
numeric digits 20
- self~assertEquals(RxCalcArcCos(.1526,16), RxCalcArcCos(.1526))
+ self~assertSame(RxCalcArcCos(.1526,16), RxCalcArcCos(.1526))
-::method 'testRxCalcArcCosG'
--- Test default precision not equals
- expected = 81.2223695
- self~assertNotEquals(expected, RxCalcArcCos(.1526))
-
::method 'testRxCalcArcCosH'
-- Test supplying Degree as 'd'
- expected = 81.2223694
- self~assertEquals(expected, RxCalcArcCos(.1526,,'d'))
+ numeric digits 9
+ self~assertSame(81.2223694, RxCalcArcCos(.1526,,'d'))
+ numeric digits 18
+ self~assertSame(81.22236944777625, RxCalcArcCos(.1526,,'d'))
::method 'testRxCalcArcCosI'
-- Test supplying Degree as 'D'
- expected = 81.2223694
- self~assertEquals(expected, RxCalcArcCos(.1526,,'D'))
+ numeric digits 9
+ self~assertSame(81.2223694, RxCalcArcCos(.1526,,'D'))
+ numeric digits 18
+ self~assertSame(81.22236944777625, RxCalcArcCos(.1526,,'D'))
::method 'testRxCalcArcCosJ'
-- Test supplying Degree as 'degree'
- expected = 81.2223694
- self~assertEquals(expected, RxCalcArcCos(.1526,,'degree'))
+ numeric digits 9
+ self~assertSame(81.2223694, RxCalcArcCos(.1526,,'degree'))
+ numeric digits 18
+ self~assertSame(81.22236944777625, RxCalcArcCos(.1526,,'degree'))
::method 'testRxCalcArcCosK'
-- Test supplying Degree as 'DEGREE'
- expected = 81.2223694
- self~assertEquals(expected, RxCalcArcCos(.1526,,'DEGREE'))
+ numeric digits 9
+ self~assertSame(81.2223694, RxCalcArcCos(.1526,,'DEGREE'))
+ numeric digits 18
+ self~assertSame(81.22236944777625, RxCalcArcCos(.1526,,'DEGREE'))
::method 'testRxCalcArcCosL'
-- Test supplying Degree as an invalid expression
@@ -1416,18 +1466,20 @@
-- This set of unitTests is brought to you by the ArcCosine Radians function
::method 'test_RxCalcArcCos_rA'
-- Test default precision
- expected = 1.41759777
- self~assertEquals(expected, RxCalcArcCos(.1526,,'r'))
+ numeric digits 9
+ self~assertSame(1.41759777, RxCalcArcCos(.1526,,'r'))
+ numeric digits 18
+ self~assertSame(1.417597773134944, RxCalcArcCos(.1526,,'r'))
::method 'test_RxCalcArcCos_rB'
-- Test lowest precision
expected = 1
- self~assertEquals(expected, RxCalcArcCos(.1526,1,'r'))
+ self~assertSame(expected, RxCalcArcCos(.1526,1,'r'))
::method 'test_RxCalcArcCos_rC'
-- Test highest precision
expected = 1.417597773134944
- self~assertEquals(expected, RxCalcArcCos(.1526,16,'r'))
+ self~asser...
[truncated message content] |