public void LessThanOrEqualM_MultiDigit_RegexDoesNotMatch_LargerSameDigitCount()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualMagnitude(1000);
Assert.IsFalse(Regex.Match("1001", pattern).Success);
Assert.IsFalse(Regex.Match("9999", pattern).Success);
}
static void Main(string[] args)
{
do
{
Console.WriteLine("Hello. What number range would you like to match?");
Console.WriteLine("You can write '<=AAA', '<AAA', '>=AAA', or '>AAA' or 'q' to quit.");
Console.Write("Your range: ");
string range = Console.ReadLine();
Console.WriteLine();
var numbers = Regex.Matches(range, "[\\d\\-]+").OfType <Match>().Select(m => int.Parse(m.Value)).ToList();
string pattern;
if (range.StartsWith("<=") && numbers.Count == 1)
{
pattern = GetNumberRangePattern.ForLessThanOrEqualTo(numbers[0]);
}
else if (range.StartsWith("<") && numbers.Count == 1)
{
pattern = GetNumberRangePattern.ForLessThan(numbers[0]);
}
else if (range.StartsWith(">=") && numbers.Count == 1)
{
pattern = GetNumberRangePattern.ForGreaterThanOrEqualTo(numbers[0]);
}
else if (range.StartsWith(">") && numbers.Count == 1)
{
pattern = GetNumberRangePattern.ForGreaterThan(numbers[0]);
}
else if (range.ToLower().StartsWith("q"))
{
return;
}
else
{
Console.WriteLine("Invalid format. Please try again.");
continue;
}
Console.WriteLine($"The regex pattern to match '{range}' is:");
Console.WriteLine(pattern);
Console.WriteLine();
Console.Write("What number would you like to check with this pattern? ");
var toCheck = Console.ReadLine();
var check = Regex.IsMatch(toCheck, pattern);
if (check)
{
Console.WriteLine($"Success! {toCheck} meets the condition {range}.");
}
else
{
Console.WriteLine($"No, {toCheck} does not meet the condition {range}.");
}
Console.ReadLine();
Console.Clear();
} while (true);
}
public void GreaterThanM_MultiDigit_RegexDoesNotMatch_SmallerSameDigits()
{
string pattern = GetNumberRangePattern.ForGreaterThanMagnitude(1234);
Assert.IsFalse(Regex.Match("1233", pattern).Success);
Assert.IsFalse(Regex.Match("1000", pattern).Success);
Assert.IsFalse(Regex.Match("0000", pattern).Success);
Assert.IsFalse(Regex.Match("1111", pattern).Success);
}
public void LessThan_Negative_RegexDoesNotMatch_MorePositive()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualTo(-9);
Assert.IsFalse(Regex.Match("-8", pattern).Success);
Assert.IsFalse(Regex.Match("0", pattern).Success);
Assert.IsFalse(Regex.Match("9", pattern).Success);
Assert.IsFalse(Regex.Match("999", pattern).Success);
}
public void GreaterThanM_0_RegexMatches_Positive()
{
string pattern = GetNumberRangePattern.ForGreaterThanMagnitude(0);
string matchTo = "1";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void GreaterThanM_SingleDigit_RegexMatches_LargerSingleDigit()
{
string pattern = GetNumberRangePattern.ForGreaterThanMagnitude(1);
string matchTo = "9";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void LessThanOrEqualM_0_RegexMatches_Self()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualMagnitude(0);
string matchTo = "0";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void LessThanOrEqualM_MultiDigit_RegexMatches_Same()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualMagnitude(1234);
string matchTo = "1234";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void LessThanOrEqualM_MultiDigit_RegexMatches_SmallerSameDigitCountMinusOne()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualMagnitude(9999);
string matchTo = "9998";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void LessThan_Positive_RegexMatches_0()
{
string pattern = GetNumberRangePattern.ForLessThan(9);
string matchTo = "0";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void GreaterThanOrEqualTo_Negative_RegexDoesNotMatch_MoreNegative()
{
string pattern = GetNumberRangePattern.ForGreaterThanOrEqualTo(-123);
Assert.IsFalse(Regex.Match("-124", pattern).Success);
Assert.IsFalse(Regex.Match("-1230", pattern).Success);
Assert.IsFalse(Regex.Match("-1000", pattern).Success);
Assert.IsFalse(Regex.Match("-9999", pattern).Success);
Assert.IsFalse(Regex.Match("-999999999999999999999999999999", pattern).Success);
}
public void GreaterThan_Negative_RegexMatches_NegativeCloserToZero()
{
string pattern = GetNumberRangePattern.ForGreaterThan(-9);
string matchTo = "-8";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void GreaterThanOrEqualTo_Negative_RegexMatches_Positive()
{
string pattern = GetNumberRangePattern.ForGreaterThanOrEqualTo(-9);
string matchTo = "9";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void LessThanOrEqualTo_Negative_RegexMatches_Self()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualTo(-110);
string matchTo = "-110";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void LessThan_Negative_RegexMatches_MuchSmaller()
{
string pattern = GetNumberRangePattern.ForLessThan(-51);
string matchTo = "-525252525252";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void LessThan_0_RegexMatches_VeryNegative()
{
string pattern = GetNumberRangePattern.ForLessThan(0);
string matchTo = "-999999999999999999999999999999999";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void LessThanOrEqualM_SingleDigit_RegexMatches_SmallerSingleDigit()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualMagnitude(2);
string matchTo = "1";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void GreaterThanOrEqualM_MultiDigit_RegexMatches_Self()
{
string pattern = GetNumberRangePattern.ForGreaterThanOrEqualMagnitude(8765);
string matchTo = "8765";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchTo, match.Value);
}
public void GreaterThanM_NumberWithinText_RegexMatches_JustLargerNumber()
{
string pattern = GetNumberRangePattern.ForGreaterThanMagnitude(1234);
string matchToNumber = "12345";
string matchTo = $"Abc{matchToNumber} Hello World!";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchToNumber, match.Value);
}
public void LessThanOrEqualM_NumberWithinText_RegexMatches_JustSmallerNumber()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualMagnitude(1000);
string matchToNumber = "999";
string matchTo = $"Abc{matchToNumber} Hello World!";
var match = Regex.Match(matchTo, pattern);
Assert.IsTrue(match.Success);
Assert.AreEqual(matchToNumber, match.Value);
}
public void LessThanOrEqualM_SingleDigit_RegexDoesNotMatch_LargerSingleDigit()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualMagnitude(2);
Assert.IsFalse(Regex.Match("3", pattern).Success);
Assert.IsFalse(Regex.Match("4", pattern).Success);
Assert.IsFalse(Regex.Match("5", pattern).Success);
Assert.IsFalse(Regex.Match("6", pattern).Success);
Assert.IsFalse(Regex.Match("7", pattern).Success);
Assert.IsFalse(Regex.Match("8", pattern).Success);
Assert.IsFalse(Regex.Match("9", pattern).Success);
}
public void GreaterThanM_SingleDigit_RegexDoesNotMatch_SmallerSingleDigit()
{
string pattern = GetNumberRangePattern.ForGreaterThanMagnitude(9);
Assert.IsFalse(Regex.Match("0", pattern).Success);
Assert.IsFalse(Regex.Match("1", pattern).Success);
Assert.IsFalse(Regex.Match("2", pattern).Success);
Assert.IsFalse(Regex.Match("3", pattern).Success);
Assert.IsFalse(Regex.Match("4", pattern).Success);
Assert.IsFalse(Regex.Match("5", pattern).Success);
Assert.IsFalse(Regex.Match("6", pattern).Success);
Assert.IsFalse(Regex.Match("7", pattern).Success);
Assert.IsFalse(Regex.Match("8", pattern).Success);
}
public void GreaterThanM_MultiDigit_RegexDoesNotMatch_SelfMax()
{
string pattern = GetNumberRangePattern.ForGreaterThanMagnitude(9999);
Assert.IsFalse(Regex.Match("9999", pattern).Success);
}
public void LessThan_Negative_RegexDoesNotMatch_Self()
{
string pattern = GetNumberRangePattern.ForLessThan(-9);
Assert.IsFalse(Regex.Match("-9", pattern).Success);
}
public void LessThanM_MultiDigit_RegexDoesNotMatch_Self()
{
string pattern = GetNumberRangePattern.ForLessThanMagnitude(2222);
Assert.IsFalse(Regex.Match("2222", pattern).Success);
}
public void GreaterThanM_SingleDigit_RegexDoesNotMatch_Self()
{
string pattern = GetNumberRangePattern.ForGreaterThanMagnitude(1);
Assert.IsFalse(Regex.Match("1", pattern).Success);
}
public void GreaterThan_Negative_RegexDoesNotMatch_Self()
{
string pattern = GetNumberRangePattern.ForGreaterThan(-123);
Assert.IsFalse(Regex.Match("-123", pattern).Success);
}
public void LessThanOrEqualM_MultiDigit_RegexDoesNotMatch_LeadingZero()
{
string pattern = GetNumberRangePattern.ForLessThanOrEqualMagnitude(1000);
Assert.IsFalse(Regex.Match("010", pattern).Success);
}
