freepascal.compiler/packages/fpindexer/tests/tfpmasks.pp

{$mode objfpc}
program test;
{$codepage utf8}

uses classes, fpcunit, fpmasks;


type

  { TTestMask }

  TTestMask = class
  private
    FS, FMask: Utf8String;
    procedure Test;
    procedure TestMask(const S, Mask: Utf8String; Result: Boolean);
    procedure TestMaskCaseInSensitive(const S, Mask: Utf8String; Result: Boolean);
    procedure TestMaskDisableRange(const S, Mask: Utf8String; Result: Boolean);
    procedure TestMaskAdvanced(const S, Mask: Utf8String; Result: Boolean);
    procedure TestMaskWindows(const S, Mask: Utf8String; Result: Boolean);
    procedure TestMaskWindowsNonDefaultQuirks(const S, Mask: Utf8String; Result: Boolean);
    procedure TestMaskException(const S, Mask: Utf8String; AFail: Boolean);
  public
    procedure TestMaskSyntax;
    procedure TestNil;
    procedure TestAnyText;
    procedure TestAnyChar;
    procedure TestCharSet;
    procedure TestDisableRange;
    procedure TestCase;
    procedure TestDefault;
    procedure TestAdvanced;
    procedure TestWindows;
  end;

procedure TTestMask.Test;
begin
  MatchesMask(FS, FMask);
end;

procedure TTestMask.TestMask(const S, Mask: Utf8String; Result: Boolean);
begin
  TAssert.AssertEquals(S + ' match ' + Mask + ': ', Result, MatchesMask(S, Mask));
end;

procedure TTestMask.TestMaskCaseInSensitive(const S, Mask: Utf8String;
  Result: Boolean);
begin
  TAssert.AssertEquals(S + ' match ' + Mask + ': ', Result, MatchesMask(S, Mask, False));
end;

procedure TTestMask.TestMaskDisableRange(const S, Mask: Utf8String; Result: Boolean);
begin
  TAssert.AssertEquals(S + ' match ' + Mask + ': ', Result,
               MatchesMask(S, Mask, False, MaskOpCodesDisableRange));
end;

procedure TTestMask.TestMaskAdvanced(const S, Mask: Utf8String; Result: Boolean);
begin
  TAssert.AssertEquals(S + ' match ' + Mask + ': ', Result,
               MatchesMask(S, Mask, False, AllMaskOpCodes));
end;

procedure TTestMask.TestMaskWindows(const S, Mask: Utf8String; Result: Boolean);
begin
  TAssert.AssertEquals(S + ' match ' + Mask + ': ', Result, MatchesWindowsMask(S, Mask));
end;

procedure TTestMask.TestMaskWindowsNonDefaultQuirks(const S, Mask: Utf8String;
  Result: Boolean);
begin
  TAssert.AssertEquals(S + ' match ' + Mask + ': ', Result, MatchesWindowsMask(S, Mask, False, DefaultMaskOpCodes, [wqFilenameEnd,wqExtension3More,wqAllByExtension]));
end;

procedure TTestMask.TestMaskException(const S, Mask: Utf8String; AFail: Boolean);
begin
  FS := S;
  FMask := Mask;
  if AFail then
    TAssert.AssertException('Invalid syntax: ' + S + ' match ' + Mask + ': ', EMaskError, @Test)
  else
    try
      Test;
    except
      TAssert.Fail('Invalid syntax: ' + S + ' match ' + Mask);
    end;
end;

procedure TTestMask.TestMaskSyntax;
begin
  TestMaskException('', '', False);
  TestMaskException('', 'a', False);
  TestMaskException('', '?', False);
  TestMaskException('', '*', False);
  TestMaskException('', '[a]', False);
  TestMaskException('', '[a-b]', False);
  TestMaskException('', '[!a-b]', False);
  TestMaskException('', '[abc]', False);
  TestMaskException('', '[abc-fgh]', False);
  TestMaskException('', '[a------h]', False);
  TestMaskException('', '**', False);
  TestMaskException('', 'aa', False);
  TestMaskException('', 'a*', False);
  TestMaskException('', '*a', False);
  TestMaskException('', '*?', False);

  TestMaskException('', '[', True);
  TestMaskException('', '[a', True);
  TestMaskException('', '[]', True);
  //TestMaskException('', '[!]', True);
  //TestMaskException('', '[-]', True);
  TestMaskException('', '[a-]', True);
  //TestMaskException('', '[-a]', True);
  //TestMaskException('', '[--a]', True);
end;

procedure TTestMask.TestNil;
begin
  TestMask('', '', True);
  TestMask('', '*', True);

  TestMask('', '?', False);
  TestMask('', 'a', False);
  TestMask('', '[a]', False);
  TestMask('', 'ä', False);
  TestMask('', '[ä]', False);
end;

procedure TTestMask.TestAnyText;
begin
  TestMask('abc', '*', True);              // ASCII
  TestMask('abc', 'a*', True);
  TestMask('abc', '*c', True);
  TestMask('abc', '*a*', True);
  TestMask('abc', '*b*', True);
  TestMask('abc', '*c*', True);
  TestMask('abc', 'a*c', True);
  TestMask('abc', '*bc', True);
  TestMask('abc', 'ab*', True);

  TestMask('äöæ', '*', True);              // Unicode
  TestMask('äöæ', 'ä*', True);
  TestMask('äöæ', '*æ', True);
  TestMask('äöæ', '*ä*', True);
  TestMask('äöæ', '*ö*', True);
  TestMask('äöæ', '*æ*', True);
  TestMask('äöæ', 'ä*æ', True);
  TestMask('äöæ', '*öæ', True);
  TestMask('äöæ', 'äö*', True);

  TestMask('abcde', '*', True);            // ASCII
  TestMask('abcde', 'a*e', True);
  TestMask('abcde', 'a*b*e', True);
  TestMask('abcde', 'a*d*e', True);
  TestMask('abcde', 'a*c*e', True);
  TestMask('abcde', 'a*b*e', True);
  TestMask('abc.pas.bak', '*.bak', True);

  TestMask('äöæ獵豹☺', '*', True);         // Unicode
  TestMask('äöæ獵豹☺', 'ä*☺', True);
  TestMask('äöæ獵豹☺', 'ä*ö*☺', True);
  TestMask('äöæ獵豹☺', 'ä*獵豹*☺', True);
  TestMask('äöæ獵豹☺', 'ä*æ*☺', True);
  TestMask('äöæ獵豹☺', 'ä*ö*☺', True);

  TestMask('abc', '*b', False);            // ASCII
  TestMask('abc', 'b*', False);
  TestMask('abc', '*a', False);
  TestMask('abc', 'c*', False);
  TestMask('abc', 'ab*d', False);

  TestMask('äöæ', '*ö', False);            // Unicode
  TestMask('äöæ', 'ö*', False);
  TestMask('äöæ', '*ä', False);
  TestMask('äöæ', 'æ*', False);
  TestMask('äöæ', 'äö*ũ', False);

  TestMask('abcde', 'a*d', False);         // ASCII
  TestMask('abcde', 'a*c*d', False);
  TestMask('abcde', 'b*d*e', False);
  TestMask('abc.txt', '.*', False);
  TestMask('abc.txt', '*.', False);
  TestMask('abc', '*.', False);
  TestMask('abc.pas.bak', '*.pas', False);

  TestMask('äöæ獵豹☺', 'ä*獵豹', False);   // Unicode
  TestMask('äöæ獵豹☺', 'ä*æ*獵豹', False);
  TestMask('äöæ獵豹☺', 'ö*獵豹*☺', False);
end;

procedure TTestMask.TestAnyChar;
begin
  TestMask('abc', '?bc', True);            // ASCII
  TestMask('abc', '?b?', True);
  TestMask('abc', '???', True);

  TestMask('äöæ', '?öæ', True);            // Unicode
  TestMask('äöæ', '?ö?', True);
  TestMask('äöæ', '???', True);

  TestMask('abc', '?*?', True);            // ASCII
  TestMask('abc', '?*??', True);
  TestMask('abc', '?*?*?', True);

  TestMask('äöæ', '?*?', True);            // Unicode
  TestMask('äöæ', '?*??', True);
  TestMask('äöæ', '?*?*?', True);

  TestMask('abc', 'a?', False);            // ASCII
  TestMask('abc', 'abc?', False);
  TestMask('abc', '?abc', False);
  TestMask('abc', '??*??', False);
  TestMask('abc', '?*?*??', False);

  TestMask('äöæ', 'ä?', False);            // Unicode
  TestMask('äöæ', 'äöæ?', False);
  TestMask('äöæ', '?äöæ', False);
  TestMask('äöæ', '??*??', False);
  TestMask('äöæ', '?*?*??', False);
end;

procedure TTestMask.TestCharSet;
begin
  TestMask('c', '[c]', True);              // ASCII
  TestMask('c', '[!b]', True);
  TestMask('c', '[a-c]', True);
  TestMask('c', '[a-d]', True);
  TestMask('c', '[d-a]', True);  // Reverse range
  TestMask('c', '[!a-b]', True);
  TestMask('c', '[abc]', True);

  TestMask('ö', '[ö]', True);              // Unicode
  TestMask('ö', '[!ä]', True);
  TestMask('ö', '[ä-ũ]', True);
  TestMask('է', '[ՠ-կ]', True);
  TestMask('ö', '[!☺-☂]', True);
  TestMask('ö', '[äũö]', True);

  TestMask('c', '[a]', False);             // ASCII
  TestMask('c', '[!c]', False);
  TestMask('c', '[a-b]', False);
  TestMask('c', '[z-d]', False);  // Reverse range
  TestMask('c', '[abd]', False);

  TestMask('ö', '[ä]', False);             // Unicode
  TestMask('ö', '[!ö]', False);
  TestMask('ö', '[ՠ-կ]', False);
  TestMask('ö', '[äũæ]', False);
end;

procedure TTestMask.TestDisableRange;
begin
  TestMaskDisableRange('a[b]c', 'a[b]c', True); // [] is now literal.
  // Wildcard syntax should still work.
  TestMaskDisableRange('a[b]c', '?[b]?', True);
  TestMaskDisableRange('abc', 'a*', True);
  TestMaskDisableRange('abc', '?b?', True);

  TestMaskDisableRange('abc', '?[b]?', False);
  TestMaskDisableRange('c', '[c]', False);
end;

procedure TTestMask.TestCase;
begin
  TestMaskCaseInsensitive('aBc', '?b?', True);
  TestMaskCaseInsensitive('äÖæ', 'Äö?', True);
  TestMaskCaseInsensitive('abcÖ', '*[äũö]', True);
end;

procedure TTestMask.TestDefault;
begin
  TestMask('a?c', '?[?]?', True);
  TestMask('C:\x', 'C:\x', True);

  TestMask('a?c', '?\??', False);
  TestMask('ab*.x', '??\*.x', False);
  TestMask('x \ y', '? \\ ?', False);
  TestMask('abc', '?[?]?', False);
  TestMask('a??d', '?[?]?', False);
end;

procedure TTestMask.TestAdvanced;
begin
  TestMaskAdvanced('a?c', '?[?]?', True);
  TestMaskAdvanced('abc', '?[?]?', True);
  TestMaskAdvanced('ac', '?[?]?', True);
  TestMaskAdvanced('a?c', '?\??', True);
  TestMaskAdvanced('ab*.x', '??\*.x', True);
  TestMaskAdvanced('a[c]d', '?\[*', True);
  TestMaskAdvanced('x \ y', '? \\ ?', True);
  TestMaskAdvanced('abcd', 'a[??]d', True);
  TestMaskAdvanced('abd', 'a[??]d', True);
  TestMaskAdvanced('ad', 'a[??]d', True);

  TestMaskAdvanced('C:\x', 'C:\x', False);
  TestMaskAdvanced('abcd', '?[?]?', False);
end;

procedure TTestMask.TestWindows;
begin
  TestMaskWindows('abc.txt', '*.*', True);
  TestMaskWindows('abc', '*.*', True);
  TestMaskWindows('abc.txt', '*', True);
  TestMaskWindows('abc', '*', True);
  TestMaskWindows('abc', '*.', True);
  TestMaskWindows('abcd.txt', 'abc???.*', False);
  TestMaskWindows('abcd.txt', 'abc???.txt?', False);
  TestMaskWindowsNonDefaultQuirks('abcd.txt', 'abc???.*', True);
  TestMaskWindowsNonDefaultQuirks('abcd.txt', 'abc???.txt?', True);
  TestMaskWindows('abcd.txt', 'abc*', True);
  TestMaskWindows('abc.pas.bak', '*.bak', True);
  TestMaskWindows('C:\x', 'C:\x', True);
  TestMaskWindows('C:\ab[c]d', 'C:*[*]*', False);  //sets and ranges are enabled by default on TWindowsMask as well
  TestMaskWindows('', '*', True);
  TestMaskWindows('', '?', False);
  TestMaskWindowsNonDefaultQuirks('', '?', True); //requires wqFileNameEnd
  TestMaskWindows('abcd.txt', '*.txtx', False);
  TestMaskWindows('abc.txt', '*.', False);
  TestMaskWindows('abc.txt', '.*', False);
  TestMaskWindows('abc.pas.bak', '*.pas', False);
  TestMaskWindows('abc', '.*', False);
  TestMaskWindows('x \ y', '? \\ ?', False);
  TestMaskWindows('', 'a', False);
  TestMaskWindows('', '[a]', False);
  TestMaskWindows('foo','foo.*',True);
end;


var
  TestMask: TTestMask;
begin
  system.FileNameCaseSensitive:=true;
  TestMask := TTestMask.Create;
  try
    TestMask.TestMaskSyntax;
    TestMask.TestNil;
    TestMask.TestAnyText;
    TestMask.TestAnyChar;
    TestMask.TestCharSet;
    TestMask.TestDisableRange;
    TestMask.TestCase;
    TestMask.TestDefault;
    TestMask.TestAdvanced;
    TestMask.TestWindows;

  finally
    TestMask.Free;
  end;
end.