public static void WriteAllText(this FileAbstractLayer fal, RelativePath file, string content)
 {
     using (var writer = CreateText(fal, file))
     {
         writer.Write(content);
     }
 }

 public PathChangeKind GetPathChangeKind(RelativePath path) {
   PathChangeKind result;
   if (!_map.TryGetValue(path, out result)) {
     result = PathChangeKind.None;
   }
   return result;
 }

 private static void FixLink(XAttribute link, RelativePath filePath, HashSet<string> linkToFiles)
 {
     string linkFile;
     string anchor = null;
     if (PathUtility.IsRelativePath(link.Value))
     {
         var index = link.Value.IndexOf('#');
         if (index == -1)
         {
             linkFile = link.Value;
         }
         else if (index == 0)
         {
             return;
         }
         else
         {
             linkFile = link.Value.Remove(index);
             anchor = link.Value.Substring(index);
         }
         var path = filePath + (RelativePath)linkFile;
         var file = (string)path.GetPathFromWorkingFolder();
         link.Value = file + anchor;
         linkToFiles.Add(HttpUtility.UrlDecode(file));
     }
 }

 public static string ReadAllText(this FileAbstractLayer fal, RelativePath file)
 {
     using (var sr = OpenReadText(fal, file))
     {
         return sr.ReadToEnd();
     }
 }

 public static string GetProperty(this FileAbstractLayer fal, RelativePath file, string propertyName)
 {
     var dict = fal.GetProperties(file);
     string result;
     dict.TryGetValue(propertyName, out result);
     return result;
 }

 public override void Copy(PathMapping sourceFilePath, RelativePath destFilePath)
 {
     var key = destFilePath.GetPathFromWorkingFolder();
     _mapping[key] = new PathMapping(key, sourceFilePath.PhysicalPath)
     {
         Properties = sourceFilePath.Properties,
     };
 }

 public IEnumerable<string> GetSection(string sectionName, Func<IEnumerable<string>, IEnumerable<string>> postProcessing)
 {
     var filename = new RelativePath(sectionName);
       return _configurationFileProvider.ReadFile(filename, (fullPathName, lines) => {
     _volatileToken.AddFile(fullPathName);
     return postProcessing(lines);
       });
 }

 public FileName(DirectoryName parent, RelativePath relativePath) {
   if (parent == null)
     throw new ArgumentNullException("parent");
   if (relativePath.IsEmpty)
     throw new ArgumentException("Relative path is empty", "relativePath");
   _parent = parent;
   _relativePath = relativePath;
 }

		public PhpSourceFile(FullPath root, FullPath fullPath)
		{
			root.EnsureNonEmpty("root");
			fullPath.EnsureNonEmpty("fullPath");

			this.fullPath = fullPath;
			this.relativePath = RelativePath.Empty;
			this.root = root;
		}

 public bool Exists(RelativePath file)
 {
     if (file == null)
     {
         throw new ArgumentNullException(nameof(file));
     }
     EnsureNotDisposed();
     return Reader.FindFile(file) != null;
 }

 public PathMapping? FindFile(RelativePath file)
 {
     var pp = Path.Combine(_expandedInputFolder, file.RemoveWorkingFolder());
     if (!File.Exists(pp))
     {
         return null;
     }
     return new PathMapping(file, Path.Combine(InputFolder, file.RemoveWorkingFolder())) { Properties = Properties };
 }

        public void RelativePath_Unit_Append1_PathContainsAnotherSeparator()
        {
            String[] nodes = new String[] { "sites" };
            Char separator = RelativePath.ForwardSlash;
            RelativePath target = new RelativePath(nodes, separator);
            String path = "Chad\\Greer";

            target.Append(path);
        }

    public bool MatchFileName(RelativePath relativePath, IPathComparer comparer) {
      var path = relativePath.Value;
      CheckPath(path);

      if (PrePassWontMatch(MatchKind.File, path, comparer))
        return false;

      var result = BaseOperator.Match(MatchKind.File, comparer, Operators, 0, path, 0);
      return IsMatch(path, result);
    }

 public FileStream OpenRead(RelativePath file)
 {
     if (file == null)
     {
         throw new ArgumentNullException(nameof(file));
     }
     EnsureNotDisposed();
     var pp = FindPhysicalPath(file);
     return File.OpenRead(Environment.ExpandEnvironmentVariables(pp.PhysicalPath));
 }

        public IEnumerable<string> ReadFile(RelativePath relativePath, Func<FullPath, IEnumerable<string>, IEnumerable<string>> postProcessing)
        {
            foreach (var directoryName in PossibleDirectoryNames()) {
            var path = directoryName.Combine(relativePath);
            if (_fileSystem.FileExists(path))
              return postProcessing(path, _fileSystem.ReadAllLines(path));
              }

              throw new FileLoadException(
            string.Format("Could not load configuration file \"{0}\" from the following locations:{1}", relativePath,
                      PossibleDirectoryNames().Aggregate("", (x, y) => x + "\n" + y)));
        }

 public FileStream Create(RelativePath file)
 {
     if (file == null)
     {
         throw new ArgumentNullException(nameof(file));
     }
     EnsureNotDisposed();
     if (!CanWrite)
     {
         throw new InvalidOperationException();
     }
     return Writer.Create(file);
 }

        public void RelativePath_Unit_Append1_Optimal()
        {
            String[] nodes = new String[] { "sites" };
            Char separator = RelativePath.ForwardSlash;
            RelativePath target = new RelativePath(nodes, separator);
            String path = "Chad/Greer";

            RelativePath result = target.Append(path);
            Assert.AreEqual("sites", result.Nodes.ElementAt(0));
            Assert.AreEqual("Chad", result.Nodes.ElementAt(1));
            Assert.AreEqual("Greer", result.Nodes.ElementAt(2));
            Assert.AreEqual(separator, result.Separator);
        }

        public void TestPaths()
        {
            FullPath root;
            FullPath full;
            RelativePath rel;
            string str1, str2;

            string[,] cases = 
      {
          // root:        // full:          // full canonical:    // relative canonical:
        { @"C:\a/b/c/",   @"D:\a/b/",       @"D:\a\b\",           @"D:\a\b\" },
                                            
        { @"C:\a\b\c",    @"C:\a\b\c",      @"C:\a\b\c",          @"" },
        { @"C:\a\b\c",    @"C:\a\b\c\",     @"C:\a\b\c\",         @"" },
        { @"C:\a\b\c\",   @"C:\a\b\c",      @"C:\a\b\c",          @"" },
        { @"C:\a\b\c\",   @"C:\a\b\c\",     @"C:\a\b\c\",         @"" },
                                            
        { @"C:\a\b\c",    @"C:\a\b",        @"C:\a\b",            @".." },
        { @"C:\a\b\c\",   @"C:\a\b",        @"C:\a\b",            @".." },
                                            
        { @"C:\a\b\c",    @"C:\",           @"C:\",                @"..\..\.." },
        { @"C:\a\b\c\",   @"C:\",           @"C:\",                @"..\..\.." },
                                            
        { @"C:\a\b\c\",   @"C:\a\b\x\y\z",  @"C:\a\b\x\y\z",      @"..\x\y\z" },
        { @"C:\a\b\cd\",  @"C:\a\b\c",      @"C:\a\b\c",          @"..\c" },
        { @"C:\a\b\cd",   @"C:\a\b\c",      @"C:\a\b\c",          @"..\c" },
        { @"C:\a\b\cd\",  @"C:\a\b\c\d",    @"C:\a\b\c\d",          @"..\c\d" },
        { @"C:\a\b\cd",   @"C:\a\b\c\d",    @"C:\a\b\c\d",          @"..\c\d" },
      };

            for (int i = 0; i < cases.GetLength(0); i++)
            {
                root = new FullPath(cases[i, 0]);
                full = new FullPath(cases[i, 1]);
                rel = new RelativePath(root, full);

                Assert.AreEqual(full.ToString(), cases[i, 2]);

                Assert.AreEqual(rel.ToString(), cases[i, 3]);

                str1 = full;
                if (str1[str1.Length - 1] == '\\') str1 = str1.Substring(0, str1.Length - 1);

                str2 = rel.ToFullPath(root);
                if (str2[str2.Length - 1] == '\\') str2 = str2.Substring(0, str2.Length - 1);

                Assert.AreEqual(str1, str2);

                Assert.AreEqual(RelativePath.ParseCanonical(cases[i, 3]).ToString(), cases[i, 3]);
            }
        }

    public bool MatchFileName(RelativePath relativePath, IPathComparer comparer) {
      if (relativePath.IsEmpty)
        throw new ArgumentNullException("relativePath");

      if (_fileExtensions.Contains(relativePath.Extension))
        return true;

      // Note: Use "for" loop to avoid allocation if using "Any()"
      for (var index = 0; index < _pathMatchers.Length; index++) {
        if (_pathMatchers[index].MatchFileName(relativePath, comparer))
          return true;
      }
      return false;
    }

 public PathMapping(RelativePath logicalPath, string physicalPath)
 {
     if (logicalPath == null)
     {
         throw new ArgumentNullException(nameof(logicalPath));
     }
     if (physicalPath == null)
     {
         throw new ArgumentNullException(nameof(physicalPath));
     }
     LogicalPath = logicalPath.GetPathFromWorkingFolder();
     PhysicalPath = physicalPath;
     AllowMoveOut = false;
     Properties = ImmutableDictionary<string, string>.Empty;
 }