stringstest.cs

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

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void IInStrRev_3()
		{
			Strings.InStrRev("abcd","b",0,CompareMethod.Text);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void InStrRev_4()
		{
			Strings.InStrRev("abcd","b",-2,CompareMethod.Text);
		}

		#endregion

		#region Join Tests

		[Test]
		public void Join_1()
		{
			string[] sarr = new string[] {"abc", "def", "ghi"};

			Assert.AreEqual("abc def ghi",Strings.Join(sarr, " "));
			Assert.AreEqual("abc, def, ghi",Strings.Join(sarr, ", "));
			Assert.AreEqual("abc Ok def Ok ghi",Strings.Join(sarr, " Ok "));
		}

		[Test]
		public void Join_2()
		{
			object[] sarr = new object[] {"abc", "def", "ghi"};

			Assert.AreEqual("abc def ghi",Strings.Join(sarr, " "));
			Assert.AreEqual("abc, def, ghi",Strings.Join(sarr, ", "));
			Assert.AreEqual("abc Ok def Ok ghi",Strings.Join(sarr, " Ok "));
		}

		[Test]
		public void Join_3()
		{
			object[] sarr = new object[] {0x20a, 0x57a, 0x566a};

			Assert.AreEqual("522 1402 22122",Strings.Join(sarr, " "));
			Assert.AreEqual("522, 1402, 22122",Strings.Join(sarr, ", "));
			Assert.AreEqual("522 Ok 1402 Ok 22122",Strings.Join(sarr, " Ok "));
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Join_4()
		{
			object[][] sarr = new object[][] {new object[] {"a"}, new object[] {"b"}};

			Strings.Join(sarr, " ");
		}

		[Test]
		public void Join_5()
		{
			object[] sarr = new object[] {"abc", "def", "ghi"};

			Assert.AreEqual(null,Strings.Join(null, " "));
			Assert.AreEqual("abcdefghi",Strings.Join(sarr, null));
		}

		#endregion

		#region LCase Tests

		[Test]
		public void LCase_1()
		{
			Assert.AreEqual("aaaaaaaa11111111bbbbb2222ccccc3333",Strings.LCase("AAAAAAAA11111111BBBBB2222CCCCC3333"));
			Assert.AreEqual("a",Strings.LCase("A"));
			Assert.AreEqual("z",Strings.LCase("Z"));
			Assert.AreEqual("@#$$@#",Strings.LCase("@#$$@#"));
			Assert.AreEqual("\u2345 \u5678",Strings.LCase("\u2345 \u5678"));
		}

		[Test]
		public void LCase_2()
		{			
			Assert.AreEqual('a',Strings.LCase('A'));
			Assert.AreEqual('z',Strings.LCase('Z'));
			Assert.AreEqual('@',Strings.LCase('@'));
			Assert.AreEqual('\u5678',Strings.LCase('\u5678'));
		}

		[Test]
		public void LCase_3()
		{
			Assert.AreEqual(null,Strings.LCase(null));
		}

		#endregion

		#region Left Tests

		[Test]
		public void Left_1()
		{
			Assert.AreEqual("Ab",Strings.Left("AbCdEf",2));
			Assert.AreEqual("AbCd",Strings.Left("AbCdEf",4));
			Assert.AreEqual(String.Empty,Strings.Left("AbCdEf",0));
			Assert.AreEqual("AbCdEf",Strings.Left("AbCdEf",15));
		}

		[Test]
		public void Left_2()
		{
			Assert.AreEqual(String.Empty,Strings.Left(null,2));
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Left_3()
		{
			Strings.Left("abc",-1);
		}

		#endregion

		#region Len Tests

		[Test]
		public void Len_1()
		{
			Assert.AreEqual(2,Strings.Len(new Boolean()),"Boolean");
			Assert.AreEqual(1,Strings.Len(new Byte()),"Byte");
			Assert.AreEqual(2,Strings.Len(new Char()),"Char");
			Assert.AreEqual(8,Strings.Len(new Double()),"Double");
			Assert.AreEqual(2,Strings.Len(new Int16()),"Int16");
			Assert.AreEqual(4,Strings.Len(new Int32()),"Int32");
			Assert.AreEqual(8,Strings.Len(new Int64()),"Int64");
// Passing unsigned types to VB1.1 returns the sizeof of a signed type.
#if NET_2_0
			Assert.AreEqual(1,Strings.Len(new SByte()),"SByte");
#else
			Assert.AreEqual(2,Strings.Len(new SByte()),"SByte");
#endif
			Assert.AreEqual(4,Strings.Len(new Single()),"Single");
			Assert.AreEqual(8,Strings.Len(new DateTime()),"DateTime");
			Assert.AreEqual(8,Strings.Len(new Decimal()),"Decimal");
#if NET_2_0
			Assert.AreEqual(2,Strings.Len(new UInt16()),"UInt16");
			Assert.AreEqual(4,Strings.Len(new UInt32()),"UInt32");
#else
			Assert.AreEqual(4,Strings.Len(new UInt16()),"UInt16");
			Assert.AreEqual(8,Strings.Len(new UInt32()),"UInt32");
#endif
			decimal d = new UInt64();
			Assert.AreEqual(8,Strings.Len(d));

			object o = new Int32();
			string s = String.Empty;
			Assert.AreEqual(4,Strings.Len(o));
			Assert.AreEqual(0,Strings.Len(s));
			Assert.AreEqual(9,Strings.Len("abcdefghi"));
			Assert.AreEqual(0,Strings.Len(null),"null");

		}

		class A 
		{
			int i;
			long j;
			double k;

			public A() 
			{
				i = 1;
				j = 2;
				k = 5.4;
			}
		}

		[Test]
		[ExpectedException(typeof(InvalidCastException))]
		public void Len_2()
		{
			object o = new A();
			Assert.AreEqual(4,Strings.Len(o));
		}

		[Test]
		[ExpectedException(typeof(InvalidCastException))]
		public void Len_3()
		{
			Strings.Len(new Object());
		}

		[Test]
		[ExpectedException(typeof(InvalidCastException))]
		public void Len_4()
		{
			Strings.Len(DBNull.Value);
		}

		#endregion

		#region LSet Tests

		[Test]
		public void LSet_1()
		{
			Assert.AreEqual("abc       ",Strings.LSet("abc",10));
			Assert.AreEqual("abc       ",Strings.LSet("abc   ",10));
			Assert.AreEqual("ab",Strings.LSet("abc",2));
			Assert.AreEqual(String.Empty,Strings.LSet("abc",0));
			Assert.AreEqual("  ",Strings.LSet(null,2));
		}

		[Test]
		[ExpectedException(typeof(ArgumentOutOfRangeException))]
		public void LSet_2()
		{
			Strings.LSet("abc",-1);
		}

		#endregion

		#region LTrim tests

		[Test]
		public void LTrim_1()
		{
			Assert.AreEqual("abc   ",Strings.LTrim("   abc   "));
			Assert.AreEqual("abc   ",Strings.LTrim("abc   "));
			Assert.AreEqual("\tabc   ",Strings.LTrim("\tabc   "));
			Assert.AreEqual("!!!!abc   ",Strings.LTrim("!!!!abc   "));
			Assert.AreEqual(String.Empty,Strings.LTrim(String.Empty));
			Assert.AreEqual(String.Empty,Strings.LTrim(null));
		}

		#endregion

		#region Mid Tests

		[Test]
		public void Mid_1()
		{
			Assert.AreEqual("bcdefg",Strings.Mid("abcdefg",2));
			Assert.AreEqual("bc",Strings.Mid("abcdefg",2,2));
			Assert.AreEqual("bcdefg",Strings.Mid("abcdefg",2,10));
			Assert.AreEqual("g",Strings.Mid("abcdefg",7,10));

			Assert.AreEqual(String.Empty,Strings.Mid("abcdefg",8,10));
			Assert.AreEqual(String.Empty,Strings.Mid("abcdefg",1,0));

			Assert.AreEqual(String.Empty,Strings.Mid(String.Empty,1,0));
			Assert.AreEqual(String.Empty,Strings.Mid(null,1,2));
			Assert.AreEqual(null,Strings.Mid(null,1));
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Mid_2()
		{
			Strings.Mid("abcdefg",0);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Mid_3()
		{
			Strings.Mid("abcdefg",-1);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Mid_4()
		{
			Strings.Mid("abcdefg",1,-1);
		}

		#endregion

		#region Replace Tests

		[Test]
		public void Replace_1()
		{
			Assert.AreEqual("aZZdZZlkjhZZkjh",Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",1,-1,CompareMethod.Binary));
			Assert.AreEqual("cdZZlkjhZZkjh",Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",3,-1,CompareMethod.Binary));
			Assert.AreEqual("kjhZZkjh",Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",8,-1,CompareMethod.Binary));
			Assert.AreEqual("h",Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",15,-1,CompareMethod.Binary));

			Assert.AreEqual("aZZdbclkjhbckjh",Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",1,1,CompareMethod.Binary));
			Assert.AreEqual("aZZdZZlkjhbckjh",Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",1,2,CompareMethod.Binary));		
		}

		[Test]
		public void Replace_2()
		{
			Assert.AreEqual("abcdbclkjhbckjh",Strings.Replace("abcdbclkjhbckjh","BC", "ZZ",1,-1,CompareMethod.Binary));
			Assert.AreEqual("aZZdZZlkjhZZkjh",Strings.Replace("abcdbclkjhbckjh","BC", "ZZ",1,-1,CompareMethod.Text));
			Assert.AreEqual("aZZdZZlkjhZZkjh",Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",1,-1,CompareMethod.Text));
		}

		[Test]
		public void Replace_3()
		{
			Assert.AreEqual(null,Strings.Replace(String.Empty,"BC", "ZZ",1,-1,CompareMethod.Binary));
			Assert.AreEqual(null,Strings.Replace(null,"BC", "ZZ",1,-1,CompareMethod.Binary));

			Assert.AreEqual("abcdbclkjhbckjh",Strings.Replace("abcdbclkjhbckjh",String.Empty, "ZZ",1,-1,CompareMethod.Text));
			Assert.AreEqual("abcdbclkjhbckjh",Strings.Replace("abcdbclkjhbckjh",null, "ZZ",1,-1,CompareMethod.Text));

			Assert.AreEqual("adlkjhkjh",Strings.Replace("abcdbclkjhbckjh","bc", String.Empty,1,-1,CompareMethod.Text));
			Assert.AreEqual("adlkjhkjh",Strings.Replace("abcdbclkjhbckjh","bc", null,1,-1,CompareMethod.Text));			

			Assert.AreEqual(null,Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",16,-1,CompareMethod.Text));
			Assert.AreEqual("abcdbclkjhbckjh",Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",1,0,CompareMethod.Text));
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Replace_5()
		{
			Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",0,1,CompareMethod.Text);		
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Replace_6()
		{
			Strings.Replace("abcdbclkjhbckjh","bc", "ZZ",1,-2,CompareMethod.Text);		
		}

		#endregion

		#region Right Tests

		[Test]
		public void Right_1()
		{
			Assert.AreEqual(String.Empty,Strings.Right("Abcd",0));
			Assert.AreEqual("d",Strings.Right("Abcd",1));
			Assert.AreEqual("cd",Strings.Right("Abcd",2));
			Assert.AreEqual("bcd",Strings.Right("Abcd",3));
			Assert.AreEqual("Abcd",Strings.Right("Abcd",4));
			Assert.AreEqual("Abcd",Strings.Right("Abcd",5));
		}