Common-VS2019/SacsCoreUnitTests/Standard/Base/Utils/StringUtil_Tester.cs

using System;
using System.Text.RegularExpressions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Sarand.Net.Standard.Base.Utils;

namespace Sarand.UnitTests.Core.Base.Utils
{
	[TestClass]
	public class StringUtil_Tester
	{
		//-------------------------------------------------------------------
		// Data members.
		private Random random = new Random();

		//-------------------------------------------------------------------
		// Properties.
		//-------------------------------------------------------------------
		[TestMethod]
		public void StringUtil_IsEmpty()
		{
			// Leading spaces.
			Assert.AreEqual(true, StringUtil.IsEmpty(null));
			Assert.AreEqual(true, StringUtil.IsEmpty(""));
			Assert.AreEqual(false, StringUtil.IsEmpty(" "));
			Assert.AreEqual(false, StringUtil.IsEmpty("A"));
			Assert.AreEqual(false, StringUtil.IsEmpty("Abc"));
			Assert.AreEqual(true, "".IsEmpty());
			Assert.AreEqual(false, "Abc".IsEmpty());
		}

		[TestMethod]
		public void StringUtil_IsBlank()
		{
			// Leading spaces.
			Assert.AreEqual(true, StringUtil.IsBlank(null));
			Assert.AreEqual(true, StringUtil.IsBlank(""));
			Assert.AreEqual(true, StringUtil.IsBlank(" "));
			Assert.AreEqual(true, StringUtil.IsBlank("    "));
			Assert.AreEqual(true, StringUtil.IsBlank(" \n\t "));
			Assert.AreEqual(false, StringUtil.IsBlank("A"));
			Assert.AreEqual(false, StringUtil.IsBlank("Abc"));
			Assert.AreEqual(true, "".IsBlank());
			Assert.AreEqual(true, " ".IsBlank());
			Assert.AreEqual(false, "Abc".IsBlank());
		}

		//-------------------------------------------------------------------
		// Regular Expression Matching.
		//-------------------------------------------------------------------
		[TestMethod]
		public void StringUtil_Match()
		{
			// Match.
			Assert.AreEqual(true, "ABCDEF".Match("CDE"));
			Assert.AreEqual(true, "ABCDEF".MatchCI("cDe"));
			Assert.AreEqual(true, "ABCDEF".Match("CDE", System.Text.RegularExpressions.RegexOptions.None));
			Assert.AreEqual(true, "ABCDEF".Match(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)));
			Assert.AreEqual(true, "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)));

			// Match with escaped content.
			Assert.AreEqual(true, "ABC\\sDEF".Match("\\\\s"));
			Assert.AreEqual(true, "AB(CD)EF".Match("(..)"));
			Assert.AreEqual(true, "AB(CD)EF".Match("\\(CD\\)"));

			// Not match.
			Assert.AreEqual(false, "ABCDEF".Match("cDe"));
			Assert.AreEqual(false, "ABCDEF".MatchCI("eFg"));
			Assert.AreEqual(false, "ABCDEF".Match("cDe", System.Text.RegularExpressions.RegexOptions.None));
			Assert.AreEqual(false, "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)));
		}

		[TestMethod]
		public void StringUtil_IsMatch()
		{
			// IsMatch.
			Assert.AreEqual(true, "ABCDEF".IsMatch("CDE"));
			Assert.AreEqual(true, "ABCDEF".IsMatchCI("cDe"));
			Assert.AreEqual(true, "ABCDEF".IsMatch("CDE", System.Text.RegularExpressions.RegexOptions.None));
			Assert.AreEqual(true, "ABCDEF".IsMatch(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)));
			Assert.AreEqual(true, "ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)));

			// IsMatch with escaped content.
			Assert.AreEqual(true, "ABC\\sDEF".IsMatch("\\\\s"));
			Assert.AreEqual(true, "AB(CD)EF".IsMatch("(..)"));
			Assert.AreEqual(true, "AB(CD)EF".IsMatch("\\(CD\\)"));

			// Not match.
			Assert.AreEqual(false, "ABCDEF".IsMatch("cDe"));
			Assert.AreEqual(false, "ABCDEF".IsMatchCI("eFg"));
			Assert.AreEqual(false, "ABCDEF".IsMatch("cDe", System.Text.RegularExpressions.RegexOptions.None));
			Assert.AreEqual(false, "ABCDEF".IsMatch(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)));
		}

		[TestMethod]
		public void StringUtil_MatchCount()
		{
			// Match.
			Assert.AreEqual(1, "ABCDEF".MatchCount(new Regex("CDE")));
			Assert.AreEqual(2, "ABCDEFGHICDEJKL".MatchCount(new Regex("CDE")));
		}

		//-------------------------------------------------------------------
		// Padding.
		//-------------------------------------------------------------------
		[TestMethod]
		public void StringUtil_PadLeft()
		{
			// Leading spaces.
			Assert.AreEqual("   ", "".PadLeft(3, ' '));
			Assert.AreEqual("  A", "A".PadLeft(3, ' '));
			Assert.AreEqual(" AB", "AB".PadLeft(3, ' '));
			Assert.AreEqual("ABC", "ABC".PadLeft(3, ' '));
			Assert.AreEqual("ABCD", "ABCD".PadLeft(3, ' '));

			// Leading zeroes.
			Assert.AreEqual("00", "".PadLeft(2, '0'));
			Assert.AreEqual("01", "1".PadLeft(2, '0'));
			Assert.AreEqual("123", "123".PadLeft(3, '0'));
			Assert.AreEqual("0123", "123".PadLeft(4, '0'));
			Assert.AreEqual("00123", "123".PadLeft(5, '0'));
		}
		[TestMethod]
		public void StringUtil_PadRight ()
		{
			// Leading spaces.
			Assert.AreEqual("   ", "".PadRight(3, ' '));
			Assert.AreEqual("A  ", "A".PadRight(3, ' '));
			Assert.AreEqual("AB ", "AB".PadRight(3, ' '));
			Assert.AreEqual("ABC", "ABC".PadRight(3, ' '));
			Assert.AreEqual("ABCD", "ABCD".PadRight(3, ' '));

			// Trailing zeroes.
			Assert.AreEqual("00", "".PadRight(2, '0'));
			Assert.AreEqual("10", "1".PadRight(2, '0'));
			Assert.AreEqual("12", "12".PadRight(2, '0'));
			Assert.AreEqual("123", "123".PadRight(3, '0'));
			Assert.AreEqual("1230", "123".PadRight(4, '0'));
			Assert.AreEqual("12300", "123".PadRight(5, '0'));
		}

		//-------------------------------------------------------------------
		//                        S u b   S t r i n g
		//-------------------------------------------------------------------
		[TestMethod]
		public void StringUtil_SubstringSafe ()
		{
			Assert.AreEqual(StringUtil.SubstringSafe(null, 0), "");
			Assert.AreEqual(StringUtil.SubstringSafe("", 0), "");
			Assert.AreEqual("".SubstringSafe(0), "");

			// Right portion from start position.
			Assert.AreEqual("abc".SubstringSafe(-3), "abc");
			Assert.AreEqual("abc".SubstringSafe(-2), "abc");
			Assert.AreEqual("abc".SubstringSafe(-1), "abc");
			Assert.AreEqual("abc".SubstringSafe(0), "abc");
			Assert.AreEqual("abc".SubstringSafe(1), "bc");
			Assert.AreEqual("abc".SubstringSafe(2), "c");
			Assert.AreEqual("abc".SubstringSafe(3), "");

			// Zero length.
			Assert.AreEqual(StringUtil.SubstringSafe(null, 0, 0), "");
			Assert.AreEqual(StringUtil.SubstringSafe("", 0, 0), "");
			Assert.AreEqual("".SubstringSafe(0, 0), "");
			Assert.AreEqual("abc".SubstringSafe(-1, 0), "");
			Assert.AreEqual("abc".SubstringSafe(0, 0), "");
			Assert.AreEqual("abc".SubstringSafe(1, 0), "");
			Assert.AreEqual("abc".SubstringSafe(2, 0), "");
			Assert.AreEqual("abc".SubstringSafe(3, 0), "");
			Assert.AreEqual("abc".SubstringSafe(4, 0), "");

			// Mid portion.
			Assert.AreEqual("abcde".SubstringSafe(0, 3), "abc");
			Assert.AreEqual("abcde".SubstringSafe(1, 3), "bcd");
			Assert.AreEqual("abcde".SubstringSafe(2, 3), "cde");

			// Excessive length.
			Assert.AreEqual("abcde".SubstringSafe(-1, 12), "abcde");
			Assert.AreEqual("abcde".SubstringSafe(0, 12), "abcde");
			Assert.AreEqual("abcde".SubstringSafe(1, 12), "bcde");
			Assert.AreEqual("abcde".SubstringSafe(2, 12), "cde");
			Assert.AreEqual("abcde".SubstringSafe(3, 12), "de");
			Assert.AreEqual("abcde".SubstringSafe(4, 12), "e");
			Assert.AreEqual("abcde".SubstringSafe(5, 12), "");
		}
		//-------------------------------------------------------------------
	}
}