public void AppendTrailingSlashWorks()
 {
     var pb = new VirtualPathBuilder().CombineWith("/").AppendTrailingSlash();
     Assert.IsTrue(pb == "/");
     pb.Clear().CombineWith("/foo").AppendTrailingSlash();
     Assert.IsTrue(pb.HasTrailingSlash());
     Assert.IsTrue(pb == "/foo/");
 }
 public void AddOrReplaceExtensionWorks()
 {
     var pb = new VirtualPathBuilder().CombineWith("~/t.cs");
     Assert.IsTrue(pb.GetExtension() == "cs");
     pb.AddOrReplaceExtension("vb");
     Assert.IsTrue(pb.GetExtension() == "vb");
     pb.Clear().CombineWith("foo");
     Assert.IsFalse(pb.HasExtension());
     pb.AddOrReplaceExtension("vb");
     Assert.IsTrue(pb.GetExtension() == "vb");
 }
 public void ClearWorks()
 {
     var pb = new VirtualPathBuilder("/Foo");
     Assert.AreEqual(string.Empty, pb.ToString());
     Assert.AreEqual("/Foo/", pb.ApplicationRoot);
     pb.CombineWith("Doo");
     Assert.AreEqual("Doo", pb.ToString());
     Assert.AreEqual("/Foo/Doo", pb.Normalize().ToString());
     pb.Clear();
     Assert.AreEqual(string.Empty, pb.ToString());
     pb.CombineWith(".");
     Assert.AreEqual("", pb.Normalize().ToString());
 }
 public void GetExtensionWorks()
 {
     var pb = new VirtualPathBuilder().CombineWith(".");
     Assert.IsTrue(pb == ".");
     Assert.IsFalse(pb.HasExtension());
     Assert.IsNull(pb.GetExtension());
     pb.Clear().CombineWith("~/oops.cshtml");
     Assert.IsTrue(pb.HasExtension());
     pb.Normalize();
     Assert.IsTrue(pb.HasExtension());
     Assert.IsTrue(pb.GetExtension() == "cshtml");
     Assert.IsTrue(pb.HasExtension());
     Assert.IsTrue(pb.GetExtension(true) == "cshtml");
     Assert.IsFalse(pb.HasExtension());
 }
 public void WithRootOperatorWorks()
 {
     var pb = new VirtualPathBuilder("/Foo");
     var caught = false;
     try{
         pb.WithRootOperator();
     }
     catch(InvalidOperationException){
         caught = true;
     }
     Assert.IsTrue(caught);
     Assert.IsTrue(pb.CombineWith("/Foo").WithRootOperator() == "~/");
     Assert.IsTrue(pb.Clear().CombineWith("Doo").WithRootOperator() == "~/Doo");
 }
 public void ResolveRootOperatorWorks()
 {
     var pb = new VirtualPathBuilder();
     Assert.IsTrue(pb.CombineWith("Foo").ResolveRootOperator().ToString() == "/Foo");
     Assert.IsTrue(pb.Clear().CombineWith("~/").ResolveRootOperator().ToString() == "/");
     Assert.IsTrue(pb.Clear().CombineWith("~").ResolveRootOperator().ToString() == "/");
     pb = new VirtualPathBuilder("/Foo");
     Assert.IsTrue(pb.CombineWith("~/Doo").ResolveRootOperator().ToString() == "/Foo/Doo");
     var caught = false;
     try{
         pb.Clear().CombineWith("/Oops").ResolveRootOperator();
     }
     catch(InvalidOperationException){
         caught = true;
     }
     Assert.IsTrue(caught);
 }
 public void RemoveTrailingSlashWorks()
 {
     var pb = new VirtualPathBuilder().CombineWith("/").RemoveTrailingSlash();
     Assert.IsTrue(pb == "");
     pb.Clear().CombineWith("/").RemoveTrailingSlash(true);
     Assert.IsTrue(pb == "/");
 }
        public void NormalizeWorks()
        {
            var pb = new VirtualPathBuilder().Normalize();
            Assert.IsTrue(pb == "");
            Assert.IsTrue(pb.ToString() == "");

            pb.Clear().CombineWith(".").Normalize();
            Assert.IsTrue(pb == "");
            Assert.IsTrue(pb.ToString() == "");

            var caught = false;
            try{
                pb.Clear().CombineWith("..").Normalize();
            }
            catch(InvalidOperationException){
                caught = true;
            }
            Assert.IsTrue(caught);

            CombineWithWorks();
        }
        public void IsValidAbsolutePathWorks()
        {
            var pb = new VirtualPathBuilder();
            Assert.IsFalse(pb.IsApplicationRoot());
            Assert.IsFalse(pb.Clear().CombineWith(".").Normalize().IsValidAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("/").Normalize().IsValidAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("~").Normalize().IsValidAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("~/").Normalize().IsValidAbsolutePath());

            pb = new VirtualPathBuilder("/Foo");
            Assert.IsFalse(pb.IsApplicationRoot());
            Assert.IsFalse(pb.Clear().CombineWith(".").Normalize().IsValidAbsolutePath());
            Assert.IsFalse(pb.Clear().CombineWith("/").Normalize().IsValidAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("/Foo").Normalize().IsValidAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("/Foo/").Normalize().IsValidAbsolutePath());
            Assert.IsFalse(pb.Clear().CombineWith("/Foo2/").Normalize().IsValidAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("~").Normalize().IsValidAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("~/Anything").Normalize().IsValidAbsolutePath());
        }
 public void IsRelativePathWorks()
 {
     var pb = new VirtualPathBuilder();
     Assert.IsFalse(pb.IsRelativePath());
     pb.CombineWith(".");
     Assert.IsTrue(pb.IsRelativePath());
     pb.Clear().CombineWith("Foo");
     Assert.IsTrue(pb.IsRelativePath());
     pb.Normalize();
     Assert.IsFalse(pb.IsRelativePath());
     Assert.IsTrue(pb.IsAbsolutePath());
 }
        public void IsAbsolutePathWorks()
        {
            var pb = new VirtualPathBuilder().CombineWith("~/");
            Assert.IsFalse(pb.IsAbsolutePath());
            pb.Normalize();
            Assert.IsTrue(pb.IsAbsolutePath());

            pb = new VirtualPathBuilder().CombineWith("~");
            Assert.IsFalse(pb.IsAbsolutePath());
            pb.Normalize();
            Assert.IsTrue(pb.IsAbsolutePath());

            pb = new VirtualPathBuilder().CombineWith("~/Foo");
            Assert.IsFalse(pb.IsAbsolutePath());
            pb.Normalize();
            Assert.IsTrue(pb.IsAbsolutePath());

            pb = new VirtualPathBuilder("/Foo");
            Assert.IsFalse(pb.IsAbsolutePath());
            Assert.IsTrue(pb.CombineWith("/Foo/").IsAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("/Foo").IsAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("/Foo/Doo").IsAbsolutePath());
            Assert.IsTrue(pb.Clear().CombineWith("/Foo/Doo/Boo").IsAbsolutePath());
            Assert.IsTrue(pb.CombineWith("../..") == "/Foo");
            Assert.IsTrue(pb.WithRootOperator().HasRootOperator());

            pb = new VirtualPathBuilder("/Foo");
            pb.CombineWith("/Doo/Foo");
            Assert.IsTrue(pb.IsAbsolutePath());
            Assert.IsFalse(pb.IsValidAbsolutePath());
        }
 public void HasTrailingSlashWorks()
 {
     var pb = new VirtualPathBuilder().CombineWith("/").Normalize();
     Assert.IsTrue(pb.HasTrailingSlash());
     Assert.IsFalse(pb.HasTrailingSlash(true));
     pb.Clear().CombineWith("/foo/");
     Assert.IsTrue(pb.HasTrailingSlash());
     pb.Clear().CombineWith("/foo");
     Assert.IsFalse(pb.HasTrailingSlash());
 }