From ea63847eb7b308ce1c9fe39b333cb30de1521935 Mon Sep 17 00:00:00 2001 From: Rodrigo Moya Date: Thu, 10 Oct 2002 20:27:55 +0000 Subject: [PATCH] 2002-10-10 Ville Palo (vi64pa@koti.soon.fi) * System.Data.SqlTypes/SqlDoubleTest.cs: new test suite for SqlDouble. svn path=/trunk/mcs/; revision=8147 --- mcs/class/System.Data/Test/ChangeLog | 4 + .../Test/System.Data.SqlTypes/AllTests.cs | 1 + .../System.Data.SqlTypes/SqlDoubleTest.cs | 534 ++++++++++++++++++ 3 files changed, 539 insertions(+) create mode 100644 mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDoubleTest.cs diff --git a/mcs/class/System.Data/Test/ChangeLog b/mcs/class/System.Data/Test/ChangeLog index fd3db00c8ac..5753deef5d4 100644 --- a/mcs/class/System.Data/Test/ChangeLog +++ b/mcs/class/System.Data/Test/ChangeLog @@ -1,3 +1,7 @@ +2002-10-10 Ville Palo (vi64pa@koti.soon.fi) + + * System.Data.SqlTypes/SqlDoubleTest.cs: new test suite for SqlDouble. + 2002-10-10 Daniel Morgan * SqlSharpCli.cs: modified diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs index 24af29b962a..adf0362a196 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs @@ -21,6 +21,7 @@ namespace MonoTests.System.Data.SqlTypes TestSuite suite = new TestSuite (); suite.AddTest (new TestSuite (typeof (SqlBooleanTest))); suite.AddTest (new TestSuite (typeof (SqlByteTest))); + suite.AddTest (new TestSuite (typeof (SqlDoubleTest))); suite.AddTest (new TestSuite (typeof (SqlInt16Test))); suite.AddTest (new TestSuite (typeof (SqlInt32Test))); suite.AddTest (new TestSuite (typeof (SqlInt64Test))); diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDoubleTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDoubleTest.cs new file mode 100644 index 00000000000..32880c78227 --- /dev/null +++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDoubleTest.cs @@ -0,0 +1,534 @@ +// +// SqlDoubleTest.cs - NUnit Test Cases for System.Data.SqlTypes.SqlDouble +// +// Ville Palo (vi64pa@koti.soon.fi) +// +// (C) Ville Palo 2002 +// + +using NUnit.Framework; +using System; +using System.Data.SqlTypes; + +namespace MonoTests.System.Data.SqlTypes +{ + public class SqlDoubleTest : TestCase { + + public SqlDoubleTest() : base ("System.Data.SqlTypes.SqlDouble") {} + public SqlDoubleTest(string name) : base(name) {} + + protected override void TearDown() {} + + protected override void SetUp() {} + + public static ITest Suite { + get { + return new TestSuite(typeof(SqlDouble)); + } + } + + // Test constructor + public void TestCreate() + { + SqlDouble Test= new SqlDouble ((double)34.87); + AssertEquals ("#A01", 34.87D, Test.Value); + + Test = new SqlDouble (-9000.6543); + AssertEquals ("#A02", -9000.6543D, Test.Value); + } + + // Test public fields + public void TestPublicFields() + { + AssertEquals ("#B01", 1.7976931348623157e+308, SqlDouble.MaxValue.Value); + AssertEquals ("#B02", -1.7976931348623157e+308, SqlDouble.MinValue.Value); + Assert ("#B03", SqlDouble.Null.IsNull); + AssertEquals ("#B04", 0d, SqlDouble.Zero.Value); + } + + // Test properties + public void TestProperties() + { + SqlDouble Test5443 = new SqlDouble (5443e12); + SqlDouble Test1 = new SqlDouble (1); + + Assert ("#C01", SqlDouble.Null.IsNull); + AssertEquals ("#C02", 5443e12, Test5443.Value); + AssertEquals ("#C03", (double)1, Test1.Value); + } + + // PUBLIC METHODS + + public void TestArithmeticMethods() + { + SqlDouble Test0 = new SqlDouble (0); + SqlDouble Test1 = new SqlDouble (15e108); + SqlDouble Test2 = new SqlDouble (-65e64); + SqlDouble Test3 = new SqlDouble (5e64); + SqlDouble Test4 = new SqlDouble (5e108); + SqlDouble TestMax = new SqlDouble (SqlDouble.MaxValue.Value); + + // Add() + AssertEquals ("#D01A", 15e108, SqlDouble.Add (Test1, Test0).Value); + AssertEquals ("#D02A", 1.5e109, SqlDouble.Add (Test1, Test2).Value); + + try { + SqlDouble test = SqlDouble.Add (SqlDouble.MaxValue, SqlDouble.MaxValue); + Fail ("#D03A"); + } catch (Exception e) { + AssertEquals ("#D04A", typeof (OverflowException), e.GetType ()); + } + + // Divide() + AssertEquals ("#D01B", (SqlDouble)3, SqlDouble.Divide (Test1, Test4)); + AssertEquals ("#D02B", -13d, SqlDouble.Divide (Test2, Test3).Value); + + try { + SqlDouble test = SqlDouble.Divide(Test1, Test0).Value; + Fail ("#D03B"); + } catch(Exception e) { + AssertEquals ("#D04B", typeof (DivideByZeroException), e.GetType ()); + } + + // Multiply() + AssertEquals ("#D01D", (double)(75e216), SqlDouble.Multiply (Test1, Test4).Value); + AssertEquals ("#D02D", (double)0, SqlDouble.Multiply (Test1, Test0).Value); + + try { + SqlDouble test = SqlDouble.Multiply (TestMax, Test1); + Fail ("#D03D"); + } catch (Exception e) { + AssertEquals ("#D04D", typeof (OverflowException), e.GetType ()); + } + + + // Subtract() + AssertEquals ("#D01F", (double)1.5e109, SqlDouble.Subtract (Test1, Test3).Value); + + try { + SqlDouble test = SqlDouble.Subtract(SqlDouble.MinValue, SqlDouble.MaxValue); + Fail ("D02F"); + } catch (Exception e) { + AssertEquals ("#D03F", typeof (OverflowException), e.GetType ()); + } + } + + public void TestCompareTo() + { + SqlDouble Test1 = new SqlDouble (4e64); + SqlDouble Test11 = new SqlDouble (4e64); + SqlDouble Test2 = new SqlDouble (-9e34); + SqlDouble Test3 = new SqlDouble (10000); + SqlString TestString = new SqlString ("This is a test"); + + Assert ("#E01", Test1.CompareTo (Test3) > 0); + Assert ("#E02", Test2.CompareTo (Test3) < 0); + Assert ("#E03", Test1.CompareTo (Test11) == 0); + Assert ("#E04", Test11.CompareTo (SqlDouble.Null) > 0); + + try { + Test1.CompareTo (TestString); + Fail("#E05"); + } catch(Exception e) { + AssertEquals ("#E06", typeof (ArgumentException), e.GetType ()); + } + } + + public void TestEqualsMethods() + { + SqlDouble Test0 = new SqlDouble (0); + SqlDouble Test1 = new SqlDouble (1.58e30); + SqlDouble Test2 = new SqlDouble (1.8e180); + SqlDouble Test22 = new SqlDouble (1.8e180); + + Assert ("#F01", !Test0.Equals (Test1)); + Assert ("#F02", !Test1.Equals (Test2)); + Assert ("#F03", !Test2.Equals (new SqlString ("TEST"))); + Assert ("#F04", Test2.Equals (Test22)); + + // Static Equals()-method + Assert ("#F05", SqlDouble.Equals (Test2, Test22).Value); + Assert ("#F06", !SqlDouble.Equals (Test1, Test2).Value); + } + + public void TestGetHashCode() + { + SqlDouble Test15 = new SqlDouble (15); + + // FIXME: Better way to test HashCode + AssertEquals ("#G01", Test15.GetHashCode (), Test15.GetHashCode ()); + } + + public void TestGetType() + { + SqlDouble Test = new SqlDouble (84); + AssertEquals ("#H01", "System.Data.SqlTypes.SqlDouble", Test.GetType ().ToString ()); + AssertEquals ("#H02", "System.Double", Test.Value.GetType ().ToString ()); + } + + public void TestGreaters() + { + SqlDouble Test1 = new SqlDouble (1e100); + SqlDouble Test11 = new SqlDouble (1e100); + SqlDouble Test2 = new SqlDouble (64e164); + + // GreateThan () + Assert ("#I01", !SqlDouble.GreaterThan (Test1, Test2).Value); + Assert ("#I02", SqlDouble.GreaterThan (Test2, Test1).Value); + Assert ("#I03", !SqlDouble.GreaterThan (Test1, Test11).Value); + + // GreaterTharOrEqual () + Assert ("#I04", !SqlDouble.GreaterThanOrEqual (Test1, Test2).Value); + Assert ("#I05", SqlDouble.GreaterThanOrEqual (Test2, Test1).Value); + Assert ("#I06", SqlDouble.GreaterThanOrEqual (Test1, Test11).Value); + } + + public void TestLessers() + { + SqlDouble Test1 = new SqlDouble (1.8e100); + SqlDouble Test11 = new SqlDouble (1.8e100); + SqlDouble Test2 = new SqlDouble (64e164); + + // LessThan() + Assert ("#J01", !SqlDouble.LessThan (Test1, Test11).Value); + Assert ("#J02", !SqlDouble.LessThan (Test2, Test1).Value); + Assert ("#J03", SqlDouble.LessThan (Test11, Test2).Value); + + // LessThanOrEqual () + Assert ("#J04", SqlDouble.LessThanOrEqual (Test1, Test2).Value); + Assert ("#J05", !SqlDouble.LessThanOrEqual (Test2, Test1).Value); + Assert ("#J06", SqlDouble.LessThanOrEqual (Test11, Test1).Value); + Assert ("#J07", SqlDouble.LessThanOrEqual (Test11, SqlDouble.Null).IsNull); + } + + public void TestNotEquals() + { + SqlDouble Test1 = new SqlDouble (1280000000001); + SqlDouble Test2 = new SqlDouble (128e10); + SqlDouble Test22 = new SqlDouble (128e10); + + Assert ("#K01", SqlDouble.NotEquals (Test1, Test2).Value); + Assert ("#K02", SqlDouble.NotEquals (Test2, Test1).Value); + Assert ("#K03", SqlDouble.NotEquals (Test22, Test1).Value); + Assert ("#K04", !SqlDouble.NotEquals (Test22, Test2).Value); + Assert ("#K05", !SqlDouble.NotEquals (Test2, Test22).Value); + Assert ("#K06", SqlDouble.NotEquals (SqlDouble.Null, Test22).IsNull); + Assert ("#K07", SqlDouble.NotEquals (SqlDouble.Null, Test22).IsNull); + } + + public void TestParse() + { + try { + SqlDouble.Parse (null); + Fail ("#L01"); + } catch (Exception e) { + AssertEquals ("#L02", typeof (ArgumentNullException), e.GetType ()); + } + + try { + SqlDouble.Parse ("not-a-number"); + Fail ("#L03"); + } catch (Exception e) { + + AssertEquals ("#L04", typeof (FormatException), e.GetType ()); + } + + try { + SqlDouble.Parse ("9e400"); + Fail ("#L05"); + } catch (Exception e) { + AssertEquals ("#L06", typeof (OverflowException), e.GetType ()); + } + + AssertEquals("#L07", (double)150, SqlDouble.Parse ("150").Value); + } + + public void TestConversions() + { + SqlDouble Test0 = new SqlDouble (0); + SqlDouble Test1 = new SqlDouble (250); + SqlDouble Test2 = new SqlDouble (64e64); + SqlDouble Test3 = new SqlDouble (64e164); + SqlDouble TestNull = SqlDouble.Null; + + // ToSqlBoolean () + Assert ("#M01A", Test1.ToSqlBoolean ().Value); + Assert ("#M02A", !Test0.ToSqlBoolean ().Value); + Assert ("#M03A", TestNull.ToSqlBoolean ().IsNull); + + // ToSqlByte () + AssertEquals ("#M01B", (byte)250, Test1.ToSqlByte ().Value); + AssertEquals ("#M02B", (byte)0, Test0.ToSqlByte ().Value); + + try { + SqlByte b = (byte)Test2.ToSqlByte (); + Fail ("#M03B"); + } catch (Exception e) { + AssertEquals ("#M04B", typeof (OverflowException), e.GetType ()); + } + + // ToSqlDecimal () + AssertEquals ("#M01C", (decimal)250, Test1.ToSqlDecimal ().Value); + AssertEquals ("#M02C", (decimal)0, Test0.ToSqlDecimal ().Value); + + try { + SqlDecimal test = Test3.ToSqlDecimal ().Value; + Fail ("#M03C"); + } catch (Exception e) { + AssertEquals ("#M04C", typeof (OverflowException), e.GetType ()); + } + + // ToSqlInt16 () + AssertEquals ("#M01D", (short)250, Test1.ToSqlInt16 ().Value); + AssertEquals ("#M02D", (short)0, Test0.ToSqlInt16 ().Value); + + try { + SqlInt16 test = Test2.ToSqlInt16().Value; + Fail ("#M03D"); + } catch (Exception e) { + AssertEquals ("#M04D", typeof (OverflowException), e.GetType ()); + } + + // ToSqlInt32 () + AssertEquals ("#M01E", (int)250, Test1.ToSqlInt32 ().Value); + AssertEquals ("#M02E", (int)0, Test0.ToSqlInt32 ().Value); + + try { + SqlInt32 test = Test2.ToSqlInt32 ().Value; + Fail ("#M03E"); + } catch (Exception e) { + AssertEquals ("#M04E", typeof (OverflowException), e.GetType ()); + } + + // ToSqlInt64 () + AssertEquals ("#M01F", (long)250, Test1.ToSqlInt64 ().Value); + AssertEquals ("#M02F", (long)0, Test0.ToSqlInt64 ().Value); + + try { + SqlInt64 test = Test2.ToSqlInt64 ().Value; + Fail ("#M03F"); + } catch (Exception e) { + AssertEquals ("#M04F", typeof (OverflowException), e.GetType ()); + } + + // ToSqlMoney () + AssertEquals ("#M01G", (decimal)250, Test1.ToSqlMoney ().Value); + AssertEquals ("#M02G", (decimal)0, Test0.ToSqlMoney ().Value); + + try { + SqlMoney test = Test2.ToSqlMoney ().Value; + Fail ("#M03G"); + } catch (Exception e) { + AssertEquals ("#M04G", typeof (OverflowException), e.GetType ()); + } + + // ToSqlSingle () + AssertEquals ("#M01H", (float)250, Test1.ToSqlSingle ().Value); + AssertEquals ("#M02H", (float)0, Test0.ToSqlSingle ().Value); + + try { + SqlSingle test = Test2.ToSqlSingle().Value; + Fail ("#MO3H"); + } catch (Exception e) { + AssertEquals ("#M04H", typeof (OverflowException), e.GetType ()); + } + + // ToSqlString () + AssertEquals ("#M01I", "250", Test1.ToSqlString ().Value); + AssertEquals ("#M02I", "0", Test0.ToSqlString ().Value); + AssertEquals ("#M03I", "6,4E+65", Test2.ToSqlString ().Value); + + // ToString () + AssertEquals ("#M01J", "250", Test1.ToString ()); + AssertEquals ("#M02J", "0", Test0.ToString ()); + AssertEquals ("#M03J", "6,4E+65", Test2.ToString ()); + } + + // OPERATORS + + public void TestArithmeticOperators() + { + SqlDouble Test0 = new SqlDouble (0); + SqlDouble Test1 = new SqlDouble (24e100); + SqlDouble Test2 = new SqlDouble (64e164); + SqlDouble Test3 = new SqlDouble (12e100); + SqlDouble Test4 = new SqlDouble (1e10); + SqlDouble Test5 = new SqlDouble (2e10); + + // "+"-operator + AssertEquals ("#N01", (SqlDouble)3e10, Test4 + Test5); + + try { + SqlDouble test = SqlDouble.MaxValue + SqlDouble.MaxValue; + Fail ("#N02"); + } catch (Exception e) { + AssertEquals ("#N03", typeof (OverflowException), e.GetType ()); + } + + // "/"-operator + AssertEquals ("#N04", (SqlDouble)2, Test1 / Test3); + + try { + SqlDouble test = Test3 / Test0; + Fail ("#N05"); + } catch (Exception e) { + AssertEquals ("#N06", typeof (DivideByZeroException), e.GetType ()); + } + + // "*"-operator + AssertEquals ("#N07", (SqlDouble)2e20, Test4 * Test5); + + try { + SqlDouble test = SqlDouble.MaxValue * Test1; + Fail ("#N08"); + } catch (Exception e) { + AssertEquals ("#N09", typeof (OverflowException), e.GetType ()); + } + + // "-"-operator + AssertEquals ("#N10", (SqlDouble)12e100, Test1 - Test3); + + try { + SqlDouble test = SqlDouble.MinValue - SqlDouble.MaxValue; + Fail ("#N11"); + } catch (Exception e) { + AssertEquals ("#N12", typeof (OverflowException), e.GetType ()); + } + } + + public void TestThanOrEqualOperators() + { + SqlDouble Test1 = new SqlDouble (1e164); + SqlDouble Test2 = new SqlDouble (9.7e100); + SqlDouble Test22 = new SqlDouble (9.7e100); + SqlDouble Test3 = new SqlDouble (2e200); + + // == -operator + Assert ("#O01", (Test2 == Test22).Value); + Assert ("#O02", !(Test1 == Test2).Value); + Assert ("#O03", (Test1 == SqlDouble.Null).IsNull); + + // != -operator + Assert ("#O04", !(Test2 != Test22).Value); + Assert ("#O05", (Test2 != Test3).Value); + Assert ("#O06", (Test1 != Test3).Value); + Assert ("#O07", (Test1 != SqlDouble.Null).IsNull); + + // > -operator + Assert ("#O08", (Test1 > Test2).Value); + Assert ("#O09", !(Test1 > Test3).Value); + Assert ("#O10", !(Test2 > Test22).Value); + Assert ("#O11", (Test1 > SqlDouble.Null).IsNull); + + // >= -operator + Assert ("#O12", !(Test1 >= Test3).Value); + Assert ("#O13", (Test3 >= Test1).Value); + Assert ("#O14", (Test2 >= Test22).Value); + Assert ("#O15", (Test1 >= SqlDouble.Null).IsNull); + + // < -operator + Assert ("#O16", !(Test1 < Test2).Value); + Assert ("#O17", (Test1 < Test3).Value); + Assert ("#O18", !(Test2 < Test22).Value); + Assert ("#O19", (Test1 < SqlDouble.Null).IsNull); + + // <= -operator + Assert ("#O20", (Test1 <= Test3).Value); + Assert ("#O21", !(Test3 <= Test1).Value); + Assert ("#O22", (Test2 <= Test22).Value); + Assert ("#O23", (Test1 <= SqlDouble.Null).IsNull); + } + + public void TestUnaryNegation() + { + SqlDouble Test = new SqlDouble (2000000001); + SqlDouble TestNeg = new SqlDouble (-3000); + + SqlDouble Result = -Test; + AssertEquals ("#P01", (double)(-2000000001), Result.Value); + + Result = -TestNeg; + AssertEquals ("#P02", (double)3000, Result.Value); + } + + public void TestSqlBooleanToSqlDouble() + { + SqlBoolean TestBoolean = new SqlBoolean (true); + SqlDouble Result; + + Result = (SqlDouble)TestBoolean; + + AssertEquals ("#Q01", (double)1, Result.Value); + + Result = (SqlDouble)SqlBoolean.Null; + Assert ("#Q02", Result.IsNull); + } + + public void TestSqlDoubleToDouble() + { + SqlDouble Test = new SqlDouble (12e12); + Double Result = (double)Test; + AssertEquals ("#R01", 12e12, Result); + } + + public void TestSqlStringToSqlDouble() + { + SqlString TestString = new SqlString ("Test string"); + SqlString TestString100 = new SqlString ("100"); + + AssertEquals ("#S01", (double)100, ((SqlDouble)TestString100).Value); + + try { + SqlDouble test = (SqlDouble)TestString; + Fail ("#S02"); + } catch(Exception e) { + AssertEquals ("#S03", typeof (FormatException), e.GetType ()); + } + } + + public void TestDoubleToSqlDouble() + { + double Test1 = 5e64; + SqlDouble Result = (SqlDouble)Test1; + AssertEquals ("#T01", 5e64, Result.Value); + } + + public void TestByteToSqlDouble() + { + short TestShort = 14; + AssertEquals ("#U01", (double)14, ((SqlDouble)TestShort).Value); + } + + public void TestSqlDecimalToSqlDouble() + { + SqlDecimal TestDecimal64 = new SqlDecimal (64); + + AssertEquals ("#V01", (double)64, ((SqlDouble)TestDecimal64).Value); + AssertEquals ("#V02", SqlDouble.Null, ((SqlDouble)SqlDecimal.Null)); + } + + public void TestSqlIntToSqlDouble() + { + SqlInt16 Test64 = new SqlInt16 (64); + SqlInt32 Test640 = new SqlInt32 (640); + SqlInt64 Test64000 = new SqlInt64 (64000); + AssertEquals ("#W01", (double)64, ((SqlDouble)Test64).Value); + AssertEquals ("#W02", (double)640, ((SqlDouble)Test640).Value); + AssertEquals ("#W03", (double)64000, ((SqlDouble)Test64000).Value); + } + + + public void TestSqlMoneyToSqlDouble() + { + SqlMoney TestMoney64 = new SqlMoney(64); + AssertEquals ("#X01", (double)64, ((SqlDouble)TestMoney64).Value); + } + + public void TestSqlSingleToSqlDouble() + { + SqlSingle TestSingle64 = new SqlSingle (64); + AssertEquals ("#Y01", (double)64, ((SqlDouble)TestSingle64).Value); + } + } +} + -- 2.25.1