685 lines
20 KiB
C#
685 lines
20 KiB
C#
//
|
||
// MonoTests.System.Text.RegularExpressions misc. test cases
|
||
//
|
||
// Authors:
|
||
// Gonzalo Paniagua Javier (gonzalo@ximian.com)
|
||
//
|
||
// (c) Copyright 2003,2004 Novell, Inc. (http://www.novell.com)
|
||
//
|
||
|
||
using System;
|
||
using System.Text;
|
||
using System.Text.RegularExpressions;
|
||
|
||
using NUnit.Framework;
|
||
|
||
namespace MonoTests.System.Text.RegularExpressions
|
||
{
|
||
[TestFixture]
|
||
public class RegexBugs
|
||
{
|
||
[Test] // bug xamarin#3866
|
||
public void BugXamarin3866 ()
|
||
{
|
||
Assert.AreEqual (new Regex(@"(?<A>a)+(?<-A>b)+(?(A)(?!))b").Match("aaaaaabbb").ToString (), "aabbb");
|
||
}
|
||
|
||
[Test]
|
||
public void BugXamarin2663 ()
|
||
{
|
||
var r = new Regex ("^(S|SW)?$");
|
||
Assert.AreEqual (r.Match ("SW").ToString (), "SW");
|
||
}
|
||
|
||
[Test]
|
||
public void BugXamarin4523 ()
|
||
{
|
||
Assert.AreEqual (new Regex("A(?i)b(?-i)C").Match("ABC").ToString (), "ABC");
|
||
}
|
||
|
||
[Test]
|
||
public void BugXamarin7587 ()
|
||
{
|
||
var pattern = @"(^)a";
|
||
var regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline);
|
||
|
||
var match = regex.Match(" a", 2, 1);
|
||
Assert.AreEqual (match.Success, true);
|
||
Assert.AreEqual (match.Index, 2);
|
||
}
|
||
|
||
[Test]
|
||
public void BugXamarin12612 ()
|
||
{
|
||
const string r_Header = @"citrd";
|
||
|
||
// Terminals
|
||
const string r_begin = @"^";
|
||
const string r_end = @"$";
|
||
const string r_open = @"\[";
|
||
const string r_close = @"\]";
|
||
const string r_letter = @"[a-zA-Z]";
|
||
const string r_non_letter = @"[^a-zA-Z]";
|
||
const string r_alphaNumericChar = @"[a-zA-Z0-9_]";
|
||
const string r_space = @"(//)";
|
||
|
||
// Simple Composition
|
||
const string r_alphaNumericString = r_alphaNumericChar + @"+";
|
||
|
||
const string r_alphaNumericSpaceString = r_alphaNumericChar
|
||
+ @"("
|
||
+ @"(" + r_alphaNumericChar + @"|" + r_space + @")*"
|
||
+ r_alphaNumericChar
|
||
+ @")?";
|
||
|
||
const string r_Identifier = r_letter + r_alphaNumericChar + @"*";
|
||
|
||
const string r_scalar = r_open //[
|
||
+ r_alphaNumericSpaceString
|
||
+ r_close; //]
|
||
|
||
const string r_array = r_open //[
|
||
+ @"("
|
||
+ r_scalar
|
||
+ @")+"
|
||
+ r_close; //]
|
||
|
||
const string r_data = @"(" + r_scalar + @"|" + r_array + @")";
|
||
|
||
// Complex Compositions
|
||
const string r_uncased_Header = @"(?i)" + r_Header + @"(?-i)";
|
||
|
||
const string r_permissable_Identifier = r_Identifier
|
||
+ @"(?<!"
|
||
+ r_non_letter + r_uncased_Header
|
||
+ @")";
|
||
|
||
const string r_captured_Identifier = @"(?<Id>" + r_permissable_Identifier + @")";
|
||
|
||
|
||
const string r_param = @"("
|
||
+ @"(?<p>"
|
||
+ r_permissable_Identifier
|
||
+ r_data
|
||
+ @")"
|
||
+ @")";
|
||
|
||
const string r_paramList = r_param + @"*";
|
||
|
||
|
||
const string r_Encoder_string = r_begin
|
||
+ r_uncased_Header
|
||
+ r_open //[
|
||
+ r_captured_Identifier
|
||
+ r_close //]
|
||
+ r_paramList
|
||
+ r_end;
|
||
|
||
|
||
|
||
|
||
Regex Decoder = new Regex(r_Encoder_string);
|
||
|
||
|
||
Assert.IsFalse(Decoder.IsMatch("citrd[bag]CITRD[1]"));
|
||
}
|
||
|
||
[Test]
|
||
public void BugXamarin11616 ()
|
||
{
|
||
|
||
Assert.AreEqual(Regex.Match("Test", @"^[\w-[\d]]\w*$").Success, true);
|
||
}
|
||
|
||
[Test] // bug #51146
|
||
public void SplitGroup ()
|
||
{
|
||
string [] splitResult = new Regex ("-").Split ("a-bcd-e-fg");
|
||
string [] expected = new string [] {"a", "bcd", "e", "fg"};
|
||
int length = expected.Length;
|
||
Assert.AreEqual (length, splitResult.Length, "#1");
|
||
for (int i = 0; i < length; i++)
|
||
Assert.AreEqual (expected [i], splitResult [i], "#2:" + i);
|
||
|
||
splitResult = new Regex ("(-)").Split ("a-bcd-e-fg");
|
||
expected = new string [] {"a", "-", "bcd", "-", "e", "-", "fg"};
|
||
length = expected.Length;
|
||
Assert.AreEqual (length, splitResult.Length, "#3");
|
||
for (int i = 0; i < length; i++)
|
||
Assert.AreEqual (expected [i], splitResult [i], "#4:" + i);
|
||
|
||
splitResult = new Regex ("(-)b(c)").Split ("a-bcd-e-fg");
|
||
expected = new string [] {"a", "-", "c", "d-e-fg" };
|
||
length = expected.Length;
|
||
Assert.AreEqual (length, splitResult.Length, "#5");
|
||
for (int i = 0; i < length; i++)
|
||
Assert.AreEqual (expected [i], splitResult [i], "#6:" + i);
|
||
|
||
splitResult = new Regex ("-").Split ("a-bcd-e-fg-");
|
||
expected = new string [] {"a", "bcd", "e", "fg", ""};
|
||
length = expected.Length;
|
||
Assert.AreEqual (length, splitResult.Length, "#7");
|
||
for (int i = 0; i < length; i++)
|
||
Assert.AreEqual (expected [i], splitResult [i], "#8:" + i);
|
||
}
|
||
|
||
[Test] // bug #42529
|
||
public void MathEmptyGroup ()
|
||
{
|
||
string str = "Match something from here.";
|
||
|
||
Assert.IsFalse (Regex.IsMatch(str, @"(something|dog)$"), "#1");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(|something|dog)$"), "#2");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(something||dog)$"), "#3");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(something|dog|)$"), "#4");
|
||
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(something|dog)*"), "#5");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(|something|dog)*"), "#6");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(something||dog)*"), "#7");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(something|dog|)*"), "#8");
|
||
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(something|dog)*$"), "#9");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(|something|dog)*$"), "#10");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(something||dog)*$"), "#11");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"(something|dog|)*$"), "#12");
|
||
}
|
||
|
||
[Test] // bug #52924
|
||
public void Braces ()
|
||
{
|
||
Regex regVar = new Regex(@"{\w+}");
|
||
Match m = regVar.Match ("{ }");
|
||
Assert.IsFalse (m.Success);
|
||
}
|
||
|
||
[Test] // bug #71077
|
||
public void WhiteSpaceGroupped ()
|
||
{
|
||
string s = "\n";
|
||
string p = @"[\s\S]"; // =Category.Any
|
||
Assert.IsTrue (Regex.IsMatch (s, p));
|
||
}
|
||
|
||
[Test] // Bug #577346
|
||
public void CharacterClassParse ()
|
||
{
|
||
var foo = new Regex("[\\177-\\377]");
|
||
}
|
||
|
||
[Test] // bug #45976
|
||
public void RangeIgnoreCase()
|
||
{
|
||
string str = "AAABBBBAAA" ;
|
||
Assert.IsTrue (Regex.IsMatch(str, @"[A-F]+", RegexOptions.IgnoreCase), "#A1");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[a-f]+", RegexOptions.IgnoreCase), "#A2");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[A-Fa-f]+", RegexOptions.IgnoreCase), "#A3");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[AB]+", RegexOptions.IgnoreCase), "#A4");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[A-B]+", RegexOptions.IgnoreCase), "#A5");
|
||
|
||
str = "AaaBBBaAa" ;
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[A-F]+", RegexOptions.IgnoreCase), "#B1");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[a-f]+", RegexOptions.IgnoreCase), "#B2");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[A-Fa-f]+", RegexOptions.IgnoreCase), "#B3");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[AB]+", RegexOptions.IgnoreCase), "#B4");
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[A-B]+", RegexOptions.IgnoreCase), "#B5");
|
||
|
||
str = "Aaa[";
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[A-a]+", RegexOptions.IgnoreCase), "#C");
|
||
|
||
str = "Ae";
|
||
Assert.IsTrue (Regex.IsMatch (str, @"[A-a]+", RegexOptions.IgnoreCase), "#D");
|
||
}
|
||
|
||
[Test] // bug #54797
|
||
public void Escape0 ()
|
||
{
|
||
Regex r = new Regex(@"^[\s\0]*$");
|
||
Assert.IsTrue (r.Match(" \0").Success);
|
||
}
|
||
|
||
[Test] // bug #432172
|
||
public void NoBitmap ()
|
||
{
|
||
Regex rx =
|
||
new Regex ("([^a-zA-Z_0-9])+", RegexOptions.Compiled);
|
||
Assert.AreEqual ("--", rx.Match ("A--B-").Value);
|
||
}
|
||
|
||
[Test]
|
||
public void MultipleMatches()
|
||
{
|
||
Regex regex = new Regex (@"^(?'path'.*(\\|/)|(/|\\))(?'file'.*)$");
|
||
Match match = regex.Match (@"d:\Temp\SomeDir\SomeDir\bla.xml");
|
||
|
||
Assert.AreEqual (5, match.Groups.Count, "#1");
|
||
Assert.AreEqual ("1", regex.GroupNameFromNumber (1), "#2");
|
||
Assert.AreEqual ("2", regex.GroupNameFromNumber (2), "#3");
|
||
Assert.AreEqual ("path", regex.GroupNameFromNumber (3), "#4");
|
||
Assert.AreEqual ("file", regex.GroupNameFromNumber (4), "#5");
|
||
Assert.AreEqual ("\\", match.Groups [1].Value, "#6");
|
||
Assert.AreEqual (string.Empty, match.Groups [2].Value, "#7");
|
||
Assert.AreEqual (@"d:\Temp\SomeDir\SomeDir\", match.Groups [3].Value, "#8");
|
||
Assert.AreEqual ("bla.xml", match.Groups [4].Value, "#9");
|
||
}
|
||
|
||
[Test] // bug #56000
|
||
public void SameNameGroups ()
|
||
{
|
||
string rex = "link\\s*rel\\s*=\\s*[\"']?alternate[\"']?\\s*";
|
||
rex += "type\\s*=\\s*[\"']?text/xml[\"']?\\s*href\\s*=\\s*(?:\"(?<1>[^\"]*)\"|'(?<1>[^']*)'|(?<1>\\S+))";
|
||
new Regex (rex, RegexOptions.IgnoreCase);
|
||
}
|
||
|
||
[Test] // bug #52890
|
||
public void UndefinedGroup ()
|
||
{
|
||
Regex regex = new Regex( "[A-Za-z_0-9]" );
|
||
Match m = regex.Match( "123456789abc" );
|
||
Group g = m.Groups["not_defined"];
|
||
Assert.IsNotNull (g, "#1");
|
||
Assert.AreEqual (0, g.Index, "#2");
|
||
Assert.AreEqual (0, g.Length, "#3");
|
||
Assert.AreEqual (string.Empty, g.Value, "#4");
|
||
Assert.IsFalse (g.Success, "#5");
|
||
Assert.IsNotNull (g.Captures, "#6");
|
||
Assert.AreEqual (0, g.Captures.Count, "#7");
|
||
}
|
||
|
||
[Test]
|
||
public void Quantifiers1 ()
|
||
{
|
||
Regex re = new Regex ("[\\w\\W]{8,32}");
|
||
Match m = re.Match (new string ('1', 7));
|
||
Assert.IsFalse (m.Success);
|
||
}
|
||
|
||
[Test]
|
||
public void Quantifiers2 ()
|
||
{
|
||
Regex re = new Regex ("[\\w\\W]{8,32}");
|
||
Match m = re.Match (new string ('1', 8));
|
||
Assert.IsTrue (m.Success);
|
||
}
|
||
|
||
[Test]
|
||
public void Quantifiers3 ()
|
||
{
|
||
Regex re = new Regex ("[\\w\\W]{8,32}");
|
||
Match m = re.Match (new string ('1', 16));
|
||
Assert.IsTrue (m.Success);
|
||
}
|
||
|
||
[Test]
|
||
public void Quantifiers4 ()
|
||
{
|
||
Regex re = new Regex ("[\\w\\W]{8,32}");
|
||
Match m = re.Match (new string ('1', 32));
|
||
Assert.IsTrue (m.Success);
|
||
}
|
||
|
||
[Test]
|
||
public void Quantifiers5 ()
|
||
{
|
||
Regex re = new Regex ("[\\w\\W]{8,32}");
|
||
Match m = re.Match (new string ('1', 33));
|
||
Assert.IsTrue (m.Success);
|
||
}
|
||
|
||
[Test]
|
||
public void CategoryAndNegated () // Was a regression after first attemp to fix 59150.
|
||
{
|
||
string text = "<?xml version=\"1.0\"?>";
|
||
Regex re = new Regex ("<\\s*(\\/?)\\s*([\\s\\S]*?)\\s*(\\/?)\\s*>");
|
||
text = re.Replace (text, "{blue:<$1}{maroon:$2}{blue:$3>}");
|
||
Assert.AreEqual ("{blue:<}{maroon:?xml version=\"1.0\"?}{blue:>}", text);
|
||
}
|
||
|
||
[Test]
|
||
public void BackSpace ()
|
||
{
|
||
string text = "Go, \bNo\bGo" ;
|
||
Regex re = new Regex(@"\b[\b]");
|
||
text = re.Replace(text, " ");
|
||
Assert.AreEqual ("Go, \bNo Go", text);
|
||
}
|
||
|
||
[Test]
|
||
public void ReplaceNegOneAndStartat ()
|
||
{
|
||
string text = "abcdeeee";
|
||
Regex re = new Regex("e+");
|
||
text = re.Replace(text, "e", -1, 4);
|
||
Assert.AreEqual ("abcde", text);
|
||
}
|
||
|
||
[Test] // bug #57274
|
||
public void SplitInfiniteLoop ()
|
||
{
|
||
string ss = "a b c d e";
|
||
string [] words = Regex.Split (ss, "[ \t\n\r]*");
|
||
Assert.AreEqual (11, words.Length, "#1");
|
||
Assert.AreEqual (string.Empty, words [0], "#2");
|
||
Assert.AreEqual ("a", words [1], "#3");
|
||
Assert.AreEqual (string.Empty, words [2], "#4");
|
||
Assert.AreEqual ("b", words [3], "#5");
|
||
Assert.AreEqual (string.Empty, words [4], "#6");
|
||
Assert.AreEqual ("c", words [5], "#7");
|
||
Assert.AreEqual (string.Empty, words [6], "#8");
|
||
Assert.AreEqual ("d", words [7], "#9");
|
||
Assert.AreEqual (string.Empty, words [8], "#10");
|
||
Assert.AreEqual ("e", words [9], "#11");
|
||
Assert.AreEqual (string.Empty, words [10], "#12");
|
||
}
|
||
|
||
[Test] // bug #69065
|
||
public void CaseAndSearch ()
|
||
{
|
||
string test1 = @" !E ZWEITBAD :REGLER-PARAMETER 20.10.2004 SEITE 1";
|
||
string test2 = @" REGLER-PARAMETER ";
|
||
string test3 = @"REGLER-PARAMETER ";
|
||
Regex x = new Regex ("REGLER-PARAMETER",RegexOptions.IgnoreCase|RegexOptions.Compiled);
|
||
|
||
Match m = x.Match (test1);
|
||
Assert.IsTrue (m.Success, "#1");
|
||
|
||
m = x.Match (test2);
|
||
Assert.IsTrue (m.Success, "#2");
|
||
|
||
m = x.Match (test3);
|
||
Assert.IsTrue (m.Success, "#3");
|
||
}
|
||
|
||
[Test] // bug #69193
|
||
public void QuantifiersParseError ()
|
||
{
|
||
new Regex ("{1,a}");
|
||
new Regex ("{a,1}");
|
||
new Regex ("{a}");
|
||
new Regex ("{,a}");
|
||
}
|
||
|
||
[Test] // bug #74753
|
||
public void NameLookupInEmptyMatch ()
|
||
{
|
||
Regex regTime = new Regex (
|
||
@"(?<hour>[0-9]{1,2})([\:](?<minute>[0-9]{1,2})){0,1}([\:](?<second>[0-9]{1,2})){0,1}\s*(?<ampm>(?i:(am|pm)){0,1})");
|
||
|
||
Match mTime = regTime.Match("");
|
||
Assert.AreEqual ("", mTime.Groups["hour"].Value, "#A1");
|
||
Assert.AreEqual ("", mTime.Groups ["minute"].Value, "#A2");
|
||
Assert.AreEqual ("", mTime.Groups ["second"].Value, "#A3");
|
||
Assert.AreEqual ("", mTime.Groups ["ampm"].Value, "#A4");
|
||
|
||
mTime = regTime.Match("12:00 pm");
|
||
Assert.AreEqual ("12", mTime.Groups ["hour"].Value, "#B1");
|
||
Assert.AreEqual ("00", mTime.Groups ["minute"].Value, "#B2");
|
||
Assert.AreEqual ("", mTime.Groups ["second"].Value, "#B3");
|
||
Assert.AreEqual ("pm", mTime.Groups ["ampm"].Value, "#B4");
|
||
}
|
||
|
||
[Test] // bug #77626
|
||
public void HangingHyphens ()
|
||
{
|
||
Assert.IsTrue (Regex.IsMatch ("mT1[", @"m[0-9A-Za-z_-]+\["), "#A1");
|
||
Assert.IsTrue (Regex.IsMatch ("mT1[", @"m[-0-9A-Za-z_]+\["), "#A2");
|
||
|
||
Assert.IsTrue (Regex.IsMatch ("-a;", @"[--a]{3}"), "#B1");
|
||
Assert.IsTrue (Regex.IsMatch ("-&,", @"[&--]{3}"), "#B2");
|
||
|
||
Assert.IsTrue (Regex.IsMatch ("abcz-", @"[a-c-z]{5}"), "#C1");
|
||
Assert.IsFalse (Regex.IsMatch ("defghijklmnopqrstuvwxy", @"[a-c-z]"), "#C2");
|
||
|
||
Assert.IsTrue (Regex.IsMatch ("abcxyz-", @"[a-c-x-z]{7}"), "#D1");
|
||
Assert.IsFalse (Regex.IsMatch ("defghijklmnopqrstuvw", @"[a-c-x-z]"), "#D2");
|
||
|
||
Assert.IsTrue (Regex.IsMatch (" \tz-", @"[\s-z]{4}"), "#E1");
|
||
Assert.IsFalse (Regex.IsMatch ("abcdefghijklmnopqrstuvwxy", @"[\s-z]"), "#E2");
|
||
}
|
||
|
||
[Test, ExpectedException (typeof (ArgumentException))]
|
||
public void HangingHyphen1 ()
|
||
{
|
||
Regex.IsMatch ("foobar", @"[a-\s]");
|
||
}
|
||
|
||
[Test]
|
||
public void Bug313642 ()
|
||
{
|
||
Regex r = new Regex ("(?<a>c)");
|
||
Match m = r.Match ("a");
|
||
Assert.AreEqual (1, m.Groups.Count, "#1");
|
||
Assert.AreEqual (0, m.Groups [0].Captures.Count, "#2");
|
||
Assert.AreEqual (0, m.Groups [0].Index, "#3");
|
||
Assert.AreEqual (0, m.Groups [0].Length, "#4");
|
||
Assert.IsFalse (m.Groups [0].Success, "#5");
|
||
Assert.AreEqual (string.Empty, m.Groups [0].Value, "#6");
|
||
}
|
||
|
||
[Test]
|
||
public void Bug77487 ()
|
||
{
|
||
Assert.IsTrue (Regex.IsMatch ("a a", "^(a[^a]*)*a$"), "#1");
|
||
Assert.IsTrue (Regex.IsMatch ("a a", "^(a *)*a$"), "#2");
|
||
Assert.IsTrue (Regex.IsMatch ("a a", "(a[^a]*)+a"), "#3");
|
||
Assert.IsTrue (Regex.IsMatch ("a a", "(a *)+a"), "#4");
|
||
}
|
||
|
||
[Test]
|
||
public void Bug69269 ()
|
||
{
|
||
string s = "CREATE aa\faa; CREATE bb\nbb; CREATE cc\rcc; CREATE dd\tdd; CREATE ee\vee;";
|
||
Assert.AreEqual (5, Regex.Matches(s, @"CREATE[\s\S]+?;").Count, "#1");
|
||
Assert.AreEqual (5, Regex.Matches (s, @"CREATE[ \f\n\r\t\v\S]+?;").Count, "#2");
|
||
}
|
||
|
||
[Test]
|
||
public void Bug76345 ()
|
||
{
|
||
Match m;
|
||
string s1 = "'asdf'";
|
||
string s2 = "'as,'df'";
|
||
|
||
m = new Regex("'.*?'").Match(s1);
|
||
Assert.IsTrue (m.Success, "#A1");
|
||
Assert.AreEqual (s1, m.Value, "#A2");
|
||
|
||
m = new Regex("'[^,].*?'").Match(s1);
|
||
Assert.IsTrue (m.Success, "#B1");
|
||
Assert.AreEqual (s1, m.Value, "#B2");
|
||
|
||
m = new Regex("'.*?[^,]'").Match(s1);
|
||
Assert.IsTrue (m.Success, "#C1");
|
||
Assert.AreEqual (s1, m.Value, "#C2");
|
||
|
||
m = new Regex("'.*?[^,]'").Match(s2);
|
||
Assert.IsTrue (m.Success, "#D1");
|
||
Assert.AreEqual (s2, m.Value, "#D2");
|
||
}
|
||
|
||
[Test]
|
||
public void Bug78007 ()
|
||
{
|
||
string test = "head><html>";
|
||
string pattern = @"\Ahead>\<html\>";
|
||
Regex r = new Regex (pattern);
|
||
Match m = r.Match (test);
|
||
Assert.IsTrue (m.Success, "#A1");
|
||
Assert.AreEqual (0, m.Index, "#A2");
|
||
Assert.AreEqual (14, m.Length, "#A3");
|
||
|
||
m = m.NextMatch ();
|
||
Assert.IsFalse (m.Success, "#B");
|
||
}
|
||
|
||
[Test]
|
||
public void Bug439947 ()
|
||
{
|
||
Regex r;
|
||
r = new Regex ("(?<=^|/)[^/]*\\.cs$", RegexOptions.None);
|
||
Assert.IsTrue (r.IsMatch ("z/text2.cs"));
|
||
|
||
r = new Regex ("(?<=^|/)[^/]*\\.cs$", RegexOptions.Compiled);
|
||
Assert.IsTrue (r.IsMatch ("z/text2.cs"));
|
||
}
|
||
|
||
[Test]
|
||
public void bug443841 ()
|
||
{
|
||
string numberString = @"[0-9]+";
|
||
string doubleString = string.Format (@" *[+-]? *{0}(\.{0})?([eE][+-]?{0})? *",
|
||
numberString);
|
||
string vector1To3String = string.Format (@"{0}(,{0}(,{0})?)?",
|
||
doubleString);
|
||
Regex r;
|
||
MatchCollection matches;
|
||
|
||
r = new Regex (string.Format ("^{0}$", vector1To3String));
|
||
Assert.IsTrue (r.IsMatch ("1"), "#A1");
|
||
matches = r.Matches ("1");
|
||
Assert.AreEqual (1, matches.Count, "#A2");
|
||
Assert.AreEqual ("1", matches [0].Value, "#A3");
|
||
|
||
r = new Regex (string.Format ("^{0}$", vector1To3String),
|
||
RegexOptions.Compiled);
|
||
Assert.IsTrue (r.IsMatch ("1"), "#B1");
|
||
matches = r.Matches ("1");
|
||
Assert.AreEqual (1, matches.Count, "#B2");
|
||
Assert.AreEqual ("1", matches [0].Value, "#B3");
|
||
}
|
||
|
||
[Test]
|
||
public void CharClassWithIgnoreCase ()
|
||
{
|
||
string str = "Foobar qux";
|
||
Regex re = new Regex (@"[a-z\s]*", RegexOptions.IgnoreCase);
|
||
Match m = re.Match (str);
|
||
Assert.AreEqual (str, m.Value);
|
||
}
|
||
|
||
[Test] // bug #78278
|
||
public void No65535Limit ()
|
||
{
|
||
Kill65535_1 (65535);
|
||
Kill65535_1 (65536);
|
||
Kill65535_1 (131071);
|
||
Kill65535_1 (131072);
|
||
|
||
Kill65535_2 (65530);
|
||
Kill65535_2 (65531);
|
||
Kill65535_2 (131066);
|
||
Kill65535_2 (131067);
|
||
}
|
||
|
||
[Test]
|
||
public void GroupNumbers ()
|
||
{
|
||
GroupNumbers_1 ("a", 1);
|
||
GroupNumbers_1 ("(a)", 2);
|
||
GroupNumbers_1 ("(a)(b)", 3);
|
||
GroupNumbers_1 ("(a)|(b)", 3);
|
||
GroupNumbers_1 ("((a)(b))(c)", 5);
|
||
}
|
||
|
||
[Test]
|
||
public void Trials ()
|
||
{
|
||
foreach (RegexTrial trial in trials)
|
||
trial.Execute ();
|
||
}
|
||
|
||
[Test]
|
||
public void Bug80554_0 ()
|
||
{
|
||
bug80554_trials [0].Execute ();
|
||
}
|
||
|
||
[Test]
|
||
public void Bug80554_1 ()
|
||
{
|
||
bug80554_trials [1].Execute ();
|
||
}
|
||
|
||
[Test]
|
||
public void Bug80554_2 ()
|
||
{
|
||
bug80554_trials [2].Execute ();
|
||
}
|
||
|
||
[Test]
|
||
public void Bug80554_3 ()
|
||
{
|
||
bug80554_trials [3].Execute ();
|
||
}
|
||
|
||
[Test]
|
||
public void Bug432172 ()
|
||
{
|
||
new Regex ("^(else|elif|except|finally)([^a-zA-Z_0-9]).*", RegexOptions.Compiled);
|
||
}
|
||
|
||
|
||
[Test]
|
||
public void Bug610587_RepetitionOfPositionAssertion ()
|
||
{
|
||
Assert.AreEqual ("888", Regex.Match("888", "^*8.*").Value);
|
||
}
|
||
|
||
void Kill65535_1 (int length)
|
||
{
|
||
StringBuilder sb = new StringBuilder ("x");
|
||
sb.Append ('a', length);
|
||
sb.Append ('y');
|
||
string teststring = sb.ToString ();
|
||
Regex regex = new Regex (@"xa*y");
|
||
Match m = regex.Match (teststring);
|
||
Assert.IsTrue (m.Success, "#1:" + length);
|
||
Assert.AreEqual (0, m.Index, "#2:" + length);
|
||
Assert.AreEqual (teststring.Length, m.Length, "#3:" + length);
|
||
}
|
||
|
||
void Kill65535_2 (int length)
|
||
{
|
||
StringBuilder sb = new StringBuilder ("xaaaax");
|
||
sb.Append ('a', length);
|
||
sb.Append ('y');
|
||
string teststring = sb.ToString ();
|
||
Regex regex = new Regex (@"x.*y");
|
||
Match m = regex.Match(teststring);
|
||
Assert.IsTrue (m.Success, "#1:" + length);
|
||
Assert.AreEqual (0, m.Index, "#2:" + length);
|
||
Assert.AreEqual (teststring.Length, m.Length, "#3:" + length);
|
||
}
|
||
|
||
void GroupNumbers_1 (string s, int n)
|
||
{
|
||
Regex r = new Regex (s);
|
||
int [] grps = r.GetGroupNumbers ();
|
||
Assert.AreEqual (n, grps.Length, "#1:" + r);
|
||
|
||
int sum = 0;
|
||
for (int i = 0; i < grps.Length; ++i) {
|
||
sum += grps [i];
|
||
// group numbers are unique
|
||
for (int j = 0; j < i; ++j)
|
||
Assert.IsTrue (grps [i] != grps [j], "#2:" + r + " (" + i + "," + j + ")");
|
||
}
|
||
// no gaps in group numbering
|
||
Assert.AreEqual ((n * (n - 1)) / 2, sum, "#3:" + r);
|
||
}
|
||
|
||
|
||
static string bug80554_s = @"(?(static)|(.*))(static)";
|
||
static RegexTrial[] bug80554_trials = {
|
||
new RegexTrial (bug80554_s, RegexOptions.None, "static", "Pass. Group[0]=(0,6) Group[1]= Group[2]=(0,6)"),
|
||
new RegexTrial (bug80554_s, RegexOptions.None, "hydrostatic", "Pass. Group[0]=(0,11) Group[1]=(0,5) Group[2]=(5,6)"),
|
||
new RegexTrial (bug80554_s, RegexOptions.None, "statics", "Pass. Group[0]=(0,6) Group[1]= Group[2]=(0,6)"),
|
||
new RegexTrial (bug80554_s, RegexOptions.None, "dynamic", "Fail.")
|
||
};
|
||
|
||
static RegexTrial[] trials = {
|
||
new RegexTrial (@"^[^.\d]*(\d+)(?:\D+(\d+))?", RegexOptions.None, "MD 9.18", "Pass. Group[0]=(0,7) Group[1]=(3,1) Group[2]=(5,2)"),
|
||
new RegexTrial (@"(.*:|.*)(DirName)", RegexOptions.Compiled, "/home/homedir/DirName", "Pass. Group[0]=(0,21) Group[1]=(0,14) Group[2]=(14,7)")
|
||
};
|
||
}
|
||
}
|