224 lines
9.1 KiB
C#
224 lines
9.1 KiB
C#
using System;
|
|
using System.Linq;
|
|
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_IsMatch()
|
|
{
|
|
// IsMatch.
|
|
Assert.AreEqual(true, "ABCDEF".IsMatch("ABCDEF"));
|
|
Assert.AreEqual(true, "ABCDEF".IsMatch("^ABCDEF$"));
|
|
Assert.AreEqual(true, "ABCDEF".IsMatchCI("AbCdEf"));
|
|
Assert.AreEqual(true, "ABCDEF".IsMatchCI("^AbCdEf$"));
|
|
Assert.AreEqual(true, "ABCDEF".IsMatch("^ABC"));
|
|
Assert.AreEqual(true, "ABCDEF".IsMatchCI("AbC"));
|
|
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_Match()
|
|
{
|
|
// Match.
|
|
Assert.AreEqual("CDE", "ABCDEF".GetMatch("CDE"));
|
|
Assert.AreEqual("CDE", "ABCDEF".GetMatchCI("cDe"));
|
|
Assert.AreEqual("CDE", "ABCDEF".Match("CDE", System.Text.RegularExpressions.RegexOptions.None).Value);
|
|
Assert.AreEqual("CDE", "ABCDEF".Match(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Value);
|
|
Assert.AreEqual("CDE", "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Value);
|
|
|
|
// Match with escaped content.
|
|
Assert.AreEqual(" ", "ABC DEF".GetMatch("\\s"));
|
|
Assert.AreEqual("\\s", "ABC\\sDEF".GetMatch("\\\\s"));
|
|
Assert.AreEqual("AB", "AB(CD)EF".GetMatch("(..)"));
|
|
Assert.AreEqual("(CD)", "AB(CD)EF".GetMatch("\\(..\\)"));
|
|
Assert.AreEqual("(CD)", "AB(CD)EF".GetMatch("\\(CD\\)"));
|
|
|
|
// Not match.
|
|
Assert.AreEqual(null, "ABCDEF".GetMatch("cDe"));
|
|
Assert.AreEqual(null, "ABCDEF".GetMatch("eFg"));
|
|
Assert.AreEqual("", "ABCDEF".Match("cDe", System.Text.RegularExpressions.RegexOptions.None).Value);
|
|
Assert.AreEqual("", "ABCDEF".Match(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Value);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void StringUtil_Matches()
|
|
{
|
|
// Match.
|
|
Assert.AreEqual(1, "ABCDEF".GetMatches("CDE").Count);
|
|
Assert.AreEqual(1, "ABCDEF".GetMatchesCI("cDe").Count);
|
|
Assert.AreEqual(1, "ABCDEF".Matches("CDE", System.Text.RegularExpressions.RegexOptions.None).Count);
|
|
Assert.AreEqual(1, "ABCDEF".Matches(new Regex("CDE", System.Text.RegularExpressions.RegexOptions.None)).Count);
|
|
Assert.AreEqual(1, "ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.IgnoreCase)).Count);
|
|
|
|
// Match with escaped content.
|
|
Assert.AreEqual(1, "ABC DEF".GetMatchesCI("\\s").Count);
|
|
Assert.AreEqual(1, "ABC\\sDEF".GetMatchesCI("\\\\s").Count);
|
|
Assert.AreEqual(4, "AB(CD)EF".GetMatchesCI("(..)").Count);
|
|
Assert.AreEqual("D)", "AB(CD)EF".GetMatchesCI("(..)")[2]);
|
|
Assert.AreEqual(1, "AB(CD)EF".GetMatchesCI("\\(..\\)").Count);
|
|
Assert.AreEqual(1, "AB(CD)EF".GetMatchesCI("\\(CD\\)").Count);
|
|
|
|
// Not match.
|
|
Assert.AreEqual(0, "ABCDEF".GetMatches("cDe").Count);
|
|
Assert.AreEqual(0, "ABCDEF".GetMatches("eFg").Count);
|
|
Assert.AreEqual(0, "ABCDEF".Matches("cDe", System.Text.RegularExpressions.RegexOptions.None).Count);
|
|
Assert.AreEqual(0, "ABCDEF".Matches(new Regex("cDe", System.Text.RegularExpressions.RegexOptions.None)).Count);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void StringUtil_MatchCount()
|
|
{
|
|
// Match.
|
|
Assert.AreEqual(1, "ABCDEF".GetMatchCount("CDE"));
|
|
Assert.AreEqual(1, "ABCDEF".MatchesCount(new Regex("CDE")));
|
|
Assert.AreEqual(2, "ABCDEFGHICDEJKL".GetMatchCount("CDE"));
|
|
Assert.AreEqual(2, "ABCDEFGHICDEJKL".MatchesCount(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), "");
|
|
}
|
|
//-------------------------------------------------------------------
|
|
}
|
|
}
|