conversiontests.cs

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

			object o1 = null;
			Assert.AreEqual(0,Conversion.Int(o1));
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Int3() 
		{
			A2 a1 = new A2();
			Assert.AreEqual(0,Conversion.Int(a1));
		}
		internal class A2
		{
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Int4() 
		{
			DateTime date1 = new DateTime(1999,1,1);
			Assert.AreEqual(0,Conversion.Int(date1));
		}

		#endregion

		#region Hex Tests


		// test the Hex function
		[Test]
		public void Hex() 
		{
			Assert.AreEqual("FF", Conversion.Hex(System.Byte.MaxValue));
			Assert.AreEqual("0", Conversion.Hex(System.Byte.MinValue));
			Assert.AreEqual("7FFF", Conversion.Hex(System.Int16.MaxValue));
			Assert.AreEqual("8000", Conversion.Hex(System.Int16.MinValue));
			Assert.AreEqual("7FFFFFFF", Conversion.Hex(System.Int32.MaxValue));
			Assert.AreEqual("80000000", Conversion.Hex(System.Int32.MinValue));
			Assert.AreEqual("7FFFFFFFFFFFFFFF", Conversion.Hex(System.Int64.MaxValue));
			Assert.AreEqual("8000000000000000", Conversion.Hex(System.Int64.MinValue));

			System.Byte UI8;
			System.Int16 I16;
			System.Int32 I32;
			System.Int64 I64;
			System.Object O;
			System.String S;

			UI8 = 15;
			Assert.AreEqual("F", Conversion.Hex(UI8));
			
			I16 = System.Byte.MaxValue;
			Assert.AreEqual("FF", Conversion.Hex(I16));

			I16 = (System.Int16)((I16 + 1) * -1);
			Assert.AreEqual("FF00", Conversion.Hex(I16));

			I16 = -2;
			Assert.AreEqual("FFFE", Conversion.Hex(I16));

			I32 = System.UInt16.MaxValue;
			Assert.AreEqual("FFFF", Conversion.Hex(I32));

			I32 = (I32 + 1) * -1;
			Assert.AreEqual("FFFF0000", Conversion.Hex(I32));

			I32 = -2;
			Assert.AreEqual("FFFFFFFE", Conversion.Hex(I32));

			I64 = System.UInt32.MaxValue;
			Assert.AreEqual("FFFFFFFF", Conversion.Hex(I64));

			I64 = (I64 + 1) * -1;
			Assert.AreEqual("FFFFFFFF00000000", Conversion.Hex(I64));
			
			I64 = -2;
			Assert.AreEqual("FFFFFFFFFFFFFFFE", Conversion.Hex(I64));
			
			I16 = System.Byte.MaxValue;
			S = I16.ToString();
			Assert.AreEqual("FF", Conversion.Hex(S));

			I16 = (System.Int16)((I16 + 1) * -1);
			S = I16.ToString();
			Assert.AreEqual("FFFFFF00", Conversion.Hex(S));

			I16 = -1;
			S = I16.ToString();
			Assert.AreEqual("FFFFFFFF", Conversion.Hex(S));

			I32 = System.UInt16.MaxValue;
			S = I32.ToString();
			Assert.AreEqual("FFFF", Conversion.Hex(S));

			I32 = (I32 + 1) * -1;
			S = I32.ToString();
			Assert.AreEqual("FFFF0000", Conversion.Hex(S));

			I32 = -2;
			S = I32.ToString();
			Assert.AreEqual("FFFFFFFE", Conversion.Hex(S));

			I64 = System.UInt32.MaxValue;
			S = I64.ToString();
			Assert.AreEqual("FFFFFFFF", Conversion.Hex(S));

			I64 = (I64 + 1) * -1;
			S = I64.ToString();
			Assert.AreEqual("FFFFFFFF00000000", Conversion.Hex(S));
			
			UI8 = System.Byte.MaxValue;
			O = UI8;
			Assert.AreEqual("FF", Conversion.Hex(O));

			I16 = System.Byte.MaxValue;
			O = I16;
			Assert.AreEqual("FF", Conversion.Hex(O));

			I16 = (System.Int16)((I16 + 1) * -1);
			O = I16;
			Assert.AreEqual("FF00", Conversion.Hex(O));

			I16 = -2;
			O = I16;
			Assert.AreEqual("FFFE", Conversion.Hex(O));

			I32 = System.UInt16.MaxValue;
			O = I32;
			Assert.AreEqual("FFFF", Conversion.Hex(O));

			I32 = (I32 + 1) * -1;
			O = I32;
			Assert.AreEqual("FFFF0000", Conversion.Hex(O));

			I32 = -2;
			O = I32;
			Assert.AreEqual("FFFFFFFE", Conversion.Hex(O));

			I64 = System.UInt32.MaxValue;
			O = I64;
			Assert.AreEqual("FFFFFFFF", Conversion.Hex(O));

			I64 = (I64 + 1) * -1;
			O = I64;
			Assert.AreEqual("FFFFFFFF00000000", Conversion.Hex(O));

			I64 = -2;
			O = I64;
			// FIXME : MS doesn't pass this test
			//Assert.AreEqual("FFFFFFFFFFFFFFFE", Conversion.Hex(O));

			O = typeof(int);

			bool caughtException = false;
			try 
			{
				Conversion.Hex(O);
			}
			catch (Exception e) 
			{
				Assert.AreEqual(typeof(ArgumentException), e.GetType());
				caughtException = true;
			}

			Assert.AreEqual(true, caughtException);

			caughtException = false;

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

			Assert.AreEqual(true, caughtException);
		}
		
		[Test]
		public void Hex1() 
		{
			byte byte1;
			string s;
			int i;
			long l;
			object o1;
			short short1;
			double dbl1;
			float f;

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

			Assert.AreEqual("C",Conversion.Hex(12));

			s = "11";
			Assert.AreEqual("B",Conversion.Hex(s));

			i = 300;
			Assert.AreEqual("12C",Conversion.Hex(i));

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

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

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

			s = "10";
			Assert.AreEqual("A",Conversion.Hex(s));

			s = "010";
			Assert.AreEqual("A",Conversion.Hex(s));

			s = System.Int32.MaxValue.ToString();
			Assert.AreEqual("7FFFFFFF",Conversion.Hex(s));

			s = System.Int64.MaxValue.ToString();
			Assert.AreEqual("7FFFFFFFFFFFFFFF",Conversion.Hex(s));

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

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

		}

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

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


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

			Assert.AreEqual("211D1AE3",Conversion.Hex(555555555));
			Assert.AreEqual("2540BE400",Conversion.Hex(10000000000));
			Assert.AreEqual("5AF3107A4000",Conversion.Hex(100000000000000));
			Assert.AreEqual("38D7EA4C68000",Conversion.Hex(1000000000000000));
			Assert.AreEqual("2386F26FC10000",Conversion.Hex(10000000000000000));

			// negatives
			Assert.AreEqual("FFFFFFFF",Conversion.Hex(-1));
			Assert.AreEqual("FFFFFFFE",Conversion.Hex(-1.5));
			Assert.AreEqual("FFFFFFF1",Conversion.Hex(-15));
			Assert.AreEqual("FFFFFC18",Conversion.Hex(-1000));
			Assert.AreEqual("FFFF63C0",Conversion.Hex(-40000));
			Assert.AreEqual("FFFEEE90",Conversion.Hex(-70000));
			Assert.AreEqual("FFFE7960",Conversion.Hex(-100000));
			Assert.AreEqual("FFF0BDC0",Conversion.Hex(-1000000));
			Assert.AreEqual("FF676980",Conversion.Hex(-10000000));
			Assert.AreEqual("FA0A1F00",Conversion.Hex(-100000000));
			Assert.AreEqual("C4653600",Conversion.Hex(-1000000000));
			//FIXME:Assert.AreEqual("FFFFFFFDABF41C00",Conversion.Hex(-10000000000));
		}

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

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

		[Test]
		public void Hex7() 
		{
			string s;
			s = "&o123";
			Assert.AreEqual("53",Conversion.Hex(s));

			s = "&O123";
			Assert.AreEqual("53",Conversion.Hex(s));

			s = "&h123";
			Assert.AreEqual("123",Conversion.Hex(s));

			s = "&H123";
			Assert.AreEqual("123",Conversion.Hex(s));
			
		}
		#endregion

		#region Oct Tests

		// test the Oct function
		[Test]
		public void Oct() 
		{
			Assert.AreEqual( "377", Conversion.Oct(System.Byte.MaxValue));
			Assert.AreEqual( "0", Conversion.Oct(System.Byte.MinValue));
			Assert.AreEqual( "77777", Conversion.Oct(System.Int16.MaxValue));
			Assert.AreEqual( "100000", Conversion.Oct(System.Int16.MinValue));
			Assert.AreEqual( "17777777777", Conversion.Oct(System.Int32.MaxValue));
			Assert.AreEqual( "20000000000", Conversion.Oct(System.Int32.MinValue));
			Assert.AreEqual( "777777777777777777777", Conversion.Oct(System.Int64.MaxValue));
			//Assert.AreEqual( "1000000000000000000000", Conversion.Oct(System.Int64.MinValue));

			System.Byte UI8;
			System.Int16 I16;
			System.Int32 I32;
			System.Int64 I64;
			System.Object O;
			System.String S;

			UI8 = 15;
			Assert.AreEqual( "17", Conversion.Oct(UI8));
			
			I16 = System.Byte.MaxValue;
			Assert.AreEqual( "377", Conversion.Oct(I16));

			I16 = (System.Int16)((I16 + 1) * -1);
			Assert.AreEqual( "177400", Conversion.Oct(I16));

			I16 = -2;
			Assert.AreEqual( "177776", Conversion.Oct(I16));

			I32 = System.UInt16.MaxValue;
			Assert.AreEqual( "177777", Conversion.Oct(I32));

			I32 = (I32 + 1) * -1;
			Assert.AreEqual( "37777600000", Conversion.Oct(I32));

			I32 = -2;
			Assert.AreEqual( "37777777776", Conversion.Oct(I32));

			I64 = System.UInt32.MaxValue;
			Assert.AreEqual( "37777777777", Conversion.Oct(I64));

			I64 = (I64 + 1) * -1;
			Assert.AreEqual( "1777777777740000000000", Conversion.Oct(I64));
			
			I64 = -2;
			Assert.AreEqual( "1777777777777777777776", Conversion.Oct(I64));
			
			I16 = System.Byte.MaxValue;
			S = I16.ToString();
			Assert.AreEqual( "377", Conversion.Oct(S));

			I16 = (System.Int16)((I16 + 1) * -1);
			S = I16.ToString();
			Assert.AreEqual( "37777777400", Conversion.Oct(S));

			I16 = -2;
			S = I16.ToString();
			Assert.AreEqual( "37777777776", Conversion.Oct(S));

			I32 = System.UInt16.MaxValue;
			S = I32.ToString();
			Assert.AreEqual( "177777", Conversion.Oct(S));

			I32 = (I32 + 1) * -1;
			S = I32.ToString();
			Assert.AreEqual( "37777600000", Conversion.Oct(S));

			I32 = -2;
			S = I32.ToString();
			Assert.AreEqual( "37777777776", Conversion.Oct(S));

			I64 = System.UInt32.MaxValue;
			S = I64.ToString();
			Assert.AreEqual( "37777777777", Conversion.Oct(S));

			I64 = (I64 + 1) * -1;
			S = I64.ToString();
			Assert.AreEqual( "1777777777740000000000", Conversion.Oct(S));
			
			UI8 = System.Byte.MaxValue;
			O = UI8;
			Assert.AreEqual( "377", Conversion.Oct(O));

			I16 = System.Byte.MaxValue;
			O = I16;
			Assert.AreEqual( "377", Conversion.Oct(O));

			I16 = (System.Int16)((I16 + 1) * -1);
			O = I16;
			Assert.AreEqual( "177400", Conversion.Oct(O));

			I16 = -2;
			O = I16;
			Assert.AreEqual( "177776", Conversion.Oct(O));

			I32 = System.UInt16.MaxValue;
			O = I32;
			Assert.AreEqual( "177777", Conversion.Oct(O));

			I32 = (I32 + 1) * -1;
			O = I32;
			Assert.AreEqual( "37777600000", Conversion.Oct(O));

			I32 = -2;
			O = I32;
			Assert.AreEqual( "37777777776", Conversion.Oct(O));

			I64 = System.UInt32.MaxValue;
			O = I64;
			Assert.AreEqual( "37777777777", Conversion.Oct(O));

			I64 = (I64 + 1) * -1;
			O = I64;
			Assert.AreEqual( "1777777777740000000000", Conversion.Oct(O));

			I64 = -2;
			O = I64;

			// FIXME: MS doesn't pass this test
			// Assert.AreEqual( "1777777777777777777776", Conversion.Oct(O));
		
			O = typeof(int);

			bool caughtException = false;
			try 
			{
				Conversion.Oct(O);
			}
			catch (Exception e) 
			{
				Assert.AreEqual( typeof(ArgumentException), e.GetType());
				caughtException = true;
			}

			Assert.AreEqual( true, caughtException);