File utility functions v3.02

{$INCLUDE ../cDefines.inc}
unit cFileUtils;

{                                                                              }
{                       File utility functions v3.02                           }
{                                                                              }
{             This unit is copyright ?2002-2004 by David J Butler             }
{                                                                              }
{                  This unit is part of Delphi Fundamentals.                   }
{                  Its original file name is cFileUtils.pas                    }
{       The latest version is available from the Fundamentals home page        }
{                     http://fundementals.sourceforge.net/                     }
{                                                                              }
{                I invite you to use this unit, free of charge.                }
{        I invite you to distibute this unit, but it must be for free.         }
{             I also invite you to contribute to its development,              }
{             but do not distribute a modified copy of this file.              }
{                                                                              }
{          A forum is available on SourceForge for general discussion          }
{             http://sourceforge.net/forum/forum.php?forum_id=2117             }
{                                                                              }
{ Revision history:                                                            }
{   01/06/2002  3.01  Created cFileUtils from cSysUtils.                       }
{   12/12/2002  3.02  Revision.                                                }
{                                                                              }

interface

uses
  { Delphi }
  {$IFDEF OS_MSWIN}
  Windows,
  {$ENDIF}
  SysUtils;



{                                                                              }
{ Path functions                                                               }
{                                                                              }
const
  PathSeperator = {$IFDEF OS_UNIX} '/'{$ENDIF}
                  {$IFDEF OS_MSWIN}'/'{$ENDIF};

function  PathHasDriveLetter(const Path: String): Boolean;
function  PathIsDriveLetter(const Path: String): Boolean;
function  PathIsDriveRoot(const Path: String): Boolean;
function  PathIsRoot(const Path: String): Boolean;
function  PathIsUNCPath(const Path: String): Boolean;
function  PathIsAbsolute(const Path: String): Boolean;
function  PathIsDirectory(const Path: String): Boolean;
function  PathInclSuffix(const Path: String;
          const PathSep: Char = PathSeperator): String;
function  PathExclSuffix(const Path: String;
          const PathSep: Char = PathSeperator): String;
procedure PathEnsureSuffix(var Path: String;
          const PathSep: Char = PathSeperator);
procedure PathEnsureNoSuffix(var Path: String;
          const PathSep: Char = PathSeperator);
function  PathCanonical(const Path: String;
          const PathSep: Char = PathSeperator): String;
function  PathExpand(const Path: String; const BasePath: String = '';
          const PathSep: Char = PathSeperator): String;

function  PathLeftElement(const Path: String;
          const PathSep: Char = PathSeperator): String;
procedure PathSplitLeftElement(const Path: String;
          var LeftElement, RightPath: String;
          const PathSep: Char = PathSeperator);

procedure DecodeFilePath(const FilePath: String;
          var Path, FileName: String;
          const PathSep: Char = PathSeperator);

function  FileNameValid(const FileName: String): String;
function  FilePath(const FileName, Path: String; const BasePath: String = '';
          const PathSep: Char = PathSeperator): String;

function  DirectoryExpand(const Path: String; const BasePath: String = '';
          const PathSep: Char = PathSeperator): String;

function  UnixPathToWinPath(const Path: String): String;
function  WinPathToUnixPath(const Path: String): String;



{                                                                              }
{ File operations                                                              }
{   MoveFile first attempts a rename, then a copy and delete.                  }
{                                                                              }
type
  EFileError = class(Exception);

function  GetFileSize(const FileName: String): Int64;
function  GetFileDateTime(const FileName: String): TDateTime;
function  GetFirstFileNameMatching(const FileMask: String): String;
function  DirEntryGetAttr(const FileName: String): Integer;
function  DirEntryIsDirectory(const FileName: String): Boolean;
function  FileHasAttr(const FileName: String; const Attr: Word): Boolean;
function  FileIsReadOnly(const FileName: String): Boolean;
procedure CopyFile(const FileName, DestName: String);
procedure MoveFile(const FileName, DestName: String);
function  DeleteFiles(const FileMask: String): Boolean;



{$IFDEF OS_MSWIN}
{                                                                              }
{ Logical Drive functions                                                      }
{                                                                              }
type
  TLogicalDriveType = (
      DriveRemovable,
      DriveFixed,
      DriveRemote,
      DriveCDRom,
      DriveRamDisk,
      DriveTypeUnknown);

function  DriveIsValid(const Drive: Char): Boolean;
function  DriveGetType(const Path: String): TLogicalDriveType;
function  DriveFreeSpace(const Path: String): Int64;
{$ENDIF}



{                                                                              }
{ Self-testing code                                                            }
{                                                                              }
procedure SelfTest;



implementation

uses
  { Fundamentals }
  cUtils,
  cStrings;



{                                                                              }
{ Path functions                                                               }
{                                                                              }
function PathHasDriveLetter(const Path: String): Boolean;
var P: PChar;
begin
  Result := False;
  if Length(Path) < 2 then
    exit;
  P := Pointer(Path);
  if not (P^ in ['A'..'Z', 'a'..'z']) then
    exit;
  Inc(P);
  if P^ <> ':' then
    exit;
  Result := True;
end;

function PathIsDriveLetter(const Path: String): Boolean;
begin
  Result := (Length(Path) = 2) and PathHasDriveLetter(Path);
end;

function PathIsDriveRoot(const Path: String): Boolean;
begin
  Result := (Length(Path) = 3) and PathHasDriveLetter(Path) and
            (Path[3] = '/');
end;

function PathIsRoot(const Path: String): Boolean;
begin
  Result := ((Length(Path) = 1) and (Path[1] in csSlash)) or
            PathIsDriveRoot(Path);
end;

function PathIsUNCPath(const Path: String): Boolean;
var P: PChar;
begin
  Result := False;
  if Length(Path) < 2 then
    exit;
  P := Pointer(Path);
  if P^ <> '/' then
    exit;
  Inc(P);
  if P^ <> '/' then
    exit;
  Result := True;
end;

function PathIsAbsolute(const Path: String): Boolean;
begin
  if Path = '' then
    Result := False else
  if PathHasDriveLetter(Path) then
    Result := True else
  if PChar(Pointer(Path))^ in ['/', '/'] then
    Result := True else
    Result := False;
end;

function PathIsDirectory(const Path: String): Boolean;
var L: Integer;
    P: PChar;
begin
  L := Length(Path);
  if L = 0 then
    Result := False else
  if (L = 2) and PathHasDriveLetter(Path) then
    Result := True else
    begin
      P := Pointer(Path);
      Inc(P, L - 1);
      Result := P^ in csSlash;
    end;
end;

function PathInclSuffix(const Path: String; const PathSep: Char): String;
var L: Integer;
    P: PChar;
begin
  L := Length(Path);
  if L = 0 then
    Result := '' else
    begin
      P := Pointer(Path);
      Inc(P, L - 1);
      if P^ = PathSep then
        Result := Path else
        Result := Path + PathSep;
    end;
end;

procedure PathEnsureSuffix(var Path: String; const PathSep: Char);
begin
  Path := PathInclSuffix(Path, PathSep);
end;

procedure PathEnsureNoSuffix(var Path: String; const PathSep: Char);
begin
  Path := PathExclSuffix(Path, PathSep);
end;

function PathExclSuffix(const Path: String; const PathSep: Char): String;
var L: Integer;
    P: PChar;
begin
  L := Length(Path);
  if L = 0 then
    Result := '' else
    begin
      P := Pointer(Path);
      Inc(P, L - 1);
      if P^ = PathSep then
        Result := Copy(Path, 1, L - 1) else
        Result := Path;
    end;
end;

function PathCanonical(const Path: String; const PathSep: Char): String;
var L, M : Integer;
    I, J : Integer;
    P    : StringArray;
    Q    : PChar;
begin
  Result := Path;
  // /./ references
  M := Length(Result);
  Repeat
    L := M;
    if L = 0 then
      exit;
    Result := StrReplace('/./', '/', Result);
    Result := StrReplace('/./', '/', Result);
    M := Length(Result);
  Until L = M;
  // ./ prefix
  StrEnsureNoPrefix(Result, './');
  StrEnsureNoPrefix(Result, './');
  // /. suffix
  StrEnsureNoSuffix(Result, '/.');
  StrEnsureNoSuffix(Result, '/.');
  // ..
  if Pos('..', Result) > 0 then
    begin
      P := StrSplitChar(Result, PathSep);
      Repeat
        J := -1;
        For I := Length(P) - 1 downto 0 do
          if P[I] = '..' then
            begin
              J := I;
              break;
            end;
        if J = -1 then
          break;
        M := -1;
        For I := J - 1 downto 0 do
          if (P[I] = '') or ((I = 0) and PathHasDriveLetter(P[I])) then
            break else
          if P[I] <> '..' then
            begin
              M := I;
              break;
            end;
        if M = -1 then
          break;
        Remove(P, J, 1);
        Remove(P, M, 1);
      Until False;
      Result := StrJoinChar(P, PathSep);
    end;
  // /../ prefix
  While StrMatchLeft(Result, '/../') do
    Delete(Result, 1, 3);
  While StrMatchLeft(Result, '/../') do
    Delete(Result, 1, 3);
  if (Result = '/..') or (Result = '/..') then
    Result := '';
  L := Length(Result);
  if L = 0 then
    exit;
  // X:/../ prefix
  Q := Pointer(Result);
  if Q^ in ['A'..'Z', 'a'..'z'] then
    begin
      if StrMatch(Result, ':/../', 2) then
        Delete(Result, 4, 3) else
      if (L = 5) and StrMatch(Result, ':/..', 2) then
        begin
          SetLength(Result, 2);
          exit;
        end;
      L := Length(Result);
    end;
  // single dot
  Q := Pointer(Result);
  if L = 1 then
    begin
      if Q^ = '.' then
        Result := '';
      exit;
    end;
  // final dot
  Inc(Q, L - 2);
  if not (Q^ in ['.', '/', '/', ':']) then
    begin
      Inc(Q);
      if Q^ = '.' then
        Delete(Result, L, 1);
    end;
end;

function PathExpand(const Path: String; const BasePath: String;
    const PathSep: Char): String;
begin
  if Path = '' then
    Result := BasePath else
  if PathIsAbsolute(Path) then
    Result := Path else
    Result := PathInclSuffix(BasePath, PathSep) + Path;
  Result := PathCanonical(Result, PathSep);
end;

function PathLeftElement(const Path: String; const PathSep: Char): String;
var I: Integer;
begin
  I := PosChar(PathSep, Path);
  if I <= 0 then
    Result := Path else
    Result := Copy(Path, 1, I - 1);
end;

procedure PathSplitLeftElement(const Path: String;
    var LeftElement, RightPath: String; const PathSep: Char);
var I: Integer;
begin
  I := PosChar(PathSep, Path);
  if I <= 0 then
    begin
      LeftElement := Path;
      RightPath := '';
    end else
    begin
      LeftElement := Copy(Path, 1, I - 1);
      RightPath := CopyFrom(Path, I + 1);
    end;
end;

procedure DecodeFilePath(const FilePath: String; var Path, FileName: String;
    const PathSep: Char);
var I: Integer;
begin
  I := PosCharRev(PathSep, FilePath);
  if I <= 0 then
    begin
      Path := '';
      FileName := FilePath;
    end else
    begin
      Path := Copy(FilePath, 1, I);
      FileName := CopyFrom(FilePath, I + 1);
    end;
end;

function FileNameValid(const FileName: String): String;
begin
  Result := StrReplaceChar(['/', '/', ':', '>', '<', '*', '?'], '_', FileName);
  if Result = '.' then
    Result := '' else
  if Result = '..' then
    Result := '_';
end;

function FilePath(const FileName, Path: String; const BasePath: String;
    const PathSep: Char): String;
var P, F: String;
begin
  F := FileNameValid(FileName);
  if F = '' then
    begin
      Result := '';
      exit;
    end;
  P := PathExpand(Path, BasePath, PathSep);
  if P = '' then
    Result := F else
    Result := PathInclSuffix(P, PathSep) + F;
  End;

function DirectoryExpand(const Path: String; const BasePath: String;
    const PathSep: Char): String;
begin
  Result := PathExpand(PathInclSuffix(Path, PathSep),
      PathInclSuffix(BasePath), PathSep);
end;

function UnixPathToWinPath(const Path: String): String;
begin
  Result := StrReplaceChar('/', '/',
            StrReplaceChar(['/', ':', '<', '>', '|'], '_', Path));
end;

function WinPathToUnixPath(const Path: String): String;
begin
  Result := Path;
  if PathHasDriveLetter(Path) then
    begin
      // X: -> /X
      Result[2] := Result[1];
      Result[1] := '/';
    end else
  if StrMatchLeft(Path, '//./') then
    // //./ -> /
    Delete(Result, 1, 3) else
  if PathIsUncPath(Path) then
    // // -> /
    Delete(Result, 1, 1);
  Result := StrReplaceChar('/', '/',
            StrReplaceChar(['/', ':', '<', '>', '|'], '_', Result));
end;




{                                                                              }
{ File operations                                                              }
{                                                                              }
function GetFileSize(const FileName: String): Int64;
var SRec : TSearchRec;
begin
  if FindFirst(FileName, faAnyFile, SRec) <> 0 then
    Result := -1 else
    begin
      {$IFDEF OS_MSWIN}
      {$WARNINGS OFF}
      Int64Rec(Result).Lo := SRec.FindData.nFileSizeLow;
      Int64Rec(Result).Hi := SRec.FindData.nFileSizeHigh;
      {$IFDEF DEBUG}{$WARNINGS ON}{$ENDIF}
      {$ELSE}
      Result := SRec.Size;
      {$ENDIF}
      FindClose(SRec);
    end;
end;

function GetFileDateTime(const FileName: String): TDateTime;
var Age : LongInt;
begin
  Age := FileAge(FileName);
  if Age = -1 then
    Result := 0
  else
    Result := FileDateToDateTime(Age);
end;

function GetFirstFileNameMatching(const FileMask: String): String;
var SRec : TSearchRec;
begin
  Result := '';
  if FindFirst(FileMask, faAnyFile, SRec) = 0 then
    try
      Repeat
        if SRec.Attr and faDirectory = 0 then
          begin
            Result := ExtractFilePath(FileMask) + SRec.Name;
            exit;
          end;
      Until FindNext(SRec) <> 0;
    finally
      FindClose(SRec);
    end;
end;

function DirEntryGetAttr(const FileName: String): Integer;
var SRec : TSearchRec;
begin
  if (FileName = '') or PathIsDriveLetter(FileName) then
    Result := -1 else
  if PathIsRoot(FileName) then
    Result := $0800 or faDirectory else
  if FindFirst(PathExclSuffix(FileName, '/'), faAnyFile, SRec) = 0 then
    begin
      Result := SRec.Attr;
      FindClose(SRec);
    end
  else
    Result := -1;
end;

function DirEntryIsDirectory(const FileName: String): Boolean;
var SRec : TSearchRec;
begin
  if (FileName = '') or PathIsDriveLetter(FileName) then
    Result := False else
  if PathIsRoot(FileName) then
    Result := True else
  if FindFirst(PathExclSuffix(FileName, '/'), faDirectory, SRec) = 0 then
    begin
      Result := SRec.Attr and faDirectory <> 0;
      FindClose(SRec);
    end
  else
    Result := False;
end;

{$IFDEF DELPHI6_UP}{$WARN SYMBOL_PLATFORM OFF}{$ENDIF}
function FileHasAttr(const FileName: String; const Attr: Word): Boolean;
var A : Integer;
begin
  A := FileGetAttr(FileName);
  Result := (A >= 0) and (A and Attr <> 0);
end;

function FileIsReadOnly(const FileName: String): Boolean;
begin
  Result := FileHasAttr(FileName, faReadOnly);
end;

procedure CopyFile(const FileName, DestName: String);
var
  CopyBuffer   : Pointer;
  BytesCopied  : Longint;
  Source, Dest : Integer;
  Destination  : TFileName;
const
  ChunkSize = 8192;
begin
  Destination := ExpandFileName(DestName);
  if FileHasAttr(Destination, faDirectory) then // if destination is a directory, append file name
    Destination := Destination + '/' + ExtractFileName(FileName);
  GetMem(CopyBuffer, ChunkSize);
  try
    Source := FileOpen(FileName, fmShareDenyWrite);
    if Source < 0 then
      raise EFileError.CreateFmt('Can not open file %s', [FileName]);
    try
      Dest := FileCreate(Destination);
      if Dest < 0 then
        raise EFileError.CreateFmt('Can not create file %s', [Destination]);
      try
        Repeat
          BytesCopied := FileRead(Source, CopyBuffer^, ChunkSize);
          if BytesCopied > 0 then
            FileWrite(Dest, CopyBuffer^, BytesCopied);
        Until BytesCopied < ChunkSize;
      finally
        FileClose(Dest);
      end;
    finally
      FileClose(Source);
    end;
  finally
    FreeMem(CopyBuffer, ChunkSize);
  end;
end;

procedure MoveFile(const FileName, DestName: String);
var Destination : String;
    Attr : Integer;
begin
  Destination := ExpandFileName(DestName);
  if not RenameFile(FileName, Destination) then
    begin
      Attr := FileGetAttr(FileName);
      if (Attr < 0) or (Attr and faReadOnly <> 0) then
        raise EFileError.Create(Format('Can not move file %s', [FileName]));
      CopyFile(FileName, Destination);
      DeleteFile(FileName);
    end;
end;

function DeleteFiles(const FileMask: String): Boolean;
var SRec : TSearchRec;
    Path : String;
begin
  Result := FindFirst(FileMask, faAnyFile, SRec) = 0;
  if not Result then
    exit;
  try
    Path := ExtractFilePath(FileMask);
    Repeat
      if (SRec.Name <> '') and (SRec.Name  <> '.') and (SRec.Name <> '..') and
        (SRec.Attr and (faVolumeID + faDirectory) = 0) then
      begin
        Result := DeleteFile(Path + SRec.Name);
        if not Result then
          break;
      end;
    Until FindNext(SRec) <> 0;
  finally
    FindClose(SRec);
  end;
end;
{$IFDEF DELPHI6_UP}{$WARN SYMBOL_PLATFORM ON}{$ENDIF}



{$IFDEF OS_MSWIN}
{                                                                              }
{ Logical Drive functions                                                      }
{                                                                              }
function DriveIsValid(const Drive: Char): Boolean;
var D : Char;
begin
  D := UpCase(Drive);
  Result := D in ['A'..'Z'];
  if not Result then
    exit;
  Result := IsBitSet(GetLogicalDrives, Ord(D) - Ord('A'));
end;

function DriveGetType(const Path: String): TLogicalDriveType;
begin
  Case GetDriveType(PChar(Path)) of
    DRIVE_REMOVABLE : Result := DriveRemovable;
    DRIVE_FIXED     : Result := DriveFixed;
    DRIVE_REMOTE    : Result := DriveRemote;
    DRIVE_CDROM     : Result := DriveCDRom;
    DRIVE_RAMDISK   : Result := DriveRamDisk;
  else
    Result := DriveTypeUnknown;
  end;
end;

function DriveFreeSpace(const Path: String): Int64;
var D: Byte;
begin
  if PathHasDriveLetter(Path) then
    D := Ord(UpCase(PChar(Path)^)) - Ord('A') + 1 else
  if PathIsUNCPath(Path) then
    begin
      Result := -1;
      exit;
    end else
    D := 0;
  Result := DiskFree(D);
end;
{$ENDIF}



{                                                                              }
{ Self-testing code                                                            }
{                                                                              }
{$ASSERTIONS ON}
procedure SelfTest;
begin
  Assert(PathHasDriveLetter('C:'), 'PathHasDriveLetter');
  Assert(PathHasDriveLetter('C:/'), 'PathHasDriveLetter');
  Assert(not PathHasDriveLetter('/C/'), 'PathHasDriveLetter');
  Assert(not PathHasDriveLetter('::'), 'PathHasDriveLetter');

  Assert(PathIsAbsolute('/'), 'PathIsAbsolute');
  Assert(PathIsAbsolute('/C'), 'PathIsAbsolute');
  Assert(PathIsAbsolute('/C/'), 'PathIsAbsolute');
  Assert(PathIsAbsolute('C:/'), 'PathIsAbsolute');
  Assert(PathIsAbsolute('C:'), 'PathIsAbsolute');
  Assert(PathIsAbsolute('/C/../'), 'PathIsAbsolute');
  Assert(not PathIsAbsolute(''), 'PathIsAbsolute');
  Assert(not PathIsAbsolute('C'), 'PathIsAbsolute');
  Assert(not PathIsAbsolute('C/'), 'PathIsAbsolute');
  Assert(not PathIsAbsolute('C/D'), 'PathIsAbsolute');
  Assert(not PathIsAbsolute('C/D/'), 'PathIsAbsolute');
  Assert(not PathIsAbsolute('../'), 'PathIsAbsolute');

  Assert(PathIsDirectory('/'), 'PathIsDirectory');
  Assert(PathIsDirectory('/C/'), 'PathIsDirectory');
  Assert(PathIsDirectory('C:'), 'PathIsDirectory');
  Assert(PathIsDirectory('C:/'), 'PathIsDirectory');
  Assert(PathIsDirectory('C:/D/'), 'PathIsDirectory');
  Assert(not PathIsDirectory(''), 'PathIsDirectory');
  Assert(not PathIsDirectory('D'), 'PathIsDirectory');
  Assert(not PathIsDirectory('C/D'), 'PathIsDirectory');

  Assert(PathInclSuffix('', '/') = '', 'PathInclSuffix');
  Assert(PathInclSuffix('C', '/') = 'C/', 'PathInclSuffix');
  Assert(PathInclSuffix('C/', '/') = 'C/', 'PathInclSuffix');
  Assert(PathInclSuffix('C/D', '/') = 'C/D/', 'PathInclSuffix');
  Assert(PathInclSuffix('C/D/', '/') = 'C/D/', 'PathInclSuffix');
  Assert(PathInclSuffix('C:', '/') = 'C:/', 'PathInclSuffix');
  Assert(PathInclSuffix('C:/', '/') = 'C:/', 'PathInclSuffix');

  Assert(PathExclSuffix('', '/') = '', 'PathExclSuffix');
  Assert(PathExclSuffix('C', '/') = 'C', 'PathExclSuffix');
  Assert(PathExclSuffix('C/', '/') = 'C', 'PathExclSuffix');
  Assert(PathExclSuffix('C/D', '/') = 'C/D', 'PathExclSuffix');
  Assert(PathExclSuffix('C/D/', '/') = 'C/D', 'PathExclSuffix');
  Assert(PathExclSuffix('C:', '/') = 'C:', 'PathExclSuffix');
  Assert(PathExclSuffix('C:/', '/') = 'C:', 'PathExclSuffix');

  Assert(PathCanonical('', '/') = '', 'PathCanonical');
  Assert(PathCanonical('.', '/') = '', 'PathCanonical');
  Assert(PathCanonical('./', '/') = '', 'PathCanonical');
  Assert(PathCanonical('../', '/') = '../', 'PathCanonical');
  Assert(PathCanonical('/../', '/') = '/', 'PathCanonical');
  Assert(PathCanonical('/X/../../', '/') = '/', 'PathCanonical');
  Assert(PathCanonical('/..', '/') = '', 'PathCanonical');
  Assert(PathCanonical('X', '/') = 'X', 'PathCanonical');
  Assert(PathCanonical('/X', '/') = '/X', 'PathCanonical');
  Assert(PathCanonical('X.', '/') = 'X', 'PathCanonical');
  Assert(PathCanonical('.', '/') = '', 'PathCanonical');
  Assert(PathCanonical('/X.', '/') = '/X', 'PathCanonical');
  Assert(PathCanonical('/X.Y', '/') = '/X.Y', 'PathCanonical');
  Assert(PathCanonical('/X.Y/', '/') = '/X.Y/', 'PathCanonical');
  Assert(PathCanonical('/A/X..Y/', '/') = '/A/X..Y/', 'PathCanonical');
  Assert(PathCanonical('/A/.Y/', '/') = '/A/.Y/', 'PathCanonical');
  Assert(PathCanonical('/A/..Y/', '/') = '/A/..Y/', 'PathCanonical');
  Assert(PathCanonical('/A/Y../', '/') = '/A/Y../', 'PathCanonical');
  Assert(PathCanonical('/A/Y..', '/') = '/A/Y..', 'PathCanonical');
  Assert(PathCanonical('X', '/') = 'X', 'PathCanonical');
  Assert(PathCanonical('X/', '/') = 'X/', 'PathCanonical');
  Assert(PathCanonical('X/Y/..', '/') = 'X', 'PathCanonical');
  Assert(PathCanonical('X/Y/../', '/') = 'X/', 'PathCanonical');
  Assert(PathCanonical('/X/Y/..', '/') = '/X', 'PathCanonical');
  Assert(PathCanonical('/X/Y/../', '/') = '/X/', 'PathCanonical');
  Assert(PathCanonical('/X/Y/../..', '/') = '', 'PathCanonical');
  Assert(PathCanonical('/X/Y/../../', '/') = '/', 'PathCanonical');
  Assert(PathCanonical('/A/././X/./Y/.././.././', '/') = '/A/', 'PathCanonical');
  Assert(PathCanonical('C:', '/') = 'C:', 'PathCanonical');
  Assert(PathCanonical('C:/', '/') = 'C:/', 'PathCanonical');
  Assert(PathCanonical('C:/A/..', '/') = 'C:', 'PathCanonical');
  Assert(PathCanonical('C:/A/../', '/') = 'C:/', 'PathCanonical');
  Assert(PathCanonical('C:/../', '/') = 'C:/', 'PathCanonical');
  Assert(PathCanonical('C:/..', '/') = 'C:', 'PathCanonical');
  Assert(PathCanonical('C:/A/../..', '/') = 'C:', 'PathCanonical');
  Assert(PathCanonical('C:/A/../../', '/') = 'C:/', 'PathCanonical');
  Assert(PathCanonical('/A/B/../C/D/../', '/') = '/A/C/', 'PathCanonical');
  Assert(PathCanonical('/A/B/../C/D/../../', '/') = '/A/', 'PathCanonical');
  Assert(PathCanonical('/A/B/../C/D/../../../', '/') = '/', 'PathCanonical');
  Assert(PathCanonical('/A/B/../C/D/../../../../', '/') = '/', 'PathCanonical');

  Assert(PathExpand('', '', '/') = '', 'PathExpand');
  Assert(PathExpand('', '/', '/') = '/', 'PathExpand');
  Assert(PathExpand('', '/C', '/') = '/C', 'PathExpand');
  Assert(PathExpand('', '/C/', '/') = '/C/', 'PathExpand');
  Assert(PathExpand('../', '/C/', '/') = '/', 'PathExpand');
  Assert(PathExpand('..', '/C/', '/') = '', 'PathExpand');
  Assert(PathExpand('/..', '/C/', '/') = '', 'PathExpand');
  Assert(PathExpand('/../', '/C/', '/') = '/', 'PathExpand');
  Assert(PathExpand('A', '../', '/') = '../A', 'PathExpand');
  Assert(PathExpand('../', '../', '/') = '../../', 'PathExpand');
  Assert(PathExpand('/', '', '/') = '/', 'PathExpand');
  Assert(PathExpand('/', '/C', '/') = '/', 'PathExpand');
  Assert(PathExpand('/A', '/C/', '/') = '/A', 'PathExpand');
  Assert(PathExpand('/A/', '/C/', '/') = '/A/', 'PathExpand');
  Assert(PathExpand('/A/B', '/C', '/') = '/A/B', 'PathExpand');
  Assert(PathExpand('A/B', '/C', '/') = '/C/A/B', 'PathExpand');
  Assert(PathExpand('A/B', '/C', '/') = '/C/A/B', 'PathExpand');
  Assert(PathExpand('A/B', '/C/', '/') = '/C/A/B', 'PathExpand');
  Assert(PathExpand('A/B', '/C/', '/') = '/C/A/B', 'PathExpand');
  Assert(PathExpand('A/B', 'C/D', '/') = 'C/D/A/B', 'PathExpand');
  Assert(PathExpand('../A/B', 'C/D', '/') = 'C/A/B', 'PathExpand');
  Assert(PathExpand('../A/B', '/C/D', '/') = '/C/A/B', 'PathExpand');
  Assert(PathExpand('../../A/B', 'C/D', '/') = 'A/B', 'PathExpand');
  Assert(PathExpand('../../A/B', '/C/D', '/') = '/A/B', 'PathExpand');
  Assert(PathExpand('../../../A/B', '/C/D', '/') = '/A/B', 'PathExpand');
  Assert(PathExpand('/../A/B', '/C/D', '/') = '/A/B', 'PathExpand');
  Assert(PathExpand('../A/B', '/../C/D', '/') = '/C/A/B', 'PathExpand');
  Assert(PathExpand('../A/B', '../C/D', '/') = '../C/A/B', 'PathExpand');
  Assert(PathExpand('../A/B', 'C:/C/D', '/') = 'C:/C/A/B', 'PathExpand');
  Assert(PathExpand('../A/B/', 'C:/C/D', '/') = 'C:/C/A/B/', 'PathExpand');

  Assert(FilePath('C', '../X/Y', 'A/B', '/') = 'A/X/Y/C', 'FilePath');
  Assert(FilePath('C', '/X/Y', 'A/B', '/') = '/X/Y/C', 'FilePath');
  Assert(FilePath('C', '', 'A/B', '/') = 'A/B/C', 'FilePath');
  Assert(FilePath('', '/X/Y', 'A/B', '/') = '', 'FilePath');
  Assert(FilePath('C', 'X/Y', 'A/B', '/') = 'A/B/X/Y/C', 'FilePath');
  Assert(FilePath('C', 'X/Y', '', '/') = 'X/Y/C', 'FilePath');

  Assert(DirectoryExpand('', '', '/') = '', 'DirectoryExpand');
  Assert(DirectoryExpand('', '/X', '/') = '/X/', 'DirectoryExpand');
  Assert(DirectoryExpand('/', '/X', '/') = '/', 'DirectoryExpand');
  Assert(DirectoryExpand('/A', '/X', '/') = '/A/', 'DirectoryExpand');
  Assert(DirectoryExpand('/A/', '/X', '/') = '/A/', 'DirectoryExpand');
  Assert(DirectoryExpand('/A/B', '/X', '/') = '/A/B/', 'DirectoryExpand');
  Assert(DirectoryExpand('A', '/X', '/') = '/X/A/', 'DirectoryExpand');
  Assert(DirectoryExpand('A/', '/X', '/') = '/X/A/', 'DirectoryExpand');
  Assert(DirectoryExpand('C:', '/X', '/') = 'C:/', 'DirectoryExpand');
  Assert(DirectoryExpand('C:/', '/X', '/') = 'C:/', 'DirectoryExpand');

  Assert(UnixPathToWinPath('/c/d.f') = '/c/d.f', 'UnixPathToWinPath');
  Assert(WinPathToUnixPath('/c/d.f') = '/c/d.f', 'WinPathToUnixPath');
end;



end.