From: Rodrigo Moya Date: Wed, 9 Oct 2002 17:54:00 +0000 (-0000) Subject: 2002-10-09 Ville Palo (vi64pa@koti.soon.fi) X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=commitdiff_plain;h=c4fb9fb7e85758283be91d20ecb9d42c00fd1b38;p=mono.git 2002-10-09 Ville Palo (vi64pa@koti.soon.fi) * System.Data.SqlTypes/SqlInt16Test.cs: * System.Data.SqlTypes/SqlInt64Test.cs: new test suites. svn path=/trunk/mcs/; revision=8105 --- diff --git a/mcs/class/System.Data/Test/ChangeLog b/mcs/class/System.Data/Test/ChangeLog index 9f5d9b41a5e..71535e38846 100644 --- a/mcs/class/System.Data/Test/ChangeLog +++ b/mcs/class/System.Data/Test/ChangeLog @@ -1,3 +1,8 @@ +2002-10-09 Ville Palo (vi64pa@koti.soon.fi) + + * System.Data.SqlTypes/SqlInt16Test.cs: + * System.Data.SqlTypes/SqlInt64Test.cs: new test suites. + 2002-10-04 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 e49f07d112a..24af29b962a 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs @@ -21,7 +21,9 @@ 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 (SqlInt16Test))); suite.AddTest (new TestSuite (typeof (SqlInt32Test))); + suite.AddTest (new TestSuite (typeof (SqlInt64Test))); return suite; } } diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt16Test.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt16Test.cs new file mode 100644 index 00000000000..179c8fd88ef --- /dev/null +++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt16Test.cs @@ -0,0 +1,645 @@ +// +// SqlInt16Test.cs - NUnit Test Cases for System.Data.SqlTypes.SqlInt16 +// +// 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 SqlInt16Test : TestCase { + + public SqlInt16Test() : base ("System.Data.SqlTypes.SqlInt64") {} + public SqlInt16Test(string name) : base(name) {} + + protected override void TearDown() {} + + protected override void SetUp() {} + + public static ITest Suite { + get { + return new TestSuite(typeof(SqlInt32)); + } + } + + // Test constructor + public void TestCreate() + { + SqlInt16 TestShort = new SqlInt16 (29); + AssertEquals ("Test#1", (short)29, TestShort.Value); + + TestShort = new SqlInt16 (-9000); + AssertEquals ("Test#2", (short)-9000, TestShort.Value); + } + + // Test public fields + public void TestPublicFields() + { + AssertEquals ("Test#1", (SqlInt16)32767, SqlInt16.MaxValue); + AssertEquals ("Test#2", (SqlInt16)(-32768), SqlInt16.MinValue); + Assert ("Test#3", SqlInt16.Null.IsNull); + AssertEquals ("Test#4", (short)0, SqlInt16.Zero.Value); + } + + // Test properties + public void TestProperties() + { + SqlInt16 Test5443 = new SqlInt16 (5443); + SqlInt16 Test1 = new SqlInt16 (1); + Assert ("Test#1", SqlInt16.Null.IsNull); + AssertEquals ("Test#2", (short)5443, Test5443.Value); + AssertEquals ("Test#3", (short)1, Test1.Value); + } + + // PUBLIC METHODS + + public void TestArithmeticMethods() + { + SqlInt16 Test64 = new SqlInt16 (64); + SqlInt16 Test0 = new SqlInt16 (0); + SqlInt16 Test164 = new SqlInt16 (164); + SqlInt16 TestMax = new SqlInt16 (SqlInt16.MaxValue.Value); + + // Add() + AssertEquals ("Test#1", (short)64, SqlInt16.Add (Test64, Test0).Value); + AssertEquals ("Test#2", (short)228, SqlInt16.Add (Test64, Test164).Value); + AssertEquals ("Test#3", (short)164, SqlInt16.Add (Test0, Test164).Value); + AssertEquals ("Test#4", (short)SqlInt16.MaxValue, SqlInt16.Add (TestMax, Test0).Value); + + try { + SqlInt16.Add (TestMax, Test64); + Fail ("Test#5"); + } catch (Exception e) { + AssertEquals ("Test#6", typeof (OverflowException), e.GetType ()); + } + + // Divide() + AssertEquals ("Test#7", (short)2, SqlInt16.Divide (Test164, Test64).Value); + AssertEquals ("Test#8", (short)0, SqlInt16.Divide (Test64, Test164).Value); + try { + SqlInt16.Divide(Test64, Test0); + Fail ("Test#9"); + } catch(Exception e) { + AssertEquals ("Test#10", typeof (DivideByZeroException), e.GetType ()); + } + + // Mod() + AssertEquals ("Test#11", (SqlInt16)36, SqlInt16.Mod (Test164, Test64)); + AssertEquals ("Test#12", (SqlInt16)64, SqlInt16.Mod (Test64, Test164)); + + // Multiply() + AssertEquals ("Test#13", (short)10496, SqlInt16.Multiply (Test64, Test164).Value); + AssertEquals ("Test#14", (short)0, SqlInt16.Multiply (Test64, Test0).Value); + + try { + SqlInt16.Multiply (TestMax, Test64); + Fail ("Test#15"); + } catch(Exception e) { + AssertEquals ("Test#16", typeof (OverflowException), e.GetType ()); + } + + // Subtract() + AssertEquals ("Test#17", (short)100, SqlInt16.Subtract (Test164, Test64).Value); + + try { + SqlInt16.Subtract (SqlInt16.MinValue, Test164); + Fail("Test#18"); + } catch(Exception e) { + AssertEquals ("Test#19", typeof (OverflowException), e.GetType ()); + } + } + + public void TestBitwiseMethods() + { + short MaxValue = SqlInt16.MaxValue.Value; + SqlInt16 TestInt = new SqlInt16 (0); + SqlInt16 TestIntMax = new SqlInt16 (MaxValue); + SqlInt16 TestInt2 = new SqlInt16 (10922); + SqlInt16 TestInt3 = new SqlInt16 (21845); + + // BitwiseAnd + AssertEquals ("Test#1", (short)21845, SqlInt16.BitwiseAnd (TestInt3, TestIntMax).Value); + AssertEquals ("Test#2", (short)0, SqlInt16.BitwiseAnd (TestInt2, TestInt3).Value); + AssertEquals ("Test#3", (short)10922, SqlInt16.BitwiseAnd (TestInt2, TestIntMax).Value); + + //BitwiseOr + AssertEquals ("Test#4", (short)MaxValue, SqlInt16.BitwiseOr (TestInt2, TestInt3).Value); + AssertEquals ("Test#5", (short)21845, SqlInt16.BitwiseOr (TestInt, TestInt3).Value); + AssertEquals ("Test#6", (short)MaxValue, SqlInt16.BitwiseOr (TestIntMax, TestInt2).Value); + } + + public void TestCompareTo() + { + SqlInt16 TestInt4000 = new SqlInt16 (4000); + SqlInt16 TestInt4000II = new SqlInt16 (4000); + SqlInt16 TestInt10 = new SqlInt16 (10); + SqlInt16 TestInt10000 = new SqlInt16 (10000); + SqlString TestString = new SqlString ("This is a test"); + + Assert ("Test#1", TestInt4000.CompareTo (TestInt10) > 0); + Assert ("Test#2", TestInt10.CompareTo (TestInt4000) < 0); + Assert ("Test#3", TestInt4000II.CompareTo (TestInt4000) == 0); + Assert ("Test#4", TestInt4000II.CompareTo (SqlInt16.Null) > 0); + + try { + TestInt10.CompareTo (TestString); + Fail ("Test#5"); + } catch(Exception e) { + AssertEquals ("Test#6", typeof (ArgumentException), e.GetType ()); + } + } + + public void TestEqualsMethod() + { + SqlInt16 Test0 = new SqlInt16 (0); + SqlInt16 Test158 = new SqlInt16 (158); + SqlInt16 Test180 = new SqlInt16 (180); + SqlInt16 Test180II = new SqlInt16 (180); + + Assert ("Test#1", !Test0.Equals (Test158)); + Assert ("Test#2", !Test158.Equals (Test180)); + Assert ("Test#3", !Test180.Equals (new SqlString ("TEST"))); + Assert ("Test#4", Test180.Equals (Test180II)); + } + + public void TestStaticEqualsMethod() + { + SqlInt16 Test34 = new SqlInt16 (34); + SqlInt16 Test34II = new SqlInt16 (34); + SqlInt16 Test15 = new SqlInt16 (15); + + Assert ("Test#1", SqlInt16.Equals (Test34, Test34II).Value); + Assert ("Test#2", !SqlInt16.Equals (Test34, Test15).Value); + Assert ("Test#3", !SqlInt16.Equals (Test15, Test34II).Value); + } + + public void TestGetHashCode() + { + SqlInt16 Test15 = new SqlInt16 (15); + + // FIXME: Better way to test GetHashCode()-methods + AssertEquals ("Test#1", Test15.GetHashCode (), Test15.GetHashCode ()); + } + + public void TestGetType() + { + SqlInt16 Test = new SqlInt16 (84); + AssertEquals ("Test#1", "System.Data.SqlTypes.SqlInt16", Test.GetType ().ToString ()); + } + + public void TestGreaters() + { + SqlInt16 Test10 = new SqlInt16 (10); + SqlInt16 Test10II = new SqlInt16 (10); + SqlInt16 Test110 = new SqlInt16 (110); + + // GreateThan () + Assert ("Test#1", !SqlInt16.GreaterThan (Test10, Test110).Value); + Assert ("Test#2", SqlInt16.GreaterThan (Test110, Test10).Value); + Assert ("Test#3", !SqlInt16.GreaterThan (Test10II, Test10).Value); + + // GreaterTharOrEqual () + Assert ("Test#4", !SqlInt16.GreaterThanOrEqual (Test10, Test110).Value); + Assert ("Test#5", SqlInt16.GreaterThanOrEqual (Test110, Test10).Value); + Assert ("Test#6", SqlInt16.GreaterThanOrEqual (Test10II, Test10).Value); + } + + public void TestLessers() + { + SqlInt16 Test10 = new SqlInt16 (10); + SqlInt16 Test10II = new SqlInt16 (10); + SqlInt16 Test110 = new SqlInt16 (110); + + // LessThan() + Assert ("Test#1", SqlInt16.LessThan (Test10, Test110).Value); + Assert ("Test#2", !SqlInt16.LessThan (Test110, Test10).Value); + Assert ("Test#3", !SqlInt16.LessThan (Test10II, Test10).Value); + + // LessThanOrEqual () + Assert ("Test#4", SqlInt16.LessThanOrEqual (Test10, Test110).Value); + Assert ("Test#5", !SqlInt16.LessThanOrEqual (Test110, Test10).Value); + Assert ("Test#6", SqlInt16.LessThanOrEqual (Test10II, Test10).Value); + Assert ("Test#7", SqlInt16.LessThanOrEqual (Test10II, SqlInt16.Null).IsNull); + } + + public void TestNotEquals() + { + SqlInt16 Test12 = new SqlInt16 (12); + SqlInt16 Test128 = new SqlInt16 (128); + SqlInt16 Test128II = new SqlInt16 (128); + + Assert ("Test#1", SqlInt16.NotEquals (Test12, Test128).Value); + Assert ("Test#2", SqlInt16.NotEquals (Test128, Test12).Value); + Assert ("Test#3", SqlInt16.NotEquals (Test128II, Test12).Value); + Assert ("Test#4", !SqlInt16.NotEquals (Test128II, Test128).Value); + Assert ("Test#5", !SqlInt16.NotEquals (Test128, Test128II).Value); + Assert ("Test#6", SqlInt16.NotEquals (SqlInt16.Null, Test128II).IsNull); + Assert ("Test#7", SqlInt16.NotEquals (SqlInt16.Null, Test128II).IsNull); + } + + public void TestOnesComplement() + { + SqlInt16 Test12 = new SqlInt16(12); + SqlInt16 Test128 = new SqlInt16(128); + + AssertEquals ("Test#1", (SqlInt16)(-13), SqlInt16.OnesComplement (Test12)); + AssertEquals ("Test#2", (SqlInt16)(-129), SqlInt16.OnesComplement (Test128)); + } + + public void TestParse() + { + try { + SqlInt16.Parse (null); + Fail ("Test#1"); + } catch (Exception e) { + AssertEquals ("Test#2", typeof (ArgumentNullException), e.GetType ()); + } + + try { + SqlInt16.Parse ("not-a-number"); + Fail ("Test#3"); + } catch (Exception e) { + AssertEquals ("Test#4", typeof (FormatException), e.GetType ()); + } + + try { + int OverInt = (int)SqlInt16.MaxValue + 1; + SqlInt16.Parse (OverInt.ToString ()); + Fail ("Test#5"); + } catch (Exception e) { + AssertEquals ("Test#6", typeof (OverflowException), e.GetType ()); + } + + AssertEquals("Test#7", (short)150, SqlInt16.Parse ("150").Value); + } + + public void TestConversions() + { + SqlInt16 Test12 = new SqlInt16 (12); + SqlInt16 Test0 = new SqlInt16 (0); + SqlInt16 TestNull = SqlInt16.Null; + SqlInt16 Test1000 = new SqlInt16 (1000); + SqlInt16 Test288 = new SqlInt16(288); + + // ToSqlBoolean () + Assert ("TestA#1", Test12.ToSqlBoolean ().Value); + Assert ("TestA#2", !Test0.ToSqlBoolean ().Value); + Assert ("TestA#3", TestNull.ToSqlBoolean ().IsNull); + + // ToSqlByte () + AssertEquals ("TestB#1", (byte)12, Test12.ToSqlByte ().Value); + AssertEquals ("TestB#2", (byte)0, Test0.ToSqlByte ().Value); + + try { + SqlByte b = (byte)Test1000.ToSqlByte (); + Fail ("TestB#4"); + } catch (Exception e) { + AssertEquals ("TestB#5", typeof (OverflowException), e.GetType ()); + } + + // ToSqlDecimal () + AssertEquals ("TestC#1", (decimal)12, Test12.ToSqlDecimal ().Value); + AssertEquals ("TestC#2", (decimal)0, Test0.ToSqlDecimal ().Value); + AssertEquals ("TestC#3", (decimal)288, Test288.ToSqlDecimal ().Value); + + // ToSqlDouble () + AssertEquals ("TestD#1", (double)12, Test12.ToSqlDouble ().Value); + AssertEquals ("TestD#2", (double)0, Test0.ToSqlDouble ().Value); + AssertEquals ("TestD#3", (double)1000, Test1000.ToSqlDouble ().Value); + + // ToSqlInt32 () + AssertEquals ("TestE#1", (int)12, Test12.ToSqlInt32 ().Value); + AssertEquals ("TestE#2", (int)0, Test0.ToSqlInt32 ().Value); + AssertEquals ("TestE#3", (int)288, Test288.ToSqlInt32().Value); + + // ToSqlInt64 () + AssertEquals ("TestF#1", (long)12, Test12.ToSqlInt64 ().Value); + AssertEquals ("TestF#2", (long)0, Test0.ToSqlInt64 ().Value); + AssertEquals ("TestF#3", (long)288, Test288.ToSqlInt64 ().Value); + + // ToSqlMoney () + AssertEquals ("TestG#1", (decimal)12, Test12.ToSqlMoney ().Value); + AssertEquals ("TestG#2", (decimal)0, Test0.ToSqlMoney ().Value); + AssertEquals ("TestG#3", (decimal)288, Test288.ToSqlMoney ().Value); + + // ToSqlSingle () + AssertEquals ("TestH#1", (float)12, Test12.ToSqlSingle ().Value); + AssertEquals ("TestH#2", (float)0, Test0.ToSqlSingle ().Value); + AssertEquals ("TestH#3", (float)288, Test288.ToSqlSingle().Value); + + // ToSqlString () + AssertEquals ("TestI#1", "12", Test12.ToSqlString ().Value); + AssertEquals ("TestI#2", "0", Test0.ToSqlString ().Value); + AssertEquals ("TestI#3", "288", Test288.ToSqlString ().Value); + + // ToString () + AssertEquals ("TestJ#1", "12", Test12.ToString ()); + AssertEquals ("TestJ#2", "0", Test0.ToString ()); + AssertEquals ("TestJ#3", "288", Test288.ToString ()); + } + + + public void TestXor() + { + SqlInt16 Test14 = new SqlInt16 (14); + SqlInt16 Test58 = new SqlInt16 (58); + SqlInt16 Test130 = new SqlInt16 (130); + SqlInt16 TestMax = new SqlInt16 (SqlInt16.MaxValue.Value); + SqlInt16 Test0 = new SqlInt16 (0); + + AssertEquals ("Test#1", (short)52, SqlInt16.Xor (Test14, Test58).Value); + AssertEquals ("Test#2", (short)140, SqlInt16.Xor (Test14, Test130).Value); + AssertEquals ("Test#3", (short)184, SqlInt16.Xor (Test58, Test130).Value); + AssertEquals ("Test#4", (short)0, SqlInt16.Xor (TestMax, TestMax).Value); + AssertEquals ("Test#5", TestMax.Value, SqlInt16.Xor (TestMax, Test0).Value); + } + + // OPERATORS + + public void TestArithmeticOperators() + { + SqlInt16 Test24 = new SqlInt16 (24); + SqlInt16 Test64 = new SqlInt16 (64); + SqlInt16 Test2550 = new SqlInt16 (2550); + SqlInt16 Test0 = new SqlInt16 (0); + + // "+"-operator + AssertEquals ("TestA#1", (SqlInt16)2614,Test2550 + Test64); + try { + SqlInt16 result = Test64 + SqlInt16.MaxValue; + Fail ("TestA#2"); + } catch (Exception e) { + AssertEquals ("TestA#3", typeof (OverflowException), e.GetType ()); + } + + // "/"-operator + AssertEquals ("TestB#1", (SqlInt16)39, Test2550 / Test64); + AssertEquals ("TestB#2", (SqlInt16)0, Test24 / Test64); + + try { + SqlInt16 result = Test2550 / Test0; + Fail ("TestB#3"); + } catch (Exception e) { + AssertEquals ("TestB#4", typeof (DivideByZeroException), e.GetType ()); + } + + // "*"-operator + AssertEquals ("TestC#1", (SqlInt16)1536, Test64 * Test24); + + try { + SqlInt16 test = (SqlInt16.MaxValue * Test64); + Fail ("TestC#2"); + } catch (Exception e) { + AssertEquals ("TestC#3", typeof (OverflowException), e.GetType ()); + } + + // "-"-operator + AssertEquals ("TestD#1", (SqlInt16)2526, Test2550 - Test24); + + try { + SqlInt16 test = SqlInt16.MinValue - Test64; + Fail ("TestD#2"); + } catch (Exception e) { + AssertEquals ("OverflowException", typeof (OverflowException), e.GetType ()); + } + + // "%"-operator + AssertEquals ("TestE#1", (SqlInt16)54, Test2550 % Test64); + AssertEquals ("TestE#2", (SqlInt16)24, Test24 % Test64); + AssertEquals ("TestE#1", (SqlInt16)0, new SqlInt16 (100) % new SqlInt16 (10)); + } + + public void TestBitwiseOperators() + { + SqlInt16 Test2 = new SqlInt16 (2); + SqlInt16 Test4 = new SqlInt16 (4); + SqlInt16 Test2550 = new SqlInt16 (2550); + + // & -operator + AssertEquals ("TestA#1", (SqlInt16)0, Test2 & Test4); + AssertEquals ("TestA#2", (SqlInt16)2, Test2 & Test2550); + AssertEquals ("TestA#3", (SqlInt16)0, SqlInt16.MaxValue & SqlInt16.MinValue); + + // | -operator + AssertEquals ("TestB#1", (SqlInt16)6,Test2 | Test4); + AssertEquals ("TestB#2", (SqlInt16)2550, Test2 | Test2550); + AssertEquals ("TestB#3", (SqlInt16)(-1), SqlInt16.MinValue | SqlInt16.MaxValue); + + // ^ -operator + AssertEquals("TestC#1", (SqlInt16)2546, (Test2550 ^ Test4)); + AssertEquals("TestC#2", (SqlInt16)6, (Test2 ^ Test4)); + } + + public void TestThanOrEqualOperators() + { + SqlInt16 Test165 = new SqlInt16 (165); + SqlInt16 Test100 = new SqlInt16 (100); + SqlInt16 Test100II = new SqlInt16 (100); + SqlInt16 Test255 = new SqlInt16 (2550); + + // == -operator + Assert ("TestA#1", (Test100 == Test100II).Value); + Assert ("TestA#2", !(Test165 == Test100).Value); + Assert ("TestA#3", (Test165 == SqlInt16.Null).IsNull); + + // != -operator + Assert ("TestB#1", !(Test100 != Test100II).Value); + Assert ("TestB#2", (Test100 != Test255).Value); + Assert ("TestB#3", (Test165 != Test255).Value); + Assert ("TestB#4", (Test165 != SqlInt16.Null).IsNull); + + // > -operator + Assert ("TestC#1", (Test165 > Test100).Value); + Assert ("TestC#2", !(Test165 > Test255).Value); + Assert ("TestC#3", !(Test100 > Test100II).Value); + Assert ("TestC#4", (Test165 > SqlInt16.Null).IsNull); + + // >= -operator + Assert ("TestD#1", !(Test165 >= Test255).Value); + Assert ("TestD#2", (Test255 >= Test165).Value); + Assert ("TestD#3", (Test100 >= Test100II).Value); + Assert ("TestD#4", (Test165 >= SqlInt16.Null).IsNull); + + // < -operator + Assert ("TestE#1", !(Test165 < Test100).Value); + Assert ("TestE#2", (Test165 < Test255).Value); + Assert ("TestE#3", !(Test100 < Test100II).Value); + Assert ("TestE#4", (Test165 < SqlInt16.Null).IsNull); + + // <= -operator + Assert ("TestF#1", (Test165 <= Test255).Value); + Assert ("TestF#2", !(Test255 <= Test165).Value); + Assert ("TestF#3", (Test100 <= Test100II).Value); + Assert ("TestF#4", (Test165 <= SqlInt16.Null).IsNull); + } + + public void TestOnesComplementOperator() + { + SqlInt16 Test12 = new SqlInt16 (12); + SqlInt16 Test128 = new SqlInt16 (128); + + AssertEquals ("Test#1", (SqlInt16)(-13), ~Test12); + AssertEquals ("Test#2", (SqlInt16)(-129), ~Test128); + AssertEquals ("Test#3", SqlInt16.Null, ~SqlInt16.Null); + } + + public void TestUnaryNegation() + { + SqlInt16 Test = new SqlInt16 (2000); + SqlInt16 TestNeg = new SqlInt16 (-3000); + + SqlInt16 Result = -Test; + AssertEquals ("Test#1", (short)(-2000), Result.Value); + + Result = -TestNeg; + AssertEquals ("Test#2", (short)3000, Result.Value); + } + + public void TestSqlBooleanToSqlInt16() + { + SqlBoolean TestBoolean = new SqlBoolean (true); + SqlInt16 Result; + + Result = (SqlInt16)TestBoolean; + + AssertEquals ("Test#1", (short)1, Result.Value); + + Result = (SqlInt16)SqlBoolean.Null; + Assert ("Test#2", Result.IsNull); + } + + public void TestSqlDecimalToSqlInt16() + { + SqlDecimal TestDecimal64 = new SqlDecimal (64); + SqlDecimal TestDecimal900 = new SqlDecimal (90000); + + AssertEquals ("Test#1", (short)64, ((SqlInt16)TestDecimal64).Value); + AssertEquals ("Test#2", SqlInt16.Null, ((SqlInt16)SqlDecimal.Null)); + + try { + SqlInt16 test = (SqlInt16)TestDecimal900; + Fail ("Test#3"); + } catch (Exception e) { + AssertEquals("Test#4", typeof(OverflowException), e.GetType ()); + } + } + + public void TestSqlDoubleToSqlInt16() + { + SqlDouble TestDouble64 = new SqlDouble (64); + SqlDouble TestDouble900 = new SqlDouble (90000); + + AssertEquals ("Test#1", (short)64, ((SqlInt16)TestDouble64).Value); + AssertEquals ("Test#2", SqlInt16.Null, ((SqlInt16)SqlDouble.Null)); + + try { + SqlInt16 test = (SqlInt16)TestDouble900; + Fail ("Test#3"); + } catch (Exception e) { + AssertEquals("Test#4", typeof (OverflowException), e.GetType ()); + } + } + + public void TestSqlIntToInt16() + { + SqlInt16 Test = new SqlInt16(12); + Int16 Result = (Int16)Test; + AssertEquals("Test#1", (short)12, Result); + } + + public void TestSqlInt32ToSqlInt16() + { + SqlInt32 Test64 = new SqlInt32 (64); + SqlInt32 Test900 = new SqlInt32 (90000); + + AssertEquals ("Test#1", (short)64, ((SqlInt16)Test64).Value); + + try { + SqlInt16 test = (SqlInt16)Test900; + Fail ("Test#2"); + } catch (Exception e) { + AssertEquals ("Test#3", typeof (OverflowException), e.GetType ()); + } + } + + public void TestSqlInt64ToSqlInt16() + { + SqlInt64 Test64 = new SqlInt64 (64); + SqlInt64 Test900 = new SqlInt64 (90000); + + AssertEquals ("Test#1", (short)64, ((SqlInt16)Test64).Value); + + try { + SqlInt16 test = (SqlInt16)Test900; + Fail ("Test#2"); + } catch (Exception e) { + AssertEquals("Test#3", typeof (OverflowException), e.GetType ()); + } + } + + public void TestSqlMoneyToSqlInt16() + { + SqlMoney TestMoney64 = new SqlMoney(64); + SqlMoney TestMoney900 = new SqlMoney(90000); + + AssertEquals ("Test#1", (short)64, ((SqlInt16)TestMoney64).Value); + + try { + SqlInt16 test = (SqlInt16)TestMoney900; + Fail ("Test#2"); + } catch (Exception e) { + AssertEquals("test#3", typeof (OverflowException), e.GetType ()); + } + } + + public void TestSqlSingleToSqlInt16() + { + SqlSingle TestSingle64 = new SqlSingle(64); + SqlSingle TestSingle900 = new SqlSingle(90000); + + AssertEquals("Test#1", (short)64, ((SqlInt16)TestSingle64).Value); + + try { + SqlInt16 test = (SqlInt16)TestSingle900; + Fail ("Test#2"); + } catch (Exception e) { + AssertEquals ("Test#3", typeof (OverflowException), e.GetType ()); + } + } + + public void TestSqlStringToSqlInt16() + { + SqlString TestString = new SqlString("Test string"); + SqlString TestString100 = new SqlString("100"); + SqlString TestString1000 = new SqlString("100000"); + + AssertEquals ("Test#1", (short)100, ((SqlInt16)TestString100).Value); + + try { + SqlInt16 test = (SqlInt16)TestString1000; + Fail ("Test#2"); + } catch(Exception e) { + AssertEquals ("Test#3", typeof (OverflowException), e.GetType ()); + } + + try { + SqlInt16 test = (SqlInt16)TestString; + Fail ("Test#3"); + } catch(Exception e) { + AssertEquals ("Test#4", typeof (FormatException), e.GetType ()); + } + } + + public void TestByteToSqlInt16() + { + short TestShort = 14; + AssertEquals ("Test#1", (short)14, ((SqlInt16)TestShort).Value); + } + } +} + diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt64Test.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt64Test.cs new file mode 100644 index 00000000000..9f7a28b0fb1 --- /dev/null +++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt64Test.cs @@ -0,0 +1,609 @@ +// +// SqlInt64Test.cs - NUnit Test Cases for System.Data.SqlTypes.SqlInt64 +// +// 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 SqlInt64Test : TestCase { + + public SqlInt64Test() : base ("System.Data.SqlTypes.SqlInt64") {} + public SqlInt64Test(string name) : base(name) {} + + protected override void TearDown() {} + + protected override void SetUp() {} + + public static ITest Suite { + get { + return new TestSuite(typeof(SqlInt64)); + } + } + + // Test constructor + public void TestCreate() + { + SqlInt64 TestLong = new SqlInt64 (29); + AssertEquals ("#A01", (long)29, TestLong.Value); + + TestLong = new SqlInt64 (-9000); + AssertEquals ("#A02", (long)-9000, TestLong.Value); + } + + // Test public fields + public void TestPublicFields() + { + AssertEquals ("#B01", (long)9223372036854775807, SqlInt64.MaxValue.Value); + AssertEquals ("#B02", (long)(-9223372036854775808), SqlInt64.MinValue.Value); + Assert ("#B03", SqlInt64.Null.IsNull); + AssertEquals ("#B04", (long)0, SqlInt64.Zero.Value); + } + + // Test properties + public void TestProperties() + { + SqlInt64 Test5443 = new SqlInt64 (5443); + SqlInt64 Test1 = new SqlInt64 (1); + + Assert ("#C01", SqlInt64.Null.IsNull); + AssertEquals ("#C02", (long)5443, Test5443.Value); + AssertEquals ("#C03", (long)1, Test1.Value); + } + + // PUBLIC METHODS + + public void TestArithmeticMethods() + { + SqlInt64 Test64 = new SqlInt64 (64); + SqlInt64 Test0 = new SqlInt64 (0); + SqlInt64 Test164 = new SqlInt64 (164); + SqlInt64 TestMax = new SqlInt64 (SqlInt64.MaxValue.Value); + + // Add() + AssertEquals ("#D01", (long)64, SqlInt64.Add (Test64, Test0).Value); + AssertEquals ("#D02", (long)228, SqlInt64.Add (Test64, Test164).Value); + AssertEquals ("#D03", (long)164, SqlInt64.Add (Test0, Test164).Value); + AssertEquals ("#D04", (long)SqlInt64.MaxValue, SqlInt64.Add (TestMax, Test0).Value); + + try { + SqlInt64.Add (TestMax, Test64); + Fail ("#D05"); + } catch (Exception e) { + AssertEquals ("#D06", typeof (OverflowException), e.GetType ()); + } + + // Divide() + AssertEquals ("#D07", (long)2, SqlInt64.Divide (Test164, Test64).Value); + AssertEquals ("#D08", (long)0, SqlInt64.Divide (Test64, Test164).Value); + + try { + SqlInt64.Divide(Test64, Test0); + Fail ("#D09"); + } catch(Exception e) { + AssertEquals ("#D10", typeof (DivideByZeroException), e.GetType ()); + } + + // Mod() + AssertEquals ("#D11", (SqlInt64)36, SqlInt64.Mod (Test164, Test64)); + AssertEquals ("#D12", (SqlInt64)64, SqlInt64.Mod (Test64, Test164)); + + // Multiply() + AssertEquals ("#D13", (long)10496, SqlInt64.Multiply (Test64, Test164).Value); + AssertEquals ("#D14", (long)0, SqlInt64.Multiply (Test64, Test0).Value); + + try { + SqlInt64.Multiply (TestMax, Test64); + Fail ("#D15"); + } catch(Exception e) { + AssertEquals ("#D16", typeof (OverflowException), e.GetType ()); + } + + // Subtract() + AssertEquals ("#D17", (long)100, SqlInt64.Subtract (Test164, Test64).Value); + + try { + SqlInt64.Subtract (SqlInt64.MinValue, Test164); + Fail ("#D18"); + } catch(Exception e) { + AssertEquals ("#D19", typeof (OverflowException), e.GetType ()); + } + } + + public void TestBitwiseMethods() + { + long MaxValue = SqlInt64.MaxValue.Value; + SqlInt64 TestInt = new SqlInt64 (0); + SqlInt64 TestIntMax = new SqlInt64 (MaxValue); + SqlInt64 TestInt2 = new SqlInt64 (10922); + SqlInt64 TestInt3 = new SqlInt64 (21845); + + // BitwiseAnd + AssertEquals ("#E01", (long)21845, SqlInt64.BitwiseAnd (TestInt3, TestIntMax).Value); + AssertEquals ("#E02", (long)0, SqlInt64.BitwiseAnd (TestInt2, TestInt3).Value); + AssertEquals ("#E03", (long)10922, SqlInt64.BitwiseAnd (TestInt2, TestIntMax).Value); + + //BitwiseOr + AssertEquals ("#E04", (long)21845, SqlInt64.BitwiseOr (TestInt, TestInt3).Value); + AssertEquals ("#E05", (long)MaxValue, SqlInt64.BitwiseOr (TestIntMax, TestInt2).Value); + } + + public void TestCompareTo() + { + SqlInt64 TestInt4000 = new SqlInt64 (4000); + SqlInt64 TestInt4000II = new SqlInt64 (4000); + SqlInt64 TestInt10 = new SqlInt64 (10); + SqlInt64 TestInt10000 = new SqlInt64 (10000); + SqlString TestString = new SqlString ("This is a test"); + + Assert ("#F01", TestInt4000.CompareTo (TestInt10) > 0); + Assert ("#F02", TestInt10.CompareTo (TestInt4000) < 0); + Assert ("#F03", TestInt4000II.CompareTo (TestInt4000) == 0); + Assert ("#F04", TestInt4000II.CompareTo (SqlInt64.Null) > 0); + + try { + TestInt10.CompareTo (TestString); + Fail("#F05"); + } catch(Exception e) { + AssertEquals ("#F06", typeof (ArgumentException), e.GetType ()); + } + } + + public void TestEqualsMethod() + { + SqlInt64 Test0 = new SqlInt64 (0); + SqlInt64 Test158 = new SqlInt64 (158); + SqlInt64 Test180 = new SqlInt64 (180); + SqlInt64 Test180II = new SqlInt64 (180); + + Assert ("#G01", !Test0.Equals (Test158)); + Assert ("#G01", !Test158.Equals (Test180)); + Assert ("#G03", !Test180.Equals (new SqlString ("TEST"))); + Assert ("#G04", Test180.Equals (Test180II)); + } + + public void TestStaticEqualsMethod() + { + SqlInt64 Test34 = new SqlInt64 (34); + SqlInt64 Test34II = new SqlInt64 (34); + SqlInt64 Test15 = new SqlInt64 (15); + + Assert ("#H01", SqlInt64.Equals (Test34, Test34II).Value); + Assert ("#H02", !SqlInt64.Equals (Test34, Test15).Value); + Assert ("#H03", !SqlInt64.Equals (Test15, Test34II).Value); + } + + public void TestGetHashCode() + { + SqlInt64 Test15 = new SqlInt64 (15); + + // FIXME: Better way to test HashCode + AssertEquals ("#I01", (int)15, Test15.GetHashCode ()); + } + + public void TestGetType() + { + SqlInt64 Test = new SqlInt64 (84); + AssertEquals ("#J01", "System.Data.SqlTypes.SqlInt64", Test.GetType ().ToString ()); + } + + public void TestGreaters() + { + SqlInt64 Test10 = new SqlInt64 (10); + SqlInt64 Test10II = new SqlInt64 (10); + SqlInt64 Test110 = new SqlInt64 (110); + + // GreateThan () + Assert ("#K01", !SqlInt64.GreaterThan (Test10, Test110).Value); + Assert ("#K02", SqlInt64.GreaterThan (Test110, Test10).Value); + Assert ("#K03", !SqlInt64.GreaterThan (Test10II, Test10).Value); + + // GreaterTharOrEqual () + Assert ("#K04", !SqlInt64.GreaterThanOrEqual (Test10, Test110).Value); + Assert ("#K05", SqlInt64.GreaterThanOrEqual (Test110, Test10).Value); + Assert ("#K06", SqlInt64.GreaterThanOrEqual (Test10II, Test10).Value); + } + + public void TestLessers() + { + SqlInt64 Test10 = new SqlInt64 (10); + SqlInt64 Test10II = new SqlInt64 (10); + SqlInt64 Test110 = new SqlInt64 (110); + + // LessThan() + Assert ("#L01", SqlInt64.LessThan (Test10, Test110).Value); + Assert ("#L02", !SqlInt64.LessThan (Test110, Test10).Value); + Assert ("#L03", !SqlInt64.LessThan (Test10II, Test10).Value); + + // LessThanOrEqual () + Assert ("#L04", SqlInt64.LessThanOrEqual (Test10, Test110).Value); + Assert ("#L05", !SqlInt64.LessThanOrEqual (Test110, Test10).Value); + Assert ("#L06", SqlInt64.LessThanOrEqual (Test10II, Test10).Value); + Assert ("#L07", SqlInt64.LessThanOrEqual (Test10II, SqlInt64.Null).IsNull); + } + + public void TestNotEquals() + { + SqlInt64 Test12 = new SqlInt64 (12); + SqlInt64 Test128 = new SqlInt64 (128); + SqlInt64 Test128II = new SqlInt64 (128); + + Assert ("#M01", SqlInt64.NotEquals (Test12, Test128).Value); + Assert ("#M02", SqlInt64.NotEquals (Test128, Test12).Value); + Assert ("#M03", SqlInt64.NotEquals (Test128II, Test12).Value); + Assert ("#M04", !SqlInt64.NotEquals (Test128II, Test128).Value); + Assert ("#M05", !SqlInt64.NotEquals (Test128, Test128II).Value); + Assert ("#M06", SqlInt64.NotEquals (SqlInt64.Null, Test128II).IsNull); + Assert ("#M07", SqlInt64.NotEquals (SqlInt64.Null, Test128II).IsNull); + } + + public void TestOnesComplement() + { + SqlInt64 Test12 = new SqlInt64(12); + SqlInt64 Test128 = new SqlInt64(128); + + AssertEquals ("#N01", (SqlInt64)(-13), SqlInt64.OnesComplement (Test12)); + AssertEquals ("#N02", (SqlInt64)(-129), SqlInt64.OnesComplement (Test128)); + } + + public void TestParse() + { + try { + SqlInt64.Parse (null); + Fail ("#O01"); + } catch (Exception e) { + AssertEquals ("#O02", typeof (ArgumentNullException), e.GetType ()); + } + + try { + SqlInt64.Parse ("not-a-number"); + Fail ("#O03"); + } catch (Exception e) { + AssertEquals ("#O04", typeof (FormatException), e.GetType ()); + } + + try { + SqlInt64.Parse ("1000000000000000000000000000"); + Fail ("#O05"); + } catch (Exception e) { + AssertEquals ("#O06", typeof (OverflowException), e.GetType ()); + } + + AssertEquals("#O07", (long)150, SqlInt64.Parse ("150").Value); + } + + public void TestConversions() + { + SqlInt64 Test12 = new SqlInt64 (12); + SqlInt64 Test0 = new SqlInt64 (0); + SqlInt64 TestNull = SqlInt64.Null; + SqlInt64 Test1000 = new SqlInt64 (1000); + SqlInt64 Test288 = new SqlInt64(288); + + // ToSqlBoolean () + Assert ("#P01", Test12.ToSqlBoolean ().Value); + Assert ("#P02", !Test0.ToSqlBoolean ().Value); + Assert ("#P03", TestNull.ToSqlBoolean ().IsNull); + + // ToSqlByte () + AssertEquals ("#P04", (byte)12, Test12.ToSqlByte ().Value); + AssertEquals ("#P05", (byte)0, Test0.ToSqlByte ().Value); + + try { + SqlByte b = (byte)Test1000.ToSqlByte (); + Fail ("#P06"); + } catch (Exception e) { + AssertEquals ("#P07", typeof (OverflowException), e.GetType ()); + } + + // ToSqlDecimal () + AssertEquals ("#P08", (decimal)12, Test12.ToSqlDecimal ().Value); + AssertEquals ("#P09", (decimal)0, Test0.ToSqlDecimal ().Value); + AssertEquals ("#P10", (decimal)288, Test288.ToSqlDecimal ().Value); + + // ToSqlDouble () + AssertEquals ("#P11", (double)12, Test12.ToSqlDouble ().Value); + AssertEquals ("#P12", (double)0, Test0.ToSqlDouble ().Value); + AssertEquals ("#P13", (double)1000, Test1000.ToSqlDouble ().Value); + + // ToSqlInt32 () + AssertEquals ("#P14", (int)12, Test12.ToSqlInt32 ().Value); + AssertEquals ("#P15", (int)0, Test0.ToSqlInt32 ().Value); + AssertEquals ("#P16", (int)288, Test288.ToSqlInt32().Value); + + // ToSqlInt16 () + AssertEquals ("#P17", (short)12, Test12.ToSqlInt16 ().Value); + AssertEquals ("#P18", (short)0, Test0.ToSqlInt16 ().Value); + AssertEquals ("#P19", (short)288, Test288.ToSqlInt16 ().Value); + + // ToSqlMoney () + AssertEquals ("#P20", (decimal)12, Test12.ToSqlMoney ().Value); + AssertEquals ("#P21", (decimal)0, Test0.ToSqlMoney ().Value); + AssertEquals ("#P22", (decimal)288, Test288.ToSqlMoney ().Value); + + // ToSqlSingle () + AssertEquals ("#P23", (float)12, Test12.ToSqlSingle ().Value); + AssertEquals ("#P24", (float)0, Test0.ToSqlSingle ().Value); + AssertEquals ("#P25", (float)288, Test288.ToSqlSingle().Value); + + // ToSqlString () + AssertEquals ("#P26", "12", Test12.ToSqlString ().Value); + AssertEquals ("#P27", "0", Test0.ToSqlString ().Value); + AssertEquals ("#P28", "288", Test288.ToSqlString ().Value); + + // ToString () + AssertEquals ("#P29", "12", Test12.ToString ()); + AssertEquals ("#P30", "0", Test0.ToString ()); + AssertEquals ("#P31", "288", Test288.ToString ()); + } + + public void TestXor() + { + SqlInt64 Test14 = new SqlInt64 (14); + SqlInt64 Test58 = new SqlInt64 (58); + SqlInt64 Test130 = new SqlInt64 (130); + SqlInt64 TestMax = new SqlInt64 (SqlInt64.MaxValue.Value); + SqlInt64 Test0 = new SqlInt64 (0); + + AssertEquals ("#Q01", (long)52, SqlInt64.Xor (Test14, Test58).Value); + AssertEquals ("#Q02", (long)140, SqlInt64.Xor (Test14, Test130).Value); + AssertEquals ("#Q03", (long)184, SqlInt64.Xor (Test58, Test130).Value); + AssertEquals ("#Q04", (long)0, SqlInt64.Xor (TestMax, TestMax).Value); + AssertEquals ("#Q05", TestMax.Value, SqlInt64.Xor (TestMax, Test0).Value); + } + + // OPERATORS + + public void TestArithmeticOperators() + { + SqlInt64 Test24 = new SqlInt64 (24); + SqlInt64 Test64 = new SqlInt64 (64); + SqlInt64 Test2550 = new SqlInt64 (2550); + SqlInt64 Test0 = new SqlInt64 (0); + + // "+"-operator + AssertEquals ("#R01", (SqlInt64)2614,Test2550 + Test64); + try { + SqlInt64 result = Test64 + SqlInt64.MaxValue; + Fail ("#R02"); + } catch (Exception e) { + AssertEquals ("#R03", typeof (OverflowException), e.GetType ()); + } + + // "/"-operator + AssertEquals ("#R04", (SqlInt64)39, Test2550 / Test64); + AssertEquals ("#R05", (SqlInt64)0, Test24 / Test64); + + try { + SqlInt64 result = Test2550 / Test0; + Fail ("#R06"); + } catch (Exception e) { + AssertEquals ("#R07", typeof (DivideByZeroException), e.GetType ()); + } + + // "*"-operator + AssertEquals ("#R08", (SqlInt64)1536, Test64 * Test24); + + try { + SqlInt64 test = (SqlInt64.MaxValue * Test64); + Fail ("TestC#2"); + } catch (Exception e) { + AssertEquals ("#R08", typeof (OverflowException), e.GetType ()); + } + + // "-"-operator + AssertEquals ("#R09", (SqlInt64)2526, Test2550 - Test24); + + try { + SqlInt64 test = SqlInt64.MinValue - Test64; + Fail ("#R10"); + } catch (Exception e) { + AssertEquals ("#R11", typeof (OverflowException), e.GetType ()); + } + + // "%"-operator + AssertEquals ("#R12", (SqlInt64)54, Test2550 % Test64); + AssertEquals ("#R13", (SqlInt64)24, Test24 % Test64); + AssertEquals ("#R14", (SqlInt64)0, new SqlInt64 (100) % new SqlInt64 (10)); + } + + public void TestBitwiseOperators() + { + SqlInt64 Test2 = new SqlInt64 (2); + SqlInt64 Test4 = new SqlInt64 (4); + + SqlInt64 Test2550 = new SqlInt64 (2550); + + // & -operator + AssertEquals ("#S01", (SqlInt64)0, Test2 & Test4); + AssertEquals ("#S02", (SqlInt64)2, Test2 & Test2550); + AssertEquals ("#S03", (SqlInt64)0, SqlInt64.MaxValue & SqlInt64.MinValue); + + // | -operator + AssertEquals ("#S04", (SqlInt64)6,Test2 | Test4); + AssertEquals ("#S05", (SqlInt64)2550, Test2 | Test2550); + AssertEquals ("#S06", (SqlInt64)(-1), SqlInt64.MinValue | SqlInt64.MaxValue); + + // ^ -operator + AssertEquals("#S07", (SqlInt64)2546, (Test2550 ^ Test4)); + AssertEquals("#S08", (SqlInt64)6, (Test2 ^ Test4)); + } + + public void TestThanOrEqualOperators() + { + SqlInt64 Test165 = new SqlInt64 (165); + SqlInt64 Test100 = new SqlInt64 (100); + SqlInt64 Test100II = new SqlInt64 (100); + SqlInt64 Test255 = new SqlInt64 (2550); + + // == -operator + Assert ("#T01", (Test100 == Test100II).Value); + Assert ("#T02", !(Test165 == Test100).Value); + Assert ("#T03", (Test165 == SqlInt64.Null).IsNull); + + // != -operator + Assert ("#T04", !(Test100 != Test100II).Value); + Assert ("#T05", (Test100 != Test255).Value); + Assert ("#T06", (Test165 != Test255).Value); + Assert ("#T07", (Test165 != SqlInt64.Null).IsNull); + + // > -operator + Assert ("#T08", (Test165 > Test100).Value); + Assert ("#T09", !(Test165 > Test255).Value); + Assert ("#T10", !(Test100 > Test100II).Value); + Assert ("#T11", (Test165 > SqlInt64.Null).IsNull); + + // >= -operator + Assert ("#T12", !(Test165 >= Test255).Value); + Assert ("#T13", (Test255 >= Test165).Value); + Assert ("#T14", (Test100 >= Test100II).Value); + Assert ("#T15", (Test165 >= SqlInt64.Null).IsNull); + + // < -operator + Assert ("#T16", !(Test165 < Test100).Value); + Assert ("#T17", (Test165 < Test255).Value); + Assert ("#T18", !(Test100 < Test100II).Value); + Assert ("#T19", (Test165 < SqlInt64.Null).IsNull); + + // <= -operator + Assert ("#T20", (Test165 <= Test255).Value); + Assert ("#T21", !(Test255 <= Test165).Value); + Assert ("#T22", (Test100 <= Test100II).Value); + Assert ("#T23", (Test165 <= SqlInt64.Null).IsNull); + } + + public void TestOnesComplementOperator() + { + SqlInt64 Test12 = new SqlInt64 (12); + SqlInt64 Test128 = new SqlInt64 (128); + + AssertEquals ("#V01", (SqlInt64)(-13), ~Test12); + AssertEquals ("#V02", (SqlInt64)(-129), ~Test128); + AssertEquals ("#V03", SqlInt64.Null, ~SqlInt64.Null); + } + + public void TestUnaryNegation() + { + SqlInt64 Test = new SqlInt64 (2000); + SqlInt64 TestNeg = new SqlInt64 (-3000); + + SqlInt64 Result = -Test; + AssertEquals ("#W01", (long)(-2000), Result.Value); + + Result = -TestNeg; + AssertEquals ("#W02", (long)3000, Result.Value); + } + + public void TestSqlBooleanToSqlInt64() + { + SqlBoolean TestBoolean = new SqlBoolean (true); + SqlInt64 Result; + + Result = (SqlInt64)TestBoolean; + + AssertEquals ("#X01", (long)1, Result.Value); + + Result = (SqlInt64)SqlBoolean.Null; + Assert ("#X02", Result.IsNull); + } + + public void TestSqlDecimalToSqlInt64() + { + SqlDecimal TestDecimal64 = new SqlDecimal (64); + SqlDecimal TestDecimal900 = new SqlDecimal (90000); + + AssertEquals("#Y01", (long)64, ((SqlInt64)TestDecimal64).Value); + AssertEquals("#Y02", SqlInt64.Null, ((SqlInt64)SqlDecimal.Null)); + + try { + SqlInt64 test = (SqlInt64)SqlDecimal.MaxValue; + Fail("#Y03"); + } catch (Exception e) { + AssertEquals("#Y04", typeof(OverflowException), e.GetType()); + } + } + + public void TestSqlDoubleToSqlInt64() + { + SqlDouble TestDouble64 = new SqlDouble (64); + SqlDouble TestDouble900 = new SqlDouble (90000); + + AssertEquals ("#Z01", (long)64, ((SqlInt64)TestDouble64).Value); + AssertEquals ("#Z02", SqlInt64.Null, ((SqlInt64)SqlDouble.Null)); + + try { + SqlInt64 test = (SqlInt64)SqlDouble.MaxValue; + Fail ("#Z03"); + } catch (Exception e) { + AssertEquals("#Z04", typeof (OverflowException), e.GetType ()); + } + } + + public void TestSql64IntToInt64() + { + SqlInt64 Test = new SqlInt64 (12); + Int64 Result = (Int64)Test; + AssertEquals ("#AA01", (long)12, Result); + } + + public void TestSqlInt32ToSqlInt64() + { + SqlInt32 Test64 = new SqlInt32 (64); + AssertEquals ("#AB01", (long)64, ((SqlInt64)Test64).Value); + } + + public void TestSqlInt16ToSqlInt64() + { + SqlInt16 Test64 = new SqlInt16 (64); + AssertEquals ("#AC01", (long)64, ((SqlInt64)Test64).Value); + } + + public void TestSqlMoneyToSqlInt64() + { + SqlMoney TestMoney64 = new SqlMoney(64); + AssertEquals ("#AD01", (long)64, ((SqlInt64)TestMoney64).Value); + } + + public void TestSqlSingleToSqlInt64() + { + SqlSingle TestSingle64 = new SqlSingle (64); + AssertEquals ("#AE01", (long)64, ((SqlInt64)TestSingle64).Value); + } + + public void TestSqlStringToSqlInt64() + { + SqlString TestString = new SqlString ("Test string"); + SqlString TestString100 = new SqlString ("100"); + SqlString TestString1000 = new SqlString ("1000000000000000000000"); + + AssertEquals ("#AF01", (long)100, ((SqlInt64)TestString100).Value); + + try { + SqlInt64 test = (SqlInt64)TestString1000; + Fail ("#AF02"); + } catch(Exception e) { + AssertEquals ("#AF03", typeof (OverflowException), e.GetType ()); + } + + try { + SqlInt64 test = (SqlInt64)TestString; + Fail ("#AF03"); + } catch(Exception e) { + AssertEquals ("#AF04", typeof (FormatException), e.GetType ()); + } + } + + public void TestByteToSqlInt64() + { + short TestShort = 14; + AssertEquals ("#G01", (long)14, ((SqlInt64)TestShort).Value); + } + } +} +