public void Constructor_Parameterless()
        {
            var result = new PathComponents();

            Assert.IsNull(result.DriveLetter);
            CollectionAssert.IsEmpty(result.Components);
        }
        public void TryParse_UnixPath_Failure(string path)
        {
            bool success = PathComponents.TryParse(path, out var result);

            Assert.IsFalse(success);
            // Assert.IsNull(result); // value of result when TryParse returns false is undefined behavior
        }
Beispiel #3
0
 private GeekUriComponents(string scheme, string host, PathComponents pathComponent, GeekSign geekSign)
 {
     this.scheme        = scheme;
     this.host          = host;
     this.pathComponent = pathComponent;
     this.geekSign      = geekSign;
 }
        public void TryParse_EmptyString()
        {
            bool success = PathComponents.TryParse(string.Empty, out var result);

            Assert.IsTrue(success);
            Assert.IsNull(result.DriveLetter);
            CollectionAssert.IsEmpty(result.Components);
        }
        public void ToString_Relative(PathFormat format, string components, string expected)
        {
            var componentsObject = new PathComponents(null, components.Split(',', StringSplitOptions.RemoveEmptyEntries));

            string result = componentsObject.ToString(format);

            Assert.AreEqual(expected, result);
        }
Beispiel #6
0
        private GeekUriComponents InstanceOf(PathComponents pathComponent, Dictionary <string, string> queryParams)
        {
            GeekUriComponents uriComponents = new GeekUriComponents(this.scheme, this.host, pathComponent, this.geekSign);

            uriComponents.queryParams = queryParams;

            return(uriComponents);
        }
        public void TryParse_UnixPath_Success(string path, char?drive, string components)
        {
            bool success = PathComponents.TryParse(path, out var result);

            Assert.IsTrue(success);
            Assert.IsNotNull(result);

            Assert.AreEqual(drive, result.DriveLetter);
            CollectionAssert.AreEqual(components.Split(',', StringSplitOptions.RemoveEmptyEntries), result.Components);
        }
Beispiel #8
0
        public void TestParseWithoutDirectories()
        {
            PathComponents path = new PathComponents(@"C:\FOO.txt");

            Assert.IsTrue(path.HasDrive);
            Assert.IsFalse(path.HasDirectories);
            Assert.IsTrue(path.HasFileName);
            Assert.IsTrue(path.HasExtension);

            Assert.AreEqual("C", path.Drive);
            CollectionAssert.AreEqual(null, path.Directories);
            Assert.AreEqual("FOO.txt", path.FileName);
        }
Beispiel #9
0
        public void TestParse()
        {
            PathComponents path = new PathComponents("/home/johndoe/Desktop/FOO.txt");

            Assert.IsTrue(path.HasDrive);
            Assert.IsTrue(path.HasDirectories);
            Assert.IsTrue(path.HasFileName);
            Assert.IsTrue(path.HasExtension);

            Assert.AreEqual("/home", path.Drive);
            CollectionAssert.AreEqual(new string[] { "johndoe", "Desktop" }, path.Directories);
            Assert.AreEqual("FOO.txt", path.FileName);
            Assert.AreEqual("FOO", path.FileNameWithoutExtension);
            Assert.AreEqual("txt", path.Extension);
        }
Beispiel #10
0
        public void TestParseDriveAloneWithoutSeparator()
        {
            PathComponents path = new PathComponents(@"C:");

            Assert.IsTrue(path.HasDrive);
            Assert.IsFalse(path.HasDirectories);
            Assert.IsFalse(path.HasFileName);
            Assert.IsFalse(path.HasExtension);

            Assert.AreEqual("C", path.Drive);
            CollectionAssert.AreEqual(null, path.Directories);
            Assert.AreEqual(string.Empty, path.FileName);
            Assert.AreEqual(string.Empty, path.FileNameWithoutExtension);
            Assert.AreEqual(string.Empty, path.Extension);
        }
Beispiel #11
0
        public void TestParseFilenameAlone()
        {
            PathComponents path = new PathComponents(@"FOO.txt");

            Assert.IsFalse(path.HasDrive);
            Assert.IsFalse(path.HasDirectories);
            Assert.IsTrue(path.HasFileName);
            Assert.IsTrue(path.HasExtension);

            Assert.AreEqual(string.Empty, path.Drive);
            CollectionAssert.AreEqual(null, path.Directories);
            Assert.AreEqual("FOO.txt", path.FileName);
            Assert.AreEqual("FOO", path.FileNameWithoutExtension);
            Assert.AreEqual("txt", path.Extension);
        }
Beispiel #12
0
        public void TestParseRelativeWithoutFilename()
        {
            PathComponents path = new PathComponents(@"Users\johndoe\Desktop\");

            Assert.IsFalse(path.HasDrive);
            Assert.IsTrue(path.HasDirectories);
            Assert.IsFalse(path.HasFileName);
            Assert.IsFalse(path.HasExtension);

            Assert.AreEqual(string.Empty, path.Drive);
            CollectionAssert.AreEqual(new string[] { "Users", "johndoe", "Desktop" }, path.Directories);
            Assert.AreEqual(string.Empty, path.FileName);
            Assert.AreEqual(string.Empty, path.FileNameWithoutExtension);
            Assert.AreEqual(string.Empty, path.Extension);
        }
Beispiel #13
0
        // Convert from
        //	[<drive>:\][<directories>\][<filename>]
        // To
        //	[<RemoteRootDirectory>/][<drive>:/][<directories>/][<filename>:/<version>/][<filename>]
        public override string BuildVersionedRemotePath(string localPath, IFileVersion version)
        {
            PathComponents comps = new PathComponents(localPath);

            string result = "";

            if (!string.IsNullOrEmpty(RemoteRootDirectory))
            {
                // <RootDirectory>/
                if (RemoteRootDirectory.EndsWith("/"))
                {
                    result += RemoteRootDirectory;
                }
                else
                {
                    result += RemoteRootDirectory + RemoteDirectorySeparatorChar;
                }
            }

            if (comps.HasDrive)
            {
                // <drive>:/
                result += comps.Drive + RemoteVersionPostfixChar + RemoteDirectorySeparatorChar;
            }

            if (comps.HasDirectories)
            {
                // <directories>/
                result += string.Join(RemoteDirectorySeparatorChar.ToString(), comps.Directories) + RemoteDirectorySeparatorChar;
            }

            if (comps.HasFileName)
            {
                if (version != null)
                {
                    result += comps.FileName                                    // <filename>
                              + RemoteVersionPostfixChar                        // <filename>:
                              + RemoteDirectorySeparatorChar                    // <filename>:/
                              + version.Version                                 // <filename>:/<version>
                              + RemoteDirectorySeparatorChar;                   // <filename>:/<version>/
                }
                result += comps.FileName;                                       // [<filename>:/<version>/]<filename>
            }

            return(result);            // [<RootDirectory>/][<drive>:/][<directories>/][<filename>:/<version>/][<filename>]
        }
        public void Constructor_WithParameters(char?driveLetter, string components)
        {
            string[] componentsArray = components?.Split(',', StringSplitOptions.RemoveEmptyEntries);

            var result = new PathComponents(driveLetter, componentsArray);

            Assert.AreEqual(driveLetter, result.DriveLetter);

            if (components is null)
            {
                CollectionAssert.IsEmpty(result.Components);
            }
            else
            {
                CollectionAssert.AreEqual(componentsArray, result.Components);
            }
        }
 public Path(string value)
 {
     this.pathComponents = new GeekPathComponents(value);
 }
 public void TryParse_NullPath()
 {
     Assert.Throws <ArgumentNullException>(() => PathComponents.TryParse(null, out _));
 }
Beispiel #17
0
        public GeekUriComponents Expand(params string[] uriVariableValues)
        {
            PathComponents pathTo = pathComponent.Expand(uriVariableValues);

            return(InstanceOf(pathTo, queryParams));
        }