conversiontests.cs

大名鼎鼎的mono是.NET平台的跨平台（支持linux

			caughtException = false;

			try 
			{
				Conversion.Oct(null);
			}
			catch (Exception e) 
			{
				Assert.AreEqual( typeof(ArgumentNullException), e.GetType());
				caughtException = true;
			}

			Assert.AreEqual( true, caughtException);
		}

		[Test]
		public void Oct1() 
		{
			byte byte1;
			string s;
			int i;
			long l;
			object o1;
			short short1;
			double dbl1;
			float f;

			byte1 = 11;
			Assert.AreEqual("13",Conversion.Oct(byte1));

			Assert.AreEqual("14",Conversion.Oct(12));

			s = "11";
			Assert.AreEqual("13",Conversion.Oct(s));

			i = 300;
			Assert.AreEqual("454",Conversion.Oct(i));

			l = 1300;
			Assert.AreEqual("2424",Conversion.Oct(l));

			short1 = 10;
			Assert.AreEqual("12",Conversion.Oct(short1));

			o1 = 14;
			Assert.AreEqual("16",Conversion.Oct(o1));

			s = "10";
			Assert.AreEqual("12",Conversion.Oct(s));

			s = "010";
			Assert.AreEqual("12",Conversion.Oct(s));

			s = System.Int32.MaxValue.ToString();
			Assert.AreEqual("17777777777",Conversion.Oct(s));

			s = System.Int64.MaxValue.ToString();
			Assert.AreEqual("777777777777777777777",Conversion.Oct(s));

			dbl1 = 234.234;
			Assert.AreEqual("352",Conversion.Oct(dbl1));

			f = 234.234F;
			Assert.AreEqual("352",Conversion.Oct(f));

		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Oct2() 
		{
			bool b = false;
			Assert.AreEqual(0,Conversion.Oct(b));
		}

		[Test]
		[ExpectedException(typeof(ArgumentNullException))]
		public void Oct3() 
		{
			object o1 = null;
			Assert.AreEqual(0,Conversion.Oct(o1));
		}


		[Test]
		public void Oct4() 
		{
			Assert.AreEqual("0",Conversion.Oct(0));

			Assert.AreEqual("4107215343",Conversion.Oct(555555555));
			Assert.AreEqual("112402762000",Conversion.Oct(10000000000));
			Assert.AreEqual("2657142036440000",Conversion.Oct(100000000000000));
			Assert.AreEqual("34327724461500000",Conversion.Oct(1000000000000000));
			Assert.AreEqual("434157115760200000",Conversion.Oct(10000000000000000));

			// negatives
			Assert.AreEqual("37777777777",Conversion.Oct(-1));
			Assert.AreEqual("37777777776",Conversion.Oct(-1.5));
			Assert.AreEqual("37777777761",Conversion.Oct(-15));
			Assert.AreEqual("37777776030",Conversion.Oct(-1000));
			Assert.AreEqual("37777661700",Conversion.Oct(-40000));
			Assert.AreEqual("37777567220",Conversion.Oct(-70000));
			Assert.AreEqual("37777474540",Conversion.Oct(-100000));
			Assert.AreEqual("37774136700",Conversion.Oct(-1000000));
			Assert.AreEqual("37731664600",Conversion.Oct(-10000000));
			Assert.AreEqual("37202417400",Conversion.Oct(-100000000));
			Assert.AreEqual("30431233000",Conversion.Oct(-1000000000));
			//FIXME:Assert.AreEqual("1777777777665375016000",Conversion.Oct(-10000000000));
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Oct5() 
		{
			A4 a1 = new A4();
			Assert.AreEqual("2386F26FC10000",Conversion.Oct(a1));
		}
		internal class A4
		{
		}

		[Test]
		[ExpectedException(typeof(OverflowException))]
		public void Oct6() 
		{
			decimal d = System.Int64.MaxValue;
			d = d +1;
			Assert.AreEqual("0",Conversion.Oct(d));
		}

		#endregion

		#region Str Tests


		// test the Str function
		[Test]
		public void Str() 
		{
			Assert.AreEqual("-1", Conversion.Str(-1));
			Assert.AreEqual(" 1", Conversion.Str(1));

			bool caughtException = false;
			Object O = typeof(int);

			try 
			{
				Conversion.Str(O);
			}
			catch (Exception e) 
			{
				Assert.AreEqual(typeof(InvalidCastException), e.GetType());
				caughtException = true;
			}

			Assert.AreEqual(true, caughtException);

			caughtException = false;

			try 
			{
				Conversion.Str(null);
			}
			catch (Exception e) 
			{
				Assert.AreEqual(typeof(ArgumentNullException), e.GetType());
				caughtException = true;
			}
		}


		[Test]
		public void Str1() 
		{
			byte byte1;
			int i;
			long l;
			object o1;
			short short1;
			double dbl1;
			float f;

			byte1 = 11;
			Assert.AreEqual(" 11",Conversion.Str(byte1));

			Assert.AreEqual(" 12",Conversion.Str(12));

			i = 300;
			Assert.AreEqual(" 300",Conversion.Str(i));

			i = -300;
			Assert.AreEqual("-300",Conversion.Str(i));

			l = 1300;
			Assert.AreEqual(" 1300",Conversion.Str(l));

			short1 = 10;
			Assert.AreEqual(" 10",Conversion.Str(short1));

			o1 = 14;
			Assert.AreEqual(" 14",Conversion.Str(o1));

			o1 = 52654;
			Assert.AreEqual(" 52654",Conversion.Str(o1));

			i = System.Int32.MaxValue;
			Assert.AreEqual(" 2147483647",Conversion.Str(i));

			l = System.Int64.MaxValue;
			Assert.AreEqual(" 9223372036854775807",Conversion.Str(l));

			dbl1 = 234.234;
			Assert.AreEqual(" 234.234",Conversion.Str(dbl1));

			f = 234.234F;
			Assert.AreEqual(" 234.234",Conversion.Str(f));

		}
#if ! NET_2_0
		[Test]
		[ExpectedException(typeof(NullReferenceException))]
		public void Str2() 
		{
			//Str(string) throws System.NullReferenceException: Object reference not set to an instance of an object.
			string s;
			s = "11";
			Assert.AreEqual("11",Conversion.Str(s));
		}
#endif

		[Test]
		[ExpectedException(typeof(ArgumentNullException))]
		public void Str3() 
		{
			object o1 = null;
			Assert.AreEqual(0,Conversion.Str(o1));
		}

		[Test]
		[ExpectedException(typeof(InvalidCastException))]
		public void Str4() 
		{
			object o1 = new object();
			Assert.AreEqual(0,Conversion.Str(o1));
		}

		#endregion

		#region Val Tests

		// Test the Val function
		[Test]
		public void Val() 
		{
			Assert.AreEqual(4, Conversion.Val('4'));
			Assert.AreEqual(-3542.76, Conversion.Val("    -   3       5   .4   2  7   6E+    0 0 2    "));
			Assert.AreEqual(255D, Conversion.Val("&HFF"));
			Assert.AreEqual(255D, Conversion.Val("&o377"));

			System.Object O = "    -   3       5   .4     7   6E+    0 0 3";

			Assert.AreEqual(-35476D, Conversion.Val(O));

			bool caughtException;

			caughtException = false;

			try 
			{
				Conversion.Val("3E+9999999");
			}
			catch (Exception e) 
			{
				Assert.AreEqual(typeof(OverflowException), e.GetType());
				caughtException = true;
			}

			Assert.AreEqual(true, caughtException);

			caughtException = false;

			try 
			{
				Conversion.Val(typeof(int));
			}
			catch (Exception e) 
			{
				Assert.AreEqual(typeof(ArgumentException), e.GetType());
				caughtException = true;
			}
			Assert.AreEqual(true, caughtException);

			Assert.AreEqual(0, Conversion.Val (null));
			Assert.AreEqual(0, Conversion.Val (String.Empty));
		}


		[Test]
		public void Val1() 
		{
			char c1;

			c1 = 'a';
			Assert.AreEqual(0,Conversion.Val(c1));

			c1 = '1';
			Assert.AreEqual(1,Conversion.Val(c1));
		}

		[Test]
		public void Val2() 
		{
			string s1;

			s1 = null;
			Assert.AreEqual(0,Conversion.Val(s1));

			s1 = "";
			Assert.AreEqual(0,Conversion.Val(s1));

			s1 = "9";
			Assert.AreEqual(9,Conversion.Val(s1));

			s1 = "0 9";
			Assert.AreEqual(9,Conversion.Val(s1));

			s1 = "9 9";
			Assert.AreEqual(99,Conversion.Val(s1));

			s1 = "123.321";
			Assert.AreEqual(123.321,Conversion.Val(s1));

			s1 = "9 . 9 a";
			Assert.AreEqual(9.9,Conversion.Val(s1));

			s1 = "B9 . 9 a";
			Assert.AreEqual(0,Conversion.Val(s1));

			s1 = "12.215.215.25";
			Assert.AreEqual(12.215,Conversion.Val(s1));

			s1 = "88888888";
			Assert.AreEqual(88888888,Conversion.Val(s1));

			s1 = " &F";
			Assert.AreEqual(0,Conversion.Val(s1));

			s1 = " & 2";
			Assert.AreEqual(0,Conversion.Val(s1));

			s1 = "1 & 2";
			Assert.AreEqual(1,Conversion.Val(s1));

			s1 = "& HF";
			Assert.AreEqual(0,Conversion.Val(s1));

			s1 = "&HFF";
			Assert.AreEqual(255,Conversion.Val(s1));

			s1 = "&HFFFF";
			Assert.AreEqual(-1,Conversion.Val(s1));

			s1 = "&HFFFE";
			Assert.AreEqual(-2,Conversion.Val(s1));

			s1 = "&HF111";
			Assert.AreEqual(-3823,Conversion.Val(s1));

			s1 = "&HFFFFF";
			Assert.AreEqual(1048575,Conversion.Val(s1));

			s1 = "&HFFFFFF";
			Assert.AreEqual(16777215,Conversion.Val(s1));

			s1 = "&HFFFFFFFF";
			Assert.AreEqual(-1,Conversion.Val(s1));

			s1 = "&HFFFFFDDD";
			Assert.AreEqual(-547,Conversion.Val(s1));

			s1 = "&HFFFFFFFFFFFF";
			Assert.AreEqual(281474976710655,Conversion.Val(s1));

			s1 = "&HFFFFFFFFFFFFFFFD";
			Assert.AreEqual(-3,Conversion.Val(s1));

			s1 = "&HFF.FF";
			Assert.AreEqual(255,Conversion.Val(s1));

			s1 = "1&HFFFF";
			Assert.AreEqual(1,Conversion.Val(s1));

			s1 = "  &H FFF E";
			Assert.AreEqual(-2,Conversion.Val(s1));

			s1 = "  &HFF";
			Assert.AreEqual(255,Conversion.Val(s1));

			s1 = "  &H FFG E";
			Assert.AreEqual(255,Conversion.Val(s1));

			s1 = "&O10";
			Assert.AreEqual(8,Conversion.Val(s1));

			s1 = "&O1 5";
			Assert.AreEqual(13,Conversion.Val(s1));

			s1 = "&O9 5";
			Assert.AreEqual(0,Conversion.Val(s1));

			s1 = "&O7777777";
			Assert.AreEqual(2097151,Conversion.Val(s1));

			s1 = "&O777764536644327";
			Assert.AreEqual(35182853441751,Conversion.Val(s1));

			//
			//
			//FIXME: s1 = "99999999999999999999999999999999999999999";
			//Assert.AreEqual("1E+41",Conversion.Val(s1).ToString());

			//FIXME: s1 = "&HFFFFFFFFFFFFFFFDD";
			//Assert.AreEqual(-35,Conversion.Val(s1));

		}

		[Test]
		public void Val3() 
		{
			string s1;
			object o1;
			bool b1;

			s1 = "123";
			o1 = s1;
			Assert.AreEqual(123, Conversion.Val(o1));
			
			b1 = true;
			Assert.AreEqual(-1, Conversion.Val(b1));
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Val4() 
		{
			V v1 = new V();
			Assert.AreEqual(0,Conversion.Val(v1));
		}
		internal class V
		{
		}
		#endregion
	}
}