mcs/class/System/Test/System.Text.RegularExpressions/RegexTest.cs

   1 //
   2 // assembly:    System_test
   3 // namespace:   MonoTests.System.Text.RegularExpressions
   4 // file:        RegexTest.cs
   5 //
   6 // Authors:
   7 //   Juraj Skripsky (juraj@hotfeet.ch)
   8 //
   9 // (c) 2003 Juraj Skripsky
  10
  11 using System;
  12 using System.Text.RegularExpressions;
  13
  14 using NUnit.Framework;
  15
  16 namespace MonoTests.System.Text.RegularExpressions {
  17
  18         [TestFixture]
  19         public class RegexTest : Assertion {
  20
  21                 [Test]
  22                 public void Simple () {
  23                         char[] c = { (char)32, (char)8212, (char)32 };
  24                         string s = new String(c);
  25                         Assertion.AssertEquals ("char", true, Regex.IsMatch(s, s));
  26                 }
  27
  28                 [Test]
  29                 public void Unescape () {
  30                         string inString = @"\a\b\t\r\v\f\n\e\02400\x231\cC\ufffff\*";
  31                         char [] c = { (char)7, (char)8, (char)9, (char)13,
  32                                       (char)11, (char)12, (char)10, (char)27,
  33                                       (char)160, (char)48, (char)35, (char)49,
  34                                       (char)3, (char)65535, (char)102, (char)42
  35                         };
  36                         string expectedString = new String(c);
  37                         string outString = Regex.Unescape(inString);
  38
  39                         Assertion.AssertEquals("unescape", outString, expectedString);
  40                 }
  41
  42                 [Test]
  43                 public void Match1 ()
  44                 {
  45                         Regex email = new Regex ("(?<user>[^@]+)@(?<domain>.+)");
  46                         Match m;
  47
  48                         m = email.Match ("mono@go-mono.com");
  49
  50                         Assert ("#m01", m.Success);
  51                         AssertEquals ("#m02", "mono", m.Groups ["user"].Value);
  52                         AssertEquals ("#m03", "go-mono.com", m.Groups ["domain"].Value);
  53
  54                         m = email.Match ("mono.bugs@go-mono.com");
  55                         Assert ("#m04", m.Success);
  56                         AssertEquals ("#m05", "mono.bugs", m.Groups ["user"].Value);
  57                         AssertEquals ("#m06", "go-mono.com", m.Groups ["domain"].Value);
  58                 }
  59
  60                 [Test]
  61                 public void Matches1 ()
  62                 {
  63                         Regex words = new Regex ("(?<word>\\w+)");
  64
  65                         MatchCollection mc = words.Matches ("the fat cat ate the rat");
  66
  67                         AssertEquals ("#m01", 6, mc.Count);
  68                         AssertEquals ("#m02", "the", mc [0].Value);
  69                         AssertEquals ("#m03", "fat", mc [1].Value);
  70                         AssertEquals ("#m04", "cat", mc [2].Value);
  71                         AssertEquals ("#m05", "ate", mc [3].Value);
  72                         AssertEquals ("#m06", "the", mc [4].Value);
  73                         AssertEquals ("#m07", "rat", mc [5].Value);
  74                 }
  75
  76                 [Test]
  77                 public void Matches2 ()
  78                 {
  79                         Regex words = new Regex ("(?<word>\\w+)", RegexOptions.RightToLeft);
  80
  81                         MatchCollection mc = words.Matches ("the fat cat ate the rat");
  82
  83                         AssertEquals ("#m01", 6, mc.Count);
  84                         AssertEquals ("#m02", "the", mc [5].Value);
  85                         AssertEquals ("#m03", "fat", mc [4].Value);
  86                         AssertEquals ("#m04", "cat", mc [3].Value);
  87                         AssertEquals ("#m05", "ate", mc [2].Value);
  88                         AssertEquals ("#m06", "the", mc [1].Value);
  89                         AssertEquals ("#m07", "rat", mc [0].Value);
  90                 }
  91
  92                 [Test]
  93                 public void Matches3 ()
  94                 {
  95                         Regex digits = new Regex ("(?<digit>\\d+)");
  96
  97                         MatchCollection mc = digits.Matches ("0 1 2 3 4 5 6a7b8c9d10");
  98
  99                         AssertEquals ("#m01", 11, mc.Count);
 100                         AssertEquals ("#m02", "0", mc [0].Value);
 101                         AssertEquals ("#m03", "1", mc [1].Value);
 102                         AssertEquals ("#m04", "2", mc [2].Value);
 103                         AssertEquals ("#m05", "3", mc [3].Value);
 104                         AssertEquals ("#m06", "4", mc [4].Value);
 105                         AssertEquals ("#m07", "5", mc [5].Value);
 106                         AssertEquals ("#m08", "6", mc [6].Value);
 107                         AssertEquals ("#m09", "7", mc [7].Value);
 108                         AssertEquals ("#m10", "8", mc [8].Value);
 109                         AssertEquals ("#m11", "9", mc [9].Value);
 110                         AssertEquals ("#m12", "10", mc [10].Value);
 111                 }
 112
 113                 [Test]
 114                 public void Matches4 ()
 115                 {
 116                         Regex digits = new Regex ("(?<digit>\\d+)", RegexOptions.RightToLeft);
 117
 118                         MatchCollection mc = digits.Matches ("0 1 2 3 4 5 6a7b8c9d10");
 119
 120                         AssertEquals ("#m01", 11, mc.Count);
 121                         AssertEquals ("#m02", "0", mc [10].Value);
 122                         AssertEquals ("#m03", "1", mc [9].Value);
 123                         AssertEquals ("#m04", "2", mc [8].Value);
 124                         AssertEquals ("#m05", "3", mc [7].Value);
 125                         AssertEquals ("#m06", "4", mc [6].Value);
 126                         AssertEquals ("#m07", "5", mc [5].Value);
 127                         AssertEquals ("#m08", "6", mc [4].Value);
 128                         AssertEquals ("#m09", "7", mc [3].Value);
 129                         AssertEquals ("#m10", "8", mc [2].Value);
 130                         AssertEquals ("#m11", "9", mc [1].Value);
 131                         AssertEquals ("#m12", "10", mc [0].Value);
 132                 }
 133
 134                 [Test]
 135                 public void Matches5 ()
 136                 {
 137                         Regex lines = new Regex ("(?<line>.+)");
 138
 139                         MatchCollection mc = lines.Matches (story);
 140
 141                         AssertEquals ("#m01", 5, mc.Count);
 142                         AssertEquals ("#m02", "Two little dragons lived in the forest", mc [0].Value);
 143                         AssertEquals ("#m03", "They spent their days collecting honey suckle,",
 144                                         mc [1].Value);
 145                         AssertEquals ("#m04", "And eating curds and whey", mc [2].Value);
 146                         AssertEquals ("#m05", "Until an evil sorcer came along", mc [3].Value);
 147                         AssertEquals ("#m06", "And chased my dragon friends away", mc [4].Value);
 148                 }
 149
 150                 [Test]
 151                 public void Matches6 ()
 152                 {
 153                         Regex lines = new Regex ("(?<line>.+)", RegexOptions.RightToLeft);
 154
 155                         MatchCollection mc = lines.Matches (story);
 156
 157                         AssertEquals ("#m01", 5, mc.Count);
 158                         AssertEquals ("#m02", "Two little dragons lived in the forest", mc [4].Value);
 159                         AssertEquals ("#m03", "They spent their days collecting honey suckle,",
 160                                         mc [3].Value);
 161                         AssertEquals ("#m04", "And eating curds and whey", mc [2].Value);
 162                         AssertEquals ("#m05", "Until an evil sorcer came along", mc [1].Value);
 163                         AssertEquals ("#m06", "And chased my dragon friends away", mc [0].Value);
 164                 }
 165
 166                 string story =  "Two little dragons lived in the forest\n" +
 167                                 "They spent their days collecting honey suckle,\n" +
 168                                 "And eating curds and whey\n" +
 169                                 "Until an evil sorcer came along\n" +
 170                                 "And chased my dragon friends away";
 171
 172                 [Test]
 173                 public void Matches7 ()
 174                 {
 175                         Regex nonwhite = new Regex ("(?<nonwhite>\\S+)");
 176
 177                         MatchCollection mc = nonwhite.Matches ("ab 12 cde 456 fghi .,\niou");
 178
 179                         AssertEquals ("#m01", 7, mc.Count);
 180                         AssertEquals ("#m02", "ab", mc [0].Value);
 181                         AssertEquals ("#m03", "12", mc [1].Value);
 182                         AssertEquals ("#m04", "cde", mc [2].Value);
 183                         AssertEquals ("#m05", "456", mc [3].Value);
 184                         AssertEquals ("#m06", "fghi", mc [4].Value);
 185                         AssertEquals ("#m07", ".,", mc [5].Value);
 186                         AssertEquals ("#m08", "iou", mc [6].Value);
 187                 }
 188
 189                 [Test]
 190                 public void Matches8 ()
 191                 {
 192                         Regex nonwhite = new Regex ("(?<nonwhite>\\S+)", RegexOptions.RightToLeft);
 193
 194                         MatchCollection mc = nonwhite.Matches ("ab 12 cde 456 fghi .,\niou");
 195
 196                         AssertEquals ("#m01", 7, mc.Count);
 197                         AssertEquals ("#m02", "ab", mc [6].Value);
 198                         AssertEquals ("#m03", "12", mc [5].Value);
 199                         AssertEquals ("#m04", "cde", mc [4].Value);
 200                         AssertEquals ("#m05", "456", mc [3].Value);
 201                         AssertEquals ("#m06", "fghi", mc [2].Value);
 202                         AssertEquals ("#m07", ".,", mc [1].Value);
 203                         AssertEquals ("#m08", "iou", mc [0].Value);
 204                 }
 205
 206                 [Test]
 207                 public void Matches9 ()
 208                 {
 209                         Regex nondigit = new Regex ("(?<nondigit>\\D+)");
 210
 211                         MatchCollection mc = nondigit.Matches ("ab0cd1ef2");
 212
 213                         AssertEquals ("#m01", 3, mc.Count);
 214                         AssertEquals ("#m02", "ab", mc [0].Value);
 215                         AssertEquals ("#m02", "cd", mc [1].Value);
 216                         AssertEquals ("#m02", "ef", mc [2].Value);
 217
 218                 }
 219
 220                 [Test]
 221                 public void Matches10 ()
 222                 {
 223                         Regex nondigit = new Regex ("(?<nondigit>\\D+)", RegexOptions.RightToLeft);
 224
 225                         MatchCollection mc = nondigit.Matches ("ab0cd1ef2");
 226
 227                         AssertEquals ("#m01", 3, mc.Count);
 228                         AssertEquals ("#m02", "ab", mc [2].Value);
 229                         AssertEquals ("#m02", "cd", mc [1].Value);
 230                         AssertEquals ("#m02", "ef", mc [0].Value);
 231
 232                 }
 233         }
 234 }
 235