mcs/class/System.Web.Routing/Test/System.Web.Routing/RouteTest.cs

   1 //
   2 // RouteTest.cs
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // Copyright (C) 2008-2009 Novell Inc. http://novell.com
   8 //
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30 using System;
  31 using System.IO;
  32 using System.Web;
  33 using System.Web.Routing;
  34 using NUnit.Framework;
  35
  36 namespace MonoTests.System.Web.Routing
  37 {
  38         class TestUrl
  39         {
  40                 public string Url { get; set; }
  41                 public string Expected { get; set; }
  42                 public string Label { get; set; }
  43                 public Type ExpectedExceptionType { get; set; }
  44         }
  45
  46         [TestFixture]
  47         public class RouteTest
  48         {
  49                 [Test]
  50                 public void ConstructorNullArgs ()
  51                 {
  52                         var r = new Route (null, null);
  53                         Assert.AreEqual (String.Empty, r.Url);
  54                         Assert.IsNull (r.RouteHandler);
  55                 }
  56
  57                 [Test]
  58                 public void SetNullUrl ()
  59                 {
  60                         var r = new Route (null, null);
  61                         r.Url = "urn:foo";
  62                         r.Url = null;
  63                         Assert.AreEqual (String.Empty, r.Url);
  64                 }
  65
  66                 static readonly TestUrl[] __invalidUrls = {
  67                         // cannot start with '~'
  68                         new TestUrl () { Url = "~", ExpectedExceptionType = typeof (ArgumentException), Label = "#1" },
  69
  70                         // cannot start with '/'
  71                         new TestUrl () { Url = "/", ExpectedExceptionType = typeof (ArgumentException), Label = "#2" },
  72
  73                         // cannot contain '?'
  74                         new TestUrl () { Url = "foo?bar", ExpectedExceptionType = typeof (ArgumentException), Label = "#3" },
  75
  76                         // unmatched '{'
  77                         new TestUrl () { Url = "foo/{bar", ExpectedExceptionType = typeof (ArgumentException), Label = "#4" },
  78
  79                         // unmatched '}'
  80                         new TestUrl () { Url = "foo/bar}", ExpectedExceptionType = typeof (ArgumentException), Label = "#5"  },
  81
  82                         // "" is an invalid parameter name.
  83                         new TestUrl () { Url = "foo/{}", ExpectedExceptionType = typeof (ArgumentException), Label = "#6" },
  84
  85                         // incomplete parameter in path segment.
  86                         new TestUrl () { Url = "foo/{x/y/z}", ExpectedExceptionType = typeof (ArgumentException), Label = "#7" },
  87
  88                         // regarded as an incomplete parameter
  89                         new TestUrl () { Url = "foo/{a{{b}}c}", ExpectedExceptionType = typeof (ArgumentException), Label = "#8" },
  90
  91                         // consecutive parameters are not allowed
  92                         new TestUrl () { Url = "foo/{a}{b}", ExpectedExceptionType = typeof (ArgumentException), Label = "#9" },
  93
  94                         // consecutive segment separators '/' are not allowed
  95                         new TestUrl () { Url = "foo//bar", ExpectedExceptionType = typeof (ArgumentException), Label = "#10" },
  96
  97                         // A catch-all parameter can only appear as the last segment of the route URL
  98                         new TestUrl () { Url = "{first}/{*rest}/{foo}", ExpectedExceptionType = typeof (ArgumentException), Label = "#11" },
  99
 100                         // A path segment that contains more than one section, such as a literal section or a parameter, cannot contain a catch-all parameter.
 101                         new TestUrl () { Url = "{first}/{*rest}-{foo}", ExpectedExceptionType = typeof (ArgumentException), Label = "#12" },
 102
 103                         // A path segment that contains more than one section, such as a literal section or a parameter, cannot contain a catch-all parameter.
 104                         new TestUrl () { Url = "{first}/{foo}-{*rest}", ExpectedExceptionType = typeof (ArgumentException), Label = "#13" },
 105
 106                         // A path segment that contains more than one section, such as a literal section or a parameter, cannot contain a catch-all parameter.
 107                         new TestUrl () { Url = "-{*rest}", ExpectedExceptionType = typeof (ArgumentException), Label = "#14" },
 108                 };
 109
 110                 [Test]
 111                 public void InvalidUrls ()
 112                 {
 113                         Route r;
 114
 115                         foreach (TestUrl tu in __invalidUrls) {
 116                                 AssertExtensions.Throws (tu.ExpectedExceptionType, () => r = new Route (tu.Url, null), tu.Label);
 117                         }
 118                 }
 119
 120                 static readonly TestUrl[] __validUrls = {
 121                         new TestUrl () { Url = "{foo}/{bar}", Expected = "{foo}/{bar}", Label = "#1" },
 122                         new TestUrl () { Url = "a~c", Expected = "a~c", Label = "#2" },
 123                         new TestUrl () { Url = "foo/", Expected = "foo/", Label = "#3" },
 124                         new TestUrl () { Url = "summary/{action}-{type}/{page}", Expected = "summary/{action}-{type}/{page}", Label = "#4" },
 125                         new TestUrl () { Url = "{first}/{*rest}", Expected = "{first}/{*rest}", Label = "#5" },
 126                         new TestUrl () { Url = "{language}-{country}/{controller}/{action}", Expected = "{language}-{country}/{controller}/{action}", Label = "#6" },
 127                         new TestUrl () { Url = "{controller}.{action}.{id}", Expected = "{controller}.{action}.{id}", Label = "#7" },
 128                         new TestUrl () { Url = "{reporttype}/{year}/{month}/{date}", Expected = "{reporttype}/{year}/{month}/{date}", Label = "#8" },
 129                         new TestUrl () { Url = "Book{title}and{foo}", Expected = "Book{title}and{foo}", Label = "#9" },
 130                         new TestUrl () { Url = "foo/{ }", Expected = "foo/{ }", Label = "#10" },
 131                         new TestUrl () { Url = "foo/{ \t}", Expected = "foo/{ \t}", Label = "#11" },
 132                         new TestUrl () { Url = "foo/{ \n}", Expected = "foo/{ \n}", Label = "#12" },
 133                         new TestUrl () { Url = "foo/{ \t\n}", Expected = "foo/{ \t\n}", Label = "#13" },
 134                         new TestUrl () { Url = "-{foo}", Expected = "-{foo}", Label = "#14" },
 135                 };
 136
 137                 [Test]
 138                 public void ValidUrls ()
 139                 {
 140                         Route r;
 141
 142                         foreach (TestUrl tu in __validUrls) {
 143                                 r = new Route (tu.Url, null);
 144                                 Assert.AreEqual (tu.Expected, r.Url, tu.Label);
 145                                 Assert.IsNull (r.DataTokens, tu.Label + "-2");
 146                                 Assert.IsNull (r.Defaults, tu.Label + "-3");
 147                                 Assert.IsNull (r.Constraints, tu.Label + "-4");
 148                         }
 149                 }
 150
 151                 [Test]
 152                 public void RoutingHandler ()
 153                 {
 154                         var r = new Route (null, new StopRoutingHandler ());
 155                         Assert.AreEqual (typeof (StopRoutingHandler), r.RouteHandler.GetType (), "#1");
 156                 }
 157
 158                 [Test]
 159                 public void GetRouteDataNoTemplate ()
 160                 {
 161                         var r = new Route ("foo/bar", null);
 162                         var hc = new HttpContextStub ("~/foo/bar", String.Empty);
 163                         var rd = r.GetRouteData (hc);
 164                         Assert.IsNotNull (rd, "#1");
 165                         Assert.AreEqual (r, rd.Route, "#2");
 166                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 167                         Assert.AreEqual (0, rd.Values.Count, "#4");
 168                 }
 169
 170                 [Test]
 171                 [ExpectedException (typeof (InvalidOperationException))]
 172                 public void InvalidConstraint ()
 173                 {
 174                         var r = new Route ("{foo}/{bar}", new StopRoutingHandler ());
 175                         var c = new RouteValueDictionary ();
 176                         c ["foo"] = Guid.NewGuid ();
 177                         r.Constraints = c;
 178                         var hc = new HttpContextStub ("~/x/y", String.Empty);
 179                         var rd = r.GetRouteData (hc);
 180                 }
 181
 182                 [Test]
 183                 public void GetRouteData ()
 184                 {
 185                         var r = new Route ("{foo}/{bar}", null);
 186                         var hc = new HttpContextStub ("~/x/y", String.Empty);
 187                         var rd = r.GetRouteData (hc);
 188                         Assert.IsNotNull (rd, "#1");
 189                         Assert.AreEqual (r, rd.Route, "#2");
 190                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 191                         Assert.AreEqual (2, rd.Values.Count, "#4");
 192                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 193                         Assert.AreEqual ("y", rd.Values ["bar"], "#4-2");
 194                 }
 195
 196                 [Test]
 197                 public void GetRouteData2 ()
 198                 {
 199                         // {} matches and substitutes even at partial state ...
 200                         var r = new Route ("{foo}/bar{baz}", null);
 201                         var hc = new HttpContextStub ("~/x/bart", String.Empty);
 202                         var rd = r.GetRouteData (hc);
 203                         Assert.IsNotNull (rd, "#1");
 204                         Assert.AreEqual (r, rd.Route, "#2");
 205                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 206                         Assert.AreEqual (2, rd.Values.Count, "#4");
 207                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 208                         Assert.AreEqual ("t", rd.Values ["baz"], "#4-2");
 209                 }
 210
 211                 [Test]
 212                 public void GetRouteData3 ()
 213                 {
 214                         var r = new Route ("{foo}/{bar}", null);
 215                         var hc = new HttpContextStub ("~/x/y/z", String.Empty);
 216                         var rd = r.GetRouteData (hc);
 217                         Assert.IsNull (rd); // mismatch
 218                 }
 219
 220                 [Test]
 221                 public void GetRouteData4 ()
 222                 {
 223                         var r = new Route ("{foo}/{bar}", null);
 224                         var hc = new HttpContextStub ("~/x", String.Empty);
 225                         var rd = r.GetRouteData (hc);
 226                         Assert.IsNull (rd); // mismatch
 227                 }
 228
 229                 [Test]
 230                 public void GetRouteData5 ()
 231                 {
 232                         var r = new Route ("{foo}/{bar}", new StopRoutingHandler ());
 233                         var rd = r.GetRouteData (new HttpContextStub ("x/y", String.Empty));
 234                         Assert.IsNull (rd, "#1");
 235                         rd = r.GetRouteData (new HttpContextStub ("~/x/y", String.Empty));
 236                         Assert.IsNotNull (rd, "#2");
 237                         rd = r.GetRouteData (new HttpContextStub ("~/x/y/z", String.Empty));
 238                         Assert.IsNull (rd, "#3");
 239                         rd = r.GetRouteData (new HttpContextStub ("~x/y", String.Empty));
 240                         Assert.IsNull (rd, "#4");
 241                         rd = r.GetRouteData (new HttpContextStub ("/x/y", String.Empty));
 242                         Assert.IsNull (rd, "#5");
 243
 244                         rd = r.GetRouteData (new HttpContextStub ("{foo}/{bar}/baz", String.Empty));
 245                         Assert.IsNull (rd, "#6");
 246                         rd = r.GetRouteData (new HttpContextStub ("{foo}/{bar}", String.Empty));
 247                         Assert.IsNotNull (rd, "#7");
 248                         Assert.AreEqual (0, rd.DataTokens.Count, "#7-2");
 249                         Assert.AreEqual (2, rd.Values.Count, "#7-3");
 250                 }
 251
 252                 [Test]
 253                 public void GetRouteData6 ()
 254                 {
 255                         var r = new Route ("{table}/{action}.aspx", null);
 256                         var rd = r.GetRouteData (new HttpContextStub ("~/FooTable/List.aspx", String.Empty));
 257                         Assert.IsNotNull (rd, "#1");
 258                         Assert.AreEqual ("FooTable", rd.Values ["table"], "#2");
 259                         Assert.AreEqual ("List", rd.Values ["action"], "#3");
 260                 }
 261
 262                 [Test]
 263                 public void GetRouteData7 ()
 264                 {
 265                         var r = new Route ("{table}/{action}.aspx", null);
 266                         var rd = r.GetRouteData (new HttpContextStub ("~/FooTable/", String.Empty));
 267                         Assert.IsNull (rd, "#1");
 268                 }
 269
 270                 [Test]
 271                 public void GetRouteData8 ()
 272                 {
 273                         var r = new Route ("{first}/{*rest}", null);
 274                         var hc = new HttpContextStub ("~/a/b/c/d", String.Empty);
 275                         var rd = r.GetRouteData (hc);
 276                         Assert.IsNotNull (rd, "#1");
 277                         Assert.AreEqual (r, rd.Route, "#2");
 278                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 279                         Assert.AreEqual (2, rd.Values.Count, "#4");
 280                         Assert.AreEqual ("a", rd.Values ["first"], "#4-1");
 281                         Assert.AreEqual ("b/c/d", rd.Values ["rest"], "#4-2");
 282                 }
 283
 284                 [Test]
 285                 public void GetRouteData9 ()
 286                 {
 287                         var r = new Route ("summary/{action}-{type}/{page}", null);
 288                         var hc = new HttpContextStub ("~/summary/test-xml/1", String.Empty);
 289                         var rd = r.GetRouteData (hc);
 290
 291                         Assert.IsNotNull (rd, "#1");
 292                         Assert.AreEqual (r, rd.Route, "#2");
 293                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 294                         Assert.AreEqual (3, rd.Values.Count, "#4");
 295                         Assert.AreEqual ("test", rd.Values["action"], "#4-1");
 296                         Assert.AreEqual ("xml", rd.Values["type"], "#4-2");
 297                         Assert.AreEqual ("1", rd.Values["page"], "#4-2");
 298                 }
 299
 300                 [Test]
 301                 public void GetRouteData10 ()
 302                 {
 303                         var r = new Route ("summary/{action}-{type}/{page}", null);
 304                         var hc = new HttpContextStub ("~/summary/-xml/1", String.Empty);
 305                         var rd = r.GetRouteData (hc);
 306
 307                         Assert.IsNull (rd, "#1"); // mismatch, missing action
 308                 }
 309
 310                 [Test]
 311                 public void GetRouteData11 ()
 312                 {
 313                         var r = new Route ("summary/{action}-{type}/{page}", null);
 314                         var hc = new HttpContextStub ("~/summary/test-/1", String.Empty);
 315                         var rd = r.GetRouteData (hc);
 316
 317                         Assert.IsNull (rd, "#1"); // mismatch, missing type
 318                 }
 319
 320                 [Test]
 321                 public void GetRouteData12 ()
 322                 {
 323                         var r = new Route ("summary/{action}-{type}/{page}", null);
 324                         var hc = new HttpContextStub ("~/summary/test-xml", String.Empty);
 325                         var rd = r.GetRouteData (hc);
 326
 327                         Assert.IsNull (rd, "#1"); // mismatch, missing page
 328                 }
 329
 330                 [Test]
 331                 public void GetRouteData13 ()
 332                 {
 333                         var r = new Route ("summary/{action}-{type}/{page}", null) {
 334                                         Defaults = new RouteValueDictionary (new { action = "Index", page = 1 } )
 335                                                 };
 336                         var hc = new HttpContextStub ("~/summary/test-xml/1", String.Empty);
 337                         var rd = r.GetRouteData (hc);
 338
 339                         Assert.IsNotNull (rd, "#1");
 340                         Assert.AreEqual (r, rd.Route, "#2");
 341                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 342                         Assert.AreEqual (3, rd.Values.Count, "#4");
 343                         Assert.AreEqual ("test", rd.Values["action"], "#4-1");
 344                         Assert.AreEqual ("xml", rd.Values["type"], "#4-2");
 345                         Assert.AreEqual ("1", rd.Values["page"], "#4-3");
 346                 }
 347
 348                 [Test]
 349                 public void GetRouteData14 ()
 350                 {
 351                         var r = new Route ("{filename}.{ext}", null);
 352                         var hc = new HttpContextStub ("~/Foo.xml.aspx", String.Empty);
 353                         var rd = r.GetRouteData (hc);
 354
 355                         Assert.IsNotNull (rd, "#1");
 356                         Assert.AreEqual (r, rd.Route, "#2");
 357                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 358                         Assert.AreEqual (2, rd.Values.Count, "#4");
 359                         Assert.AreEqual ("Foo.xml", rd.Values["filename"], "#4-1");
 360                         Assert.AreEqual ("aspx", rd.Values["ext"], "#4-2");
 361                 }
 362
 363                 [Test]
 364                 public void GetRouteData15 ()
 365                 {
 366                         var r = new Route ("My{location}-{sublocation}", null);
 367                         var hc = new HttpContextStub ("~/MyHouse-LivingRoom", String.Empty);
 368                         var rd = r.GetRouteData (hc);
 369
 370                         Assert.IsNotNull (rd, "#1");
 371                         Assert.AreEqual (r, rd.Route, "#2");
 372                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 373                         Assert.AreEqual (2, rd.Values.Count, "#4");
 374                         Assert.AreEqual ("House", rd.Values["location"], "#4-1");
 375                         Assert.AreEqual ("LivingRoom", rd.Values["sublocation"], "#4-2");
 376                 }
 377
 378                 [Test]
 379                 public void GetRouteData16 ()
 380                 {
 381                         var r = new Route ("My{location}---{sublocation}", null);
 382                         var hc = new HttpContextStub ("~/MyHouse-LivingRoom", String.Empty);
 383                         var rd = r.GetRouteData (hc);
 384
 385                         Assert.IsNull (rd, "#1");
 386                 }
 387
 388                 [Test]
 389                 public void GetRouteData17 ()
 390                 {
 391                         var r = new Route ("{foo}xyz{bar}", null);
 392                         var hc = new HttpContextStub ("~/xyzxyzxyzblah", String.Empty);
 393                         var rd = r.GetRouteData (hc);
 394
 395                         Assert.IsNotNull (rd, "#1");
 396                         Assert.AreEqual (r, rd.Route, "#2");
 397                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 398                         Assert.AreEqual (2, rd.Values.Count, "#4");
 399                         Assert.AreEqual ("xyzxyz", rd.Values["foo"], "#4-1");
 400                         Assert.AreEqual ("blah", rd.Values["bar"], "#4-2");
 401                 }
 402
 403                 [Test]
 404                 public void GetRouteData18 ()
 405                 {
 406                         var r = new Route ("foo/{ }", null);
 407                         var hc = new HttpContextStub ("~/foo/stuff", String.Empty);
 408                         var rd = r.GetRouteData (hc);
 409
 410                         Assert.IsNotNull (rd, "#1");
 411                         Assert.AreEqual (r, rd.Route, "#2");
 412                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 413                         Assert.AreEqual (1, rd.Values.Count, "#4");
 414                         Assert.AreEqual ("stuff", rd.Values[" "], "#4-1");
 415                 }
 416
 417                 [Test]
 418                 public void GetRouteData19 ()
 419                 {
 420                         var r = new Route ("foo/{ \t}", null);
 421                         var hc = new HttpContextStub ("~/foo/stuff", String.Empty);
 422                         var rd = r.GetRouteData (hc);
 423
 424                         Assert.IsNotNull (rd, "#1");
 425                         Assert.AreEqual (r, rd.Route, "#2");
 426                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 427                         Assert.AreEqual (1, rd.Values.Count, "#4");
 428                         Assert.AreEqual ("stuff", rd.Values[" \t"], "#4-1");
 429                 }
 430
 431                 [Test]
 432                 public void GetRouteData20 ()
 433                 {
 434                         var r = new Route ("foo/{ \n}", null);
 435                         var hc = new HttpContextStub ("~/foo/stuff", String.Empty);
 436                         var rd = r.GetRouteData (hc);
 437
 438                         Assert.IsNotNull (rd, "#1");
 439                         Assert.AreEqual (r, rd.Route, "#2");
 440                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 441                         Assert.AreEqual (1, rd.Values.Count, "#4");
 442                         Assert.AreEqual ("stuff", rd.Values[" \n"], "#4-1");
 443                 }
 444
 445                 [Test]
 446                 public void GetRouteData21 ()
 447                 {
 448                         var r = new Route ("foo/{ \t\n}", null);
 449                         var hc = new HttpContextStub ("~/foo/stuff", String.Empty);
 450                         var rd = r.GetRouteData (hc);
 451
 452                         Assert.IsNotNull (rd, "#1");
 453                         Assert.AreEqual (r, rd.Route, "#2");
 454                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 455                         Assert.AreEqual (1, rd.Values.Count, "#4");
 456                         Assert.AreEqual ("stuff", rd.Values[" \t\n"], "#4-1");
 457                 }
 458
 459                 [Test]
 460                 public void GetRouteData22 ()
 461                 {
 462                         var r = new Route ("foo/{ \t\n}", null);
 463                         var hc = new HttpContextStub ("~/FOO/stuff", String.Empty);
 464                         var rd = r.GetRouteData (hc);
 465
 466                         Assert.IsNotNull (rd, "#1");
 467                         Assert.AreEqual (r, rd.Route, "#2");
 468                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 469                         Assert.AreEqual (1, rd.Values.Count, "#4");
 470                         Assert.AreEqual ("stuff", rd.Values[" \t\n"], "#4-1");
 471                 }
 472
 473                 [Test]
 474                 public void GetRouteData23 ()
 475                 {
 476                         var r = new Route ("foo/{bar}-{baz}/{dancefloor}", null) {
 477                                         Defaults = new RouteValueDictionary (new { bar = "BlueOyster", dancefloor = 1 })
 478                         };
 479
 480                         var hc = new HttpContextStub ("~/foo/-nyc/1", String.Empty);
 481                         var rd = r.GetRouteData (hc);
 482                         Assert.IsNull (rd, "#1");
 483
 484                         hc = new HttpContextStub ("~/foo/blueoyster-nyc", String.Empty);
 485                         rd = r.GetRouteData (hc);
 486                         Assert.IsNotNull (rd, "#2");
 487                         Assert.AreEqual (r, rd.Route, "#2-1");
 488                         Assert.AreEqual (0, rd.DataTokens.Count, "#2-2");
 489                         Assert.AreEqual (3, rd.Values.Count, "#2-3");
 490                         Assert.AreEqual ("blueoyster", rd.Values["bar"], "#2-4");
 491                         Assert.AreEqual ("nyc", rd.Values["baz"], "#2-5");
 492                         Assert.AreEqual (1, rd.Values["dancefloor"], "#2-6");
 493                         Assert.IsTrue (typeof (int) == rd.Values["dancefloor"].GetType (), "#2-7");
 494                 }
 495
 496                 [Test]
 497                 public void GetRouteData24 ()
 498                 {
 499                         var r = new Route ("foo/{bar}-{baz}/{dancefloor}", null) {
 500                                         Defaults = new RouteValueDictionary (new { baz = "nyc", dancefloor = 1 })
 501                         };
 502
 503                         var hc = new HttpContextStub ("~/foo/BlueOyster-/1", String.Empty);
 504                         var rd = r.GetRouteData (hc);
 505                         Assert.IsNull (rd, "#1");
 506
 507                         hc = new HttpContextStub ("~/foo/blueoyster-", String.Empty);
 508                         rd = r.GetRouteData (hc);
 509                         Assert.IsNull (rd, "#2");
 510
 511                         hc = new HttpContextStub ("~/foo/blueoyster-nyc", String.Empty);
 512                         rd = r.GetRouteData (hc);
 513
 514                         Assert.IsNotNull (rd, "#3");
 515                         Assert.AreEqual (r, rd.Route, "#3-1");
 516                         Assert.AreEqual (0, rd.DataTokens.Count, "#3-2");
 517                         Assert.AreEqual (3, rd.Values.Count, "#3-3");
 518                         Assert.AreEqual ("blueoyster", rd.Values["bar"], "#3-4");
 519                         Assert.AreEqual ("nyc", rd.Values["baz"], "#3-5");
 520                         Assert.AreEqual (1, rd.Values["dancefloor"], "#3-6");
 521                         Assert.IsTrue (typeof (int) == rd.Values["dancefloor"].GetType (), "#3-7");
 522
 523                         hc = new HttpContextStub ("~/foo/blueoyster-nyc/4", String.Empty);
 524                         rd = r.GetRouteData (hc);
 525
 526                         Assert.IsNotNull (rd, "#4");
 527                         Assert.AreEqual (r, rd.Route, "#4-1");
 528                         Assert.AreEqual (0, rd.DataTokens.Count, "#4-2");
 529                         Assert.AreEqual (3, rd.Values.Count, "#4-3");
 530                         Assert.AreEqual ("blueoyster", rd.Values["bar"], "#4-4");
 531                         Assert.AreEqual ("nyc", rd.Values["baz"], "#4-5");
 532                         Assert.AreEqual ("4", rd.Values["dancefloor"], "#4-6");
 533                         Assert.IsTrue (typeof (string) == rd.Values["dancefloor"].GetType (), "#4-7");
 534                 }
 535
 536                 [Test]
 537                 public void GetRouteData25 ()
 538                 {
 539                         var r = new Route ("foo/{bar}/{baz}/{dancefloor}", null) {
 540                                         Defaults = new RouteValueDictionary (new { baz = "nyc", dancefloor = 1 })
 541                         };
 542
 543                         var hc = new HttpContextStub ("~/foo/BlueOyster", String.Empty);
 544                         var rd = r.GetRouteData (hc);
 545                         Assert.IsNotNull (rd, "#1");
 546                         Assert.AreEqual (r, rd.Route, "#1-1");
 547                         Assert.AreEqual (0, rd.DataTokens.Count, "#1-2");
 548                         Assert.AreEqual (3, rd.Values.Count, "#1-3");
 549                         Assert.AreEqual ("BlueOyster", rd.Values["bar"], "#1-4");
 550                         Assert.AreEqual ("nyc", rd.Values["baz"], "#1-5");
 551                         Assert.AreEqual (1, rd.Values["dancefloor"], "#1-6");
 552                         Assert.IsTrue (typeof (int) == rd.Values["dancefloor"].GetType (), "#1-7");
 553
 554                         hc = new HttpContextStub ("~/foo/blueoyster/bigapple", String.Empty);
 555                         rd = r.GetRouteData (hc);
 556                         Assert.IsNotNull (rd, "#2");
 557                         Assert.AreEqual (r, rd.Route, "#2-1");
 558                         Assert.AreEqual (0, rd.DataTokens.Count, "#2-2");
 559                         Assert.AreEqual (3, rd.Values.Count, "#2-3");
 560                         Assert.AreEqual ("blueoyster", rd.Values["bar"], "#2-4");
 561                         Assert.AreEqual ("bigapple", rd.Values["baz"], "#2-5");
 562                         Assert.AreEqual (1, rd.Values["dancefloor"], "#2-6");
 563                         Assert.IsTrue (typeof (int) == rd.Values["dancefloor"].GetType (), "#2-7");
 564
 565                         hc = new HttpContextStub ("~/foo/blueoyster/bigapple/3", String.Empty);
 566                         rd = r.GetRouteData (hc);
 567
 568                         Assert.IsNotNull (rd, "#3");
 569                         Assert.AreEqual (r, rd.Route, "#3-1");
 570                         Assert.AreEqual (0, rd.DataTokens.Count, "#3-2");
 571                         Assert.AreEqual (3, rd.Values.Count, "#3-3");
 572                         Assert.AreEqual ("blueoyster", rd.Values["bar"], "#3-4");
 573                         Assert.AreEqual ("bigapple", rd.Values["baz"], "#3-5");
 574                         Assert.AreEqual ("3", rd.Values["dancefloor"], "#3-6");
 575                         Assert.IsTrue (typeof (string) == rd.Values["dancefloor"].GetType (), "#3-7");
 576                 }
 577
 578                 [Test]
 579                 public void GetRouteData26 ()
 580                 {
 581                         var r = new Route ("foo/{bar}/{baz}-{dancefloor}", null) {
 582                                         Defaults = new RouteValueDictionary (new { baz = "nyc", dancefloor = 1 })
 583                         };
 584
 585                         var hc = new HttpContextStub ("~/foo/BlueOyster", String.Empty);
 586                         var rd = r.GetRouteData (hc);
 587                         Assert.IsNull (rd, "#1");
 588
 589                         hc = new HttpContextStub ("~/foo/blueoyster/bigapple", String.Empty);
 590                         rd = r.GetRouteData (hc);
 591                         Assert.IsNull (rd, "#2");
 592
 593                         hc = new HttpContextStub ("~/foo/blueoyster/bigapple-3", String.Empty);
 594                         rd = r.GetRouteData (hc);
 595
 596                         Assert.IsNotNull (rd, "#3");
 597                         Assert.AreEqual (r, rd.Route, "#3-1");
 598                         Assert.AreEqual (0, rd.DataTokens.Count, "#3-2");
 599                         Assert.AreEqual (3, rd.Values.Count, "#3-3");
 600                         Assert.AreEqual ("blueoyster", rd.Values["bar"], "#3-4");
 601                         Assert.AreEqual ("bigapple", rd.Values["baz"], "#3-5");
 602                         Assert.AreEqual ("3", rd.Values["dancefloor"], "#3-6");
 603                         Assert.IsTrue (typeof (string) == rd.Values["dancefloor"].GetType (), "#3-7");
 604
 605                         hc = new HttpContextStub ("~/foo/blueoyster/-", String.Empty);
 606                         rd = r.GetRouteData (hc);
 607
 608                         Assert.IsNull (rd, "#4");
 609                 }
 610
 611                 [Test]
 612                 public void GetRouteData27 ()
 613                 {
 614                         var r = new Route ("foo/{bar}/{baz}/{dancefloor}", null) {
 615                                         Defaults = new RouteValueDictionary (new { bar = "BlueOyster", dancefloor = 1 })
 616                         };
 617
 618                         var hc = new HttpContextStub ("~/foo/nyc", String.Empty);
 619                         var rd = r.GetRouteData (hc);
 620                         Assert.IsNull (rd, "#1");
 621                 }
 622
 623                 [Test]
 624                 public void GetRouteData28 ()
 625                 {
 626                         var r = new Route ("{foo}xyz{bar}xyz{baz}", null);
 627                         var hc = new HttpContextStub ("~/xyzxyzxyzxyzblah", String.Empty);
 628                         var rd = r.GetRouteData (hc);
 629
 630 #if NET_4_0 || !DOTNET
 631                         // When running on Mono this test succeeds - it was a bug in .NET routing for 3.5 which
 632                         // we don't reproduce anymore.
 633                         Assert.IsNotNull (rd, "#1");
 634                         Assert.AreEqual (r, rd.Route, "#2");
 635                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 636                         Assert.AreEqual (3, rd.Values.Count, "#4");
 637                         Assert.AreEqual ("xyz", rd.Values ["foo"], "#4-1");
 638                         Assert.AreEqual ("xyz", rd.Values ["bar"], "#4-2");
 639                         Assert.AreEqual ("blah", rd.Values ["baz"], "#4-3");
 640 #else
 641                         Assert.IsNull (rd, "#1");
 642 #endif
 643                 }
 644
 645                 [Test]
 646                 public void GetRouteData29 ()
 647                 {
 648                         var r = new Route ("{foo}xyz{bar}", null);
 649                         var hc = new HttpContextStub ("~/xyzxyzxyzxyzblah", String.Empty);
 650                         var rd = r.GetRouteData (hc);
 651
 652                         Assert.IsNotNull (rd, "#1");
 653                         Assert.AreEqual (r, rd.Route, "#2");
 654                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 655                         Assert.AreEqual (2, rd.Values.Count, "#4");
 656                         Assert.AreEqual ("xyzxyzxyz", rd.Values["foo"], "#4-1");
 657                         Assert.AreEqual ("blah", rd.Values["bar"], "#4-2");
 658                 }
 659
 660                 [Test]
 661                 public void GetRouteData30 ()
 662                 {
 663                         var r = new Route ("{foo}/bar/{baz}/boo/{blah}", null) {
 664                                         Defaults = new RouteValueDictionary (new { baz = "meep", blah = "blurb" })
 665                         };
 666
 667                         var hc = new HttpContextStub ("~/foo/bar", String.Empty);
 668                         var rd = r.GetRouteData (hc);
 669
 670                         Assert.IsNull (rd, "#1");
 671
 672                         hc = new HttpContextStub ("~/foo/bar/baz/boo", String.Empty);
 673                         rd = r.GetRouteData (hc);
 674
 675                         Assert.IsNotNull (rd, "#2");
 676                         Assert.AreEqual (r, rd.Route, "#3");
 677                         Assert.AreEqual (0, rd.DataTokens.Count, "#4");
 678                         Assert.AreEqual (3, rd.Values.Count, "#4");
 679                         Assert.AreEqual ("foo", rd.Values["foo"], "#4-1");
 680                         Assert.AreEqual ("baz", rd.Values["baz"], "#4-2");
 681                         Assert.AreEqual ("blurb", rd.Values["blah"], "#4-3");
 682                 }
 683
 684                 [Test(Description = "Bug #523330")]
 685                 public void GetRouteData31()
 686                 {
 687                         var r = new Route("{controller}/{action}", null)
 688                         {
 689                                 Defaults = new RouteValueDictionary(new { controller = "Home", action = "Index" }),
 690                                 DataTokens = new RouteValueDictionary(new { foobar = "bar" })
 691                         };
 692
 693                         var hc = new HttpContextStub("~/", String.Empty);
 694                         var rd = r.GetRouteData(hc);
 695
 696                         Assert.IsNotNull(rd, "#1");
 697                         Assert.AreEqual(r, rd.Route, "#2");
 698                         Assert.AreEqual(1, rd.DataTokens.Count, "#3");
 699                         Assert.AreEqual(2, rd.Values.Count, "#4");
 700                         Assert.AreEqual("Home", rd.Values["controller"], "#4-1");
 701                         Assert.AreEqual("Index", rd.Values["action"], "#4-2");
 702                         Assert.IsNull(rd.Values["foobar"], "#4-3");
 703                         Assert.IsNotNull(rd.DataTokens, "#5");
 704                         Assert.AreEqual(1, rd.DataTokens.Count, "#6");
 705                         Assert.AreEqual("bar", rd.DataTokens["foobar"], "#6-1");
 706                 }
 707
 708                 [Test (Description = "Bug #537751")]
 709                 public void GetRouteData32 ()
 710                 {
 711                         var r = new Route ("", null);
 712                         var hc = new HttpContextStub ("~/", String.Empty);
 713                         var rd = r.GetRouteData (hc);
 714
 715                         Assert.IsNotNull (rd, "#1");
 716                         Assert.AreEqual (r, rd.Route, "#2");
 717                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 718                         Assert.AreEqual (0, rd.Values.Count, "#4");
 719                 }
 720
 721                 [Test (Description = "Bug #537751")]
 722                 public void GetRouteData33 ()
 723                 {
 724                         var r = new Route (null, null);
 725                         var hc = new HttpContextStub ("~/", String.Empty);
 726                         var rd = r.GetRouteData (hc);
 727
 728                         Assert.IsNotNull (rd, "#1");
 729                         Assert.AreEqual (r, rd.Route, "#2");
 730                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 731                         Assert.AreEqual (0, rd.Values.Count, "#4");
 732                 }
 733
 734                 [Test]
 735                 public void GetRouteData34 ()
 736                 {
 737                         var r = new Route ("{foo}xyz{bar}xyz{baz}", null);
 738                         var hc = new HttpContextStub ("~/xyzxyzxyzxyzxyzxyzblah", String.Empty);
 739                         var rd = r.GetRouteData (hc);
 740
 741 #if NET_4_0 || !DOTNET
 742                         // When running on Mono this test succeeds - it was a bug in .NET routing for 3.5 which
 743                         // we don't reproduce anymore.
 744                         Assert.IsNotNull (rd, "#1");
 745                         Assert.AreEqual (r, rd.Route, "#2");
 746                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 747                         Assert.AreEqual (3, rd.Values.Count, "#4");
 748                         Assert.AreEqual ("xyzxyzxyz", rd.Values ["foo"], "#4-1");
 749                         Assert.AreEqual ("xyz", rd.Values ["bar"], "#4-2");
 750                         Assert.AreEqual ("blah", rd.Values ["baz"], "#4-3");
 751 #else
 752                         Assert.IsNull (rd, "#1");
 753 #endif
 754                 }
 755
 756                 [Test]
 757                 public void GetRouteData35 ()
 758                 {
 759                         var r = new Route ("{foo}xyz{bar}xyz{baz}", null);
 760                         var hc = new HttpContextStub ("~/xyzxyzxyzdabxyzblah", String.Empty);
 761                         var rd = r.GetRouteData (hc);
 762
 763                         Assert.IsNotNull (rd, "#1");
 764                         Assert.AreEqual (r, rd.Route, "#2");
 765                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 766                         Assert.AreEqual (3, rd.Values.Count, "#4");
 767                         Assert.AreEqual ("xyzxyz", rd.Values ["foo"], "#4-1");
 768                         Assert.AreEqual ("dab", rd.Values ["bar"], "#4-2");
 769                         Assert.AreEqual ("blah", rd.Values ["baz"], "#4-3");
 770                 }
 771
 772                 [Test]
 773                 public void GetRouteData36 ()
 774                 {
 775                         var r = new Route ("xyz{foo}xyz{bar}xyz{baz}", null);
 776                         var hc = new HttpContextStub ("~/xyzxyzxyzdabxyzblah", String.Empty);
 777                         var rd = r.GetRouteData (hc);
 778
 779 #if NET_4_0 || !DOTNET
 780                         // When running on Mono this test succeeds - it was a bug in .NET routing for 3.5 which
 781                         // we don't reproduce anymore.
 782                         Assert.IsNotNull (rd, "#1");
 783                         Assert.AreEqual (r, rd.Route, "#2");
 784                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 785                         Assert.AreEqual (3, rd.Values.Count, "#4");
 786                         Assert.AreEqual ("xyz", rd.Values ["foo"], "#4-1");
 787                         Assert.AreEqual ("dab", rd.Values ["bar"], "#4-2");
 788                         Assert.AreEqual ("blah", rd.Values ["baz"], "#4-3");
 789 #else
 790                         Assert.IsNull (rd, "#1");
 791 #endif
 792                 }
 793
 794                 [Test]
 795                 public void GetRouteData37 ()
 796                 {
 797                         var r = new Route ("{foo}xyz{bar}xyz{baz}", null);
 798                         var hc = new HttpContextStub ("~/xyzxyzxyzxyzxyz", String.Empty);
 799                         var rd = r.GetRouteData (hc);
 800
 801 #if NET_4_0 || !DOTNET
 802                         // When running on Mono this test succeeds - it was a bug in .NET routing for 3.5 which
 803                         // we don't reproduce anymore.
 804                         Assert.IsNotNull (rd, "#1");
 805                         Assert.AreEqual (r, rd.Route, "#2");
 806                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 807                         Assert.AreEqual (3, rd.Values.Count, "#4");
 808                         Assert.AreEqual ("xyz", rd.Values ["foo"], "#4-1");
 809                         Assert.AreEqual ("xyz", rd.Values ["bar"], "#4-2");
 810                         Assert.AreEqual ("xyz", rd.Values ["baz"], "#4-3");
 811 #else
 812                         Assert.IsNull (rd, "#1");
 813 #endif
 814                 }
 815
 816                 [Test]
 817                 public void GetRouteData38 ()
 818                 {
 819                         // {} matches and substitutes even at partial state ...
 820                         var r = new Route ("{foo}/bar{baz}", null);
 821                         var hc = new HttpContextStub ("~/x/bartest", String.Empty);
 822                         var rd = r.GetRouteData (hc);
 823                         Assert.IsNotNull (rd, "#1");
 824                         Assert.AreEqual (r, rd.Route, "#2");
 825                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 826                         Assert.AreEqual (2, rd.Values.Count, "#4");
 827                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 828                         Assert.AreEqual ("test", rd.Values ["baz"], "#4-2");
 829                 }
 830
 831                 [Test]
 832                 public void GetRouteData39 ()
 833                 {
 834                         // {} matches and substitutes even at partial state ...
 835                         var r = new Route ("{foo}/bar{baz}", null);
 836                         var hc = new HttpContextStub ("~/x/barte", String.Empty);
 837                         var rd = r.GetRouteData (hc);
 838                         Assert.IsNotNull (rd, "#1");
 839                         Assert.AreEqual (r, rd.Route, "#2");
 840                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 841                         Assert.AreEqual (2, rd.Values.Count, "#4");
 842                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 843                         Assert.AreEqual ("te", rd.Values ["baz"], "#4-2");
 844                 }
 845
 846                 [Test]
 847                 public void GetRouteData40 ()
 848                 {
 849                         // {} matches and substitutes even at partial state ...
 850                         var r = new Route ("{foo}/bar{baz}", null);
 851                         var hc = new HttpContextStub ("~/x/bartes", String.Empty);
 852                         var rd = r.GetRouteData (hc);
 853                         Assert.IsNotNull (rd, "#1");
 854                         Assert.AreEqual (r, rd.Route, "#2");
 855                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 856                         Assert.AreEqual (2, rd.Values.Count, "#4");
 857                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 858                         Assert.AreEqual ("tes", rd.Values ["baz"], "#4-2");
 859                 }
 860
 861                 [Test]
 862                 public void GetRouteData41 ()
 863                 {
 864                         // {} matches and substitutes even at partial state ...
 865                         var r = new Route ("{foo}/bartes{baz}", null);
 866                         var hc = new HttpContextStub ("~/x/bartest", String.Empty);
 867                         var rd = r.GetRouteData (hc);
 868                         Assert.IsNotNull (rd, "#1");
 869                         Assert.AreEqual (r, rd.Route, "#2");
 870                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 871                         Assert.AreEqual (2, rd.Values.Count, "#4");
 872                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 873                         Assert.AreEqual ("t", rd.Values ["baz"], "#4-2");
 874                 }
 875
 876                 [Test]
 877                 public void GetRouteData42 ()
 878                 {
 879                         // {} matches and substitutes even at partial state ...
 880                         var r = new Route ("{foo}/bartes{baz}", null);
 881                         var hc = new HttpContextStub ("~/x/bartest1", String.Empty);
 882                         var rd = r.GetRouteData (hc);
 883                         Assert.IsNotNull (rd, "#1");
 884                         Assert.AreEqual (r, rd.Route, "#2");
 885                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 886                         Assert.AreEqual (2, rd.Values.Count, "#4");
 887                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 888                         Assert.AreEqual ("t1", rd.Values ["baz"], "#4-2");
 889                 }
 890
 891                 [Test]
 892                 public void GetRouteData43 ()
 893                 {
 894                         // {} matches and substitutes even at partial state ...
 895                         var r = new Route ("{foo}-{bar}-{baz}", null);
 896                         var hc = new HttpContextStub ("~/--", String.Empty);
 897                         var rd = r.GetRouteData (hc);
 898                         Assert.IsNull (rd, "#1");
 899
 900                         hc = new HttpContextStub ("~/1-2-3", String.Empty);
 901                         rd = r.GetRouteData (hc);
 902                         Assert.IsNotNull (rd, "#2");
 903                         Assert.AreEqual (r, rd.Route, "#2");
 904                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 905                         Assert.AreEqual (3, rd.Values.Count, "#4");
 906                         Assert.AreEqual ("1", rd.Values ["foo"], "#4-1");
 907                         Assert.AreEqual ("2", rd.Values ["bar"], "#4-2");
 908                         Assert.AreEqual ("3", rd.Values ["baz"], "#4-2");
 909                 }
 910
 911                 [Test]
 912                 public void GetRouteData44 ()
 913                 {
 914                         // {} matches and substitutes even at partial state ...
 915                         var r = new Route ("{foo}/bartes{baz}", null);
 916                         var hc = new HttpContextStub ("~/x/bartest/", String.Empty);
 917                         var rd = r.GetRouteData (hc);
 918                         Assert.IsNotNull (rd, "#1");
 919                         Assert.AreEqual (r, rd.Route, "#2");
 920                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 921                         Assert.AreEqual (2, rd.Values.Count, "#4");
 922                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 923                         Assert.AreEqual ("t", rd.Values ["baz"], "#4-2");
 924                 }
 925
 926                 [Test]
 927                 public void GetRouteData45 ()
 928                 {
 929                         var r = new Route ("{foo}/{bar}", null);
 930                         var hc = new HttpContextStub ("~/x/y/", String.Empty);
 931                         var rd = r.GetRouteData (hc);
 932                         Assert.IsNotNull (rd, "#1");
 933                         Assert.AreEqual (r, rd.Route, "#2");
 934                         Assert.AreEqual (0, rd.DataTokens.Count, "#3");
 935                         Assert.AreEqual (2, rd.Values.Count, "#4");
 936                         Assert.AreEqual ("x", rd.Values ["foo"], "#4-1");
 937                         Assert.AreEqual ("y", rd.Values ["bar"], "#4-2");
 938                 }
 939
 940                 [Test (Description="Bug #651593")]
 941                 public void GetRouteData46 ()
 942                 {
 943                         var r = new Route ("Foo", null) {
 944                                 Defaults = new RouteValueDictionary (new {
 945                                         controller = "Foo",
 946                                         action = "Index"
 947                                 })
 948                         };
 949                         var hc = new HttpContextStub ("/Foo/123", String.Empty);
 950                         var rd = r.GetRouteData (hc);
 951                         Assert.IsNull (rd, "#1");
 952
 953                         r = new Route ("Foo", null) {
 954                                 Defaults = new RouteValueDictionary (new {
 955                                         controller = "Foo",
 956                                         action = "Index"
 957                                 })
 958                         };
 959                         hc = new HttpContextStub ("~/Foo/123", String.Empty);
 960                         rd = r.GetRouteData (hc);
 961                         Assert.IsNull (rd, "#2");
 962                 }
 963
 964                 [Test (Description="Bug #651966")]
 965                 public void GetRouteData47 ()
 966                 {
 967                         var r = new Route ("Foo/{id}", new StopRoutingHandler ()) {
 968                                 Defaults = new RouteValueDictionary (new {
 969                                         controller = "Foo",
 970                                         action = "Retrieve"
 971                                 }),
 972                                 Constraints = new RouteValueDictionary (new {
 973                                         id = @"\d{1,10}"
 974                                 })
 975                         };
 976
 977                         var hc = new HttpContextStub ("~/Foo/x123", String.Empty);
 978                         var rd = r.GetRouteData (hc);
 979
 980                         Assert.IsNull (rd, "#1");
 981                 }
 982
 983                 [Test]
 984                 public void GetRouteDataWithCatchAll ()
 985                 {
 986                         var r = new Route ("{*path}", new StopRoutingHandler ()) {
 987                                 Defaults = new RouteValueDictionary (new {
 988                                         controller = "Error",
 989                                         action = "NotFound"
 990                                 })
 991                         };
 992
 993                         var hc = new HttpContextStub ("~/", String.Empty);
 994                         var rd = r.GetRouteData (hc);
 995
 996                         Assert.IsNotNull (rd, "#1");
 997
 998                         hc = new HttpContextStub ("~/Foo/x123", String.Empty);
 999                         rd = r.GetRouteData (hc);
1000
1001                         Assert.IsNotNull (rd, "#2");
1002                 }
1003
1004                 [Test]
1005                 public void GetRouteDataWithCatchAll2 ()
1006                 {
1007                         var r = new Route ("something/{*path}", new StopRoutingHandler ()) {
1008                                 Defaults = new RouteValueDictionary (new {
1009                                         controller = "Error",
1010                                         action = "NotFound"
1011                                 })
1012                         };
1013
1014                         var hc = new HttpContextStub ("~/", String.Empty);
1015                         var rd = r.GetRouteData (hc);
1016
1017                         Assert.IsNull (rd, "#1");
1018
1019                         hc = new HttpContextStub ("~/something", String.Empty);
1020                         rd = r.GetRouteData (hc);
1021
1022                         Assert.IsNotNull (rd, "#2");
1023                         Assert.IsNull (rd.Values["path"], "#2.1");
1024
1025                         hc = new HttpContextStub ("~/something/", String.Empty);
1026                         rd = r.GetRouteData (hc);
1027
1028                         Assert.IsNotNull (rd, "#3");
1029                         Assert.IsNull (rd.Values["path"], "#3.1");
1030
1031                         hc = new HttpContextStub ("~/something/algo", String.Empty);
1032                         rd = r.GetRouteData (hc);
1033
1034                         Assert.IsNotNull (rd, "#4");
1035                         Assert.AreEqual ("algo", rd.Values["path"], "#4.1");
1036
1037                 }
1038
1039                 [Test]
1040                 [ExpectedException (typeof (ArgumentNullException))]
1041                 public void GetVirtualPathNullContext ()
1042                 {
1043                         try {
1044                                 var r = new Route (null, null);
1045                                 r.GetVirtualPath (null, new RouteValueDictionary ());
1046                         } catch (NullReferenceException) {
1047                                 // .NET lacks null arg check here. (No need to mimic silly behavior here.)
1048                                 throw new ArgumentNullException ();
1049                         }
1050                 }
1051
1052                 [Test]
1053                 public void GetVirtualPathNullValues ()
1054                 {
1055                         // null values is allowed.
1056                         var r = new Route (null, null);
1057                         var rd = new RouteData ();
1058                         var vp = r.GetVirtualPath (new RequestContext (new HttpContextStub (), rd), null);
1059                         Assert.AreEqual (String.Empty, vp.VirtualPath, "#1");
1060                         Assert.AreEqual (r, vp.Route, "#2");
1061                 }
1062
1063                 [Test]
1064                 public void GetVirtualPath ()
1065                 {
1066                         var r = new Route ("foo/bar", null);
1067                         var rd = new RouteData ();
1068                         var vp = r.GetVirtualPath (new RequestContext (new HttpContextStub ("~/foo/bar"), rd), null);
1069                         Assert.AreEqual ("foo/bar", vp.VirtualPath, "#1");
1070                         Assert.AreEqual (r, vp.Route, "#2");
1071
1072                         vp = r.GetVirtualPath (new RequestContext (new HttpContextStub ("~/foo/bar/baz"), rd), null);
1073                         Assert.AreEqual ("foo/bar", vp.VirtualPath, "#3");
1074                         Assert.AreEqual (r, vp.Route, "#4");
1075                 }
1076
1077                 [Test]
1078                 public void GetVirtualPath2 ()
1079                 {
1080                         var r = new Route ("{foo}/{bar}", null);
1081                         var hc = new HttpContextStub ("~/x/y", String.Empty);
1082                         var rd = r.GetRouteData (hc);
1083                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), null);
1084                         Assert.IsNotNull (vp, "#1");
1085                         Assert.AreEqual ("x/y", vp.VirtualPath, "#2");
1086                         Assert.AreEqual (r, vp.Route, "#3");
1087                         Assert.AreEqual (0, vp.DataTokens.Count, "#4");
1088                 }
1089
1090                 [Test]
1091                 public void GetVirtualPath3 ()
1092                 {
1093                         var r = new MyRoute ("{foo}/{bar}", new MyRouteHandler ());
1094                         var hc = new HttpContextStub2 ("~/x/y", String.Empty);
1095                         var rd = r.GetRouteData (hc);
1096                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
1097
1098                         Assert.IsNotNull (vp, "#1");
1099                         Assert.AreEqual ("x/y", vp.VirtualPath, "#2");
1100                         Assert.AreEqual (r, vp.Route, "#3");
1101                         Assert.AreEqual (0, vp.DataTokens.Count, "#4");
1102                 }
1103
1104                 [Test]
1105                 public void GetVirtualPath4 ()
1106                 {
1107                         var r = new MyRoute ("{foo}/{bar}", new MyRouteHandler ());
1108                         var hc = new HttpContextStub2 ("~/x/y", String.Empty);
1109                         var rd = r.GetRouteData (hc);
1110
1111                         // override a value incompletely
1112                         var values = new RouteValueDictionary ();
1113                         values ["foo"] = "A";
1114
1115                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1116                         Assert.IsNull (vp);
1117                 }
1118
1119                 [Test]
1120                 public void GetVirtualPath5 ()
1121                 {
1122                         var r = new MyRoute ("{foo}/{bar}", new MyRouteHandler ());
1123                         var hc = new HttpContextStub2 ("~/x/y", String.Empty);
1124                         var rd = r.GetRouteData (hc);
1125
1126                         // override values completely.
1127                         var values = new RouteValueDictionary ();
1128                         values ["foo"] = "A";
1129                         values ["bar"] = "B";
1130
1131                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1132
1133                         Assert.IsNotNull (vp, "#1");
1134                         Assert.AreEqual ("A/B", vp.VirtualPath, "#2");
1135                         Assert.AreEqual (r, vp.Route, "#3");
1136                         Assert.AreEqual (0, vp.DataTokens.Count, "#4");
1137                 }
1138
1139                 [Test]
1140                 public void GetVirtualPath6 ()
1141                 {
1142                         var r = new MyRoute ("summary/{action}-{type}/{page}", new MyRouteHandler ()) {
1143                                         Defaults = new RouteValueDictionary (new { action = "Index", page = 1 })
1144                                                 };
1145                         var hc = new HttpContextStub2 ("~/summary/Index-test/1", String.Empty);
1146                         var rd = r.GetRouteData (hc);
1147                         var values = new RouteValueDictionary (new { page = 2 });
1148
1149                         Assert.IsNotNull (rd, "#1");
1150                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1151
1152                         Assert.IsNotNull (vp, "#2");
1153                         Assert.AreEqual ("summary/Index-test/2", vp.VirtualPath, "#2-1");
1154                         Assert.AreEqual (r, vp.Route, "#2-2");
1155                         Assert.AreEqual (0, vp.DataTokens.Count, "#2-3");
1156
1157                         values = new RouteValueDictionary (new { page = 2, extra = "stuff" });
1158                         vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1159
1160                         Assert.IsNotNull (vp, "#3");
1161                         Assert.AreEqual ("summary/Index-test/2?extra=stuff", vp.VirtualPath, "#3-2");
1162                         Assert.AreEqual (0, vp.DataTokens.Count, "#3-3");
1163                 }
1164
1165                 [Test]
1166                 public void GetVirtualPath7 ()
1167                 {
1168                         var r = new MyRoute ("summary/{action}-{type}/{page}", new MyRouteHandler ()) {
1169                                         Defaults = new RouteValueDictionary (new { action = "Index", page = 1 })
1170                         };
1171                         var hc = new HttpContextStub2 ("~/summary/Index-test/1", String.Empty);
1172                         var rd = r.GetRouteData (hc);
1173                         var values = new RouteValueDictionary (new { page = 2 });
1174
1175                         Assert.IsNotNull (rd, "#1");
1176                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1177
1178                         Assert.IsNotNull (vp, "#2");
1179                         Assert.AreEqual ("summary/Index-test/2", vp.VirtualPath, "#2-1");
1180                         Assert.AreEqual (r, vp.Route, "#2-2");
1181                         Assert.AreEqual (0, vp.DataTokens.Count, "#2-3");
1182                 }
1183
1184                 [Test]
1185                 public void GetVirtualPath8 ()
1186                 {
1187                         var r = new MyRoute ("todo/{action}/{page}", new MyRouteHandler ()) {
1188                                         Defaults = new RouteValueDictionary (new { controller="todo", action="list", page=0 })
1189                         };
1190                         var hc = new HttpContextStub2 ("~/todo/list/2", String.Empty);
1191                         var rd = r.GetRouteData (hc);
1192
1193                         Assert.IsNotNull (rd, "#1");
1194
1195                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { page = 3 }));
1196                         Assert.IsNotNull (vp, "#2");
1197                         Assert.AreEqual ("todo/list/3", vp.VirtualPath, "#2-1");
1198                 }
1199
1200                 [Test]
1201                 public void GetVirtualPath9 ()
1202                 {
1203                         var r = new MyRoute ("todo/{action}/{page}", new MyRouteHandler ()) {
1204                                         Defaults = new RouteValueDictionary {
1205                                                         {"controller", "todo"},
1206                                                         {"action", null},
1207                                                         {"page", null}
1208                                                 }
1209                                 };
1210
1211                         var hc = new HttpContextStub2 ("~/todo/list/2", String.Empty);
1212                         var rd = r.GetRouteData (hc);
1213
1214                         Assert.IsNotNull (rd, "#1");
1215
1216                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { page = 3 }));
1217                         Assert.IsNotNull (vp, "#2");
1218                         Assert.AreEqual ("todo/list/3", vp.VirtualPath, "#2-1");
1219                 }
1220
1221                 [Test]
1222                 public void GetVirtualPath10 ()
1223                 {
1224                         var r = new MyRoute ("{foo}/{bar}", new MyRouteHandler ());
1225                         var hc = new HttpContextStub ("~/foo/bar", String.Empty);
1226                         var rd = r.GetRouteData (hc);
1227
1228                         Assert.IsNotNull (rd, "#1");
1229
1230                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { page = 3 }));
1231                         Assert.IsNotNull (vp, "#2");
1232                         Assert.AreEqual ("foo/bar?page=3", vp.VirtualPath, "#2-1");
1233
1234                         vp = r.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { page = 3, another = "stuff" }));
1235                         Assert.IsNotNull (vp, "#3");
1236                         Assert.AreEqual ("foo/bar?page=3&another=stuff", vp.VirtualPath, "#3-1");
1237
1238                         vp = r.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { page = 3, another = "stuff", value = "with ; spaces & other chars" }));
1239                         Assert.IsNotNull (vp, "#4");
1240                         Assert.AreEqual ("foo/bar?page=3&another=stuff&value=with%20%3B%20spaces%20%26%20other%20chars", vp.VirtualPath, "#4-1");
1241                 }
1242
1243                 [Test]
1244                 public void GetVirtualPath11 ()
1245                 {
1246                         var r = new MyRoute ("summary/{action}/{page}", new MyRouteHandler ()) {
1247                                         Defaults = new RouteValueDictionary (new { action = "Index", page = 1 })
1248                                                 };
1249                         var hc = new HttpContextStub2 ("~/summary/test/1", String.Empty);
1250                         var rd = r.GetRouteData (hc);
1251                         var values = new RouteValueDictionary (new { page = 2 });
1252
1253                         Assert.IsNotNull (rd, "#1");
1254                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1255
1256                         Assert.IsNotNull (vp, "#2");
1257                         Assert.AreEqual ("summary/test/2", vp.VirtualPath, "#2-1");
1258                         Assert.AreEqual (r, vp.Route, "#2-2");
1259                         Assert.AreEqual (0, vp.DataTokens.Count, "#2-3");
1260
1261                         values = new RouteValueDictionary (new { page = 2, extra = "stuff" });
1262                         vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1263
1264                         Assert.IsNotNull (vp, "#3");
1265                         Assert.AreEqual ("summary/test/2?extra=stuff", vp.VirtualPath, "#3-2");
1266                         Assert.AreEqual (0, vp.DataTokens.Count, "#3-3");
1267                 }
1268
1269                 [Test]
1270                 public void GetVirtualPath12 ()
1271                 {
1272                         var r = new MyRoute ("{foo}/{bar}", new MyRouteHandler ()) {
1273                                         Defaults = new RouteValueDictionary (new { bar = "baz" })
1274                                                 };
1275
1276                         var hc = new HttpContextStub2 ("~/x/y", String.Empty);
1277                         var rd = r.GetRouteData (hc);
1278                         var values = new RouteValueDictionary ();
1279
1280                         // Partial override is possible if defaults are specified
1281                         values ["foo"] = "A";
1282                         values ["baz"] = "B";
1283
1284                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1285                         Assert.IsNotNull (vp, "#1");
1286                         Assert.AreEqual ("A?baz=B", vp.VirtualPath, "#1-1");
1287                 }
1288
1289                 [Test]
1290                 public void GetVirtualPath13 ()
1291                 {
1292                         var r = new MyRoute ("{foo}/{bar}", new MyRouteHandler ()) {
1293                                         Defaults = new RouteValueDictionary (new { baz = "baz" })
1294                                                 };
1295                         var hc = new HttpContextStub2 ("~/x/y", String.Empty);
1296                         var rd = r.GetRouteData (hc);
1297
1298                         // override a value incompletely
1299                         var values = new RouteValueDictionary ();
1300                         values ["foo"] = "A";
1301
1302                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1303                         Assert.IsNull (vp);
1304                 }
1305
1306                 [Test]
1307                 public void GetVirtualPath14 ()
1308                 {
1309                         var r = new MyRoute ("{table}/{action}.aspx", new MyRouteHandler ());
1310                         var hc = new HttpContextStub2 ("~/x/y.aspx", String.Empty);
1311                         var rd = r.GetRouteData (hc);
1312
1313                         // override a value incompletely
1314                         var values = new RouteValueDictionary (new {
1315                                 emptyValue = String.Empty,
1316                                 nullValue = (string)null,
1317                                 nonEmptyValue = "SomeValue"
1318                         });
1319
1320                         var vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1321                         Assert.IsNotNull (vp, "#A1");
1322                         Assert.AreEqual ("x/y.aspx?nonEmptyValue=SomeValue", vp.VirtualPath, "#A1-1");
1323
1324                         values["nonEmptyValue"] = "Some Value + encoding &";
1325                         vp = r.GetVirtualPath (new RequestContext (hc, rd), values);
1326                         Assert.IsNotNull (vp, "#B1");
1327                         Assert.AreEqual ("x/y.aspx?nonEmptyValue=Some%20Value%20%2B%20encoding%20%26", vp.VirtualPath, "#B1-1");
1328
1329                 }
1330
1331 #if NET_4_0
1332                 [Test (Description="Bug #671753")]
1333                 public void GetVirtualPath15 ()
1334                 {
1335                         var context = new HttpContextWrapper (
1336                                 new HttpContext (new HttpRequest ("filename", "http://localhost/filename", String.Empty),
1337                                                  new HttpResponse (new StringWriter())
1338                                 )
1339                         );
1340                         var rc = new RequestContext (context, new RouteData ());
1341
1342                         Assert.IsNotNull (RouteTable.Routes, "#A1");
1343                         RouteTable.Routes.MapPageRoute ("TestRoute", "{language}/testroute", "~/TestRoute.aspx", true, null,
1344                                                         new RouteValueDictionary {{"language", "(ru|en)"}});
1345
1346                         Assert.IsNotNull(RouteTable.Routes.GetVirtualPath (rc, "TestRoute", new RouteValueDictionary {{"language", "en"}}), "#A2");
1347
1348                         rc.RouteData.Values["language"] = "ru";
1349                         Assert.IsNotNull (RouteTable.Routes.GetVirtualPath (rc, "TestRoute", new RouteValueDictionary ()), "#A3");
1350                         Assert.IsNotNull (RouteTable.Routes.GetVirtualPath (rc, "TestRoute", null), "#A4");
1351                 }
1352 #endif
1353
1354                 // Bug #500739
1355                 [Test]
1356                 public void RouteGetRequiredStringWithDefaults ()
1357                 {
1358                         var routes = new RouteValueDictionary ();
1359                         var route = new Route ("Hello/{name}", new MyRouteHandler ()) {
1360                                         Defaults = new RouteValueDictionary (new {controller = "Home", action = "Hello"})
1361                         };
1362
1363                         routes.Add ("Name", route);
1364
1365                         var hc = new HttpContextStub2 ("~/Hello/World", String.Empty);
1366                         var rd = route.GetRouteData (hc);
1367
1368                         Assert.IsNotNull (rd, "#A1");
1369                         Assert.AreEqual ("Home", rd.GetRequiredString ("controller"), "#A2");
1370                         Assert.AreEqual ("Hello", rd.GetRequiredString ("action"), "#A3");
1371                         Assert.AreEqual ("World", rd.Values ["name"], "#A4");
1372                 }
1373
1374                 [Test]
1375                 public void ProcessConstraint ()
1376                 {
1377                         var route = new MyRoute ("hello/{name}", new MyRouteHandler ());
1378
1379                         Assert.IsFalse (route.DoProcessConstraint (null, "regex", "parameter", new RouteValueDictionary (), RouteDirection.IncomingRequest), "#1");
1380
1381                         // constraint is null
1382                         AssertExtensions.Throws <InvalidOperationException> (
1383                                 () => route.DoProcessConstraint (null, null, "parameter", new RouteValueDictionary (), RouteDirection.IncomingRequest),
1384                                 "#2"
1385                         );
1386
1387                         // constraint is neither a string or an IRouteConstraint instance
1388                         AssertExtensions.Throws <InvalidOperationException> (
1389                                 () => route.DoProcessConstraint (null, 1, "parameter", new RouteValueDictionary (), RouteDirection.IncomingRequest),
1390                                 "#3"
1391                         );
1392
1393                         AssertExtensions.Throws <ArgumentNullException> (
1394                                 () => route.DoProcessConstraint (null, "regex", null, new RouteValueDictionary (), RouteDirection.IncomingRequest),
1395                                 "#4"
1396                         );
1397
1398                         Assert.IsFalse (route.DoProcessConstraint (null, "regex", String.Empty, new RouteValueDictionary (), RouteDirection.IncomingRequest), "#5");
1399
1400                         // This is a .NET programming error, so not sure if we should test for this...
1401                         AssertExtensions.Throws <NullReferenceException> (
1402                                 () => route.DoProcessConstraint (null, "regex", "parameter", null, RouteDirection.IncomingRequest),
1403                                 "#6"
1404                         );
1405                 }
1406         }
1407 }