test.core.base.pas

/// regression tests for most mormot.core.* units
// - this unit is a part of the Open Source Synopse mORMot framework 2,
// licensed under a MPL/GPL/LGPL three license - see LICENSE.md
unit test.core.base;

interface

{$I ..\src\mormot.defines.inc}

uses
  sysutils,
  classes,
  math,
  mormot.core.base,
  mormot.core.os,
  mormot.core.os.security,
  mormot.core.unicode,
  mormot.core.text,
  mormot.core.datetime,
  mormot.core.rtti,
  mormot.core.buffers,
  mormot.core.data,
  mormot.core.json,
  mormot.core.variants,
  mormot.core.fmt,
  mormot.crypt.core,
  mormot.crypt.secure,
  mormot.crypt.ecc,
  mormot.core.perf,
  mormot.core.search,
  mormot.core.log,
  mormot.core.test,
  mormot.core.threads,
  mormot.net.sock,
  mormot.net.http,
  mormot.net.client,
  mormot.db.core,
  mormot.orm.base,
  mormot.orm.core,
  mormot.rest.core,
  mormot.rest.client;

const
  HTTP_DEFAULTPORT = '8888'; // under Linux/Wine port<1024 needs root user


{$ifdef FPC_EXTRECORDRTTI}
  {$rtti explicit fields([vcPublic])} // mantadory :(
{$endif FPC_EXTRECORDRTTI}

type
  /// a test class, used by TTestServiceOrientedArchitecture
  // - also validates TPersistent objects as parameters for remote service calls
  TComplexNumber = class(TPersistent)
  private
    fReal: Double;
    fImaginary: Double;
  public
    /// create an instance to store a complex number
    constructor Create(aReal, aImaginary: double); reintroduce;
  published
    /// the real part of this complex number
    property Real: Double
      read fReal write fReal;
    /// the imaginary part of this complex number
    property Imaginary: Double
      read fImaginary write fImaginary;
  end;

  TComplexNumberObjArray = array of TComplexNumber;

  /// a record mapping TOrmPeople content
  TRecordPeople = packed record
    RowID: TID;
    FirstName: RawUtf8;
    LastName: RawUtf8;
    Data: RawBlob;
    YearOfBirth: integer;
    YearOfDeath: word;
  end;
  TRecordPeopleDynArray = array of TRecordPeople;

  // a record mapping used in the test classes of the framework
  // - this class can be used for debugging purposes, with the database
  // created by TTestFileBased from test.orm.sqlite3
  // - this class will use 'People' as a table name
  TOrmPeople = class(TOrm)
  private
    fData: RawBlob;
    fFirstName: RawUtf8;
    fLastName: RawUtf8;
    fYearOfBirth: integer;
    fYearOfDeath: word;
  published
    property FirstName: RawUtf8
      read fFirstName write fFirstName;
    property LastName: RawUtf8
      read fLastName write fLastName;
    property Data: RawBlob
      read fData write fData;
    property YearOfBirth: integer
      read fYearOfBirth write fYearOfBirth;
    property YearOfDeath: word
      read fYearOfDeath write fYearOfDeath;
  public
    /// method used to test the Client-Side
    // ModelRoot/TableName/ID/MethodName RESTful request, i.e.
    // ModelRoot/People/ID/DataAsHex in this case
    // - this method calls the supplied TRestClient to retrieve its results,
    // with the ID taken from the current TOrmPeole instance ID field
    // - parameters and result types depends on the purpose of the function
    // - TRestServerTest.DataAsHex published method implements the result
    // calculation on the Server-Side
    function DataAsHex(aClient: TRestClientUri): RawUtf8;
    /// method used to test the Client-Side
    // ModelRoot/MethodName RESTful request, i.e. ModelRoot/Sum in this case
    // - this method calls the supplied TRestClient to retrieve its results
    // - parameters and result types depends on the purpose of the function
    // - TRestServerTest.Sum published method implements the result calculation
    // on the Server-Side
    // - this method doesn't expect any ID to be supplied, therefore will be
    // called as class function - normally, it should be implement in a
    // TRestClient descendant, and not as a TOrm, since it does't depend
    // on TOrmPeople at all
    // - you could also call the same servce from the ModelRoot/People/ID/Sum URL,
    // but it won't make any difference)
    class function Sum(aClient: TRestClientUri; a, b: double; Method2: boolean): double;
  end;
  TOrmPeopleObjArray = array of TOrmPeople;
  POrmPeople = ^TOrmPeople;

  TOrmPeopleTimed = class(TOrmPeople)
  private
    fModif: TModTime;
  published
    property Modif: TModTime
      read fModif write fModif;
  end;

  /// a record used to test dynamic array serialization
  TFV = packed record
    Major, Minor, Release, Build: integer;
    Main, Detailed: string;
    BuildDateTime: TDateTime;
    BuildYear: integer;
  end;
  PFV = ^TFV;
  TFVs = array of TFV;

  TPersistentAutoCreateFieldsTest = class(TPersistentAutoCreateFields)
  private
    fText: RawUtf8;
    fValue1: TComplexNumber;
    fValue2: TComplexNumber;
  public
    constructor CreateFake;
  published
    property Text: RawUtf8 read fText write fText;
    property Value1: TComplexNumber read fValue1;
    property Value2: TComplexNumber read fValue2;
  end;
  TPersistentAutoCreateFieldsTestObjArray = array of TPersistentAutoCreateFieldsTest;

  TObjArrayTest = class(TPersistentAutoCreateFieldsTest)
  private
    fValues: TComplexNumberObjArray;
  published
    property values: TComplexNumberObjArray read fValues write fValues;
  end;

  TOrmArrayTest = class(TOrm)
  private
    fValues: TComplexNumberObjArray;
  published
    property values: TComplexNumberObjArray read fValues write fValues;
  end;

// sorting function to order by StrIComp(TOrmPeople.FirstName)
function TOrmPeopleCompareByFirstName(const A, B): integer;


type
  /// regression tests for most basic mormot.core.* features
  TTestCoreBase = class(TSynTestCase)
  protected
    a: TOrmPeopleObjArray;
    fAdd, fDel: RawUtf8;
    fQuickSelectValues: TIntegerDynArray;
    rnd: PLecuyer;
    HasValidUtf8Avx2: boolean;
    procedure Setup; override;
    function QuickSelectGT(IndexA, IndexB: PtrInt): boolean;
    procedure intadd(const Sender; Value: integer);
    procedure intdel(const Sender; Value: integer);
    /// validate our optimized MoveFast/FillCharFast functions
    procedure CustomRTLSlow(Sender: TObject);
    /// low level fast Integer or Floating-Point to/from string conversion
    // - especially the RawUtf8 or PUtf8Char relative versions
    procedure NumericalConversionsSlow(Sender: TObject);
    // methods below are run in the background from _TDynArray startup
    /// test the TDynArrayHashed object and methods (dictionary features)
    // - this test will create an array of 200,000 items to test speed
    procedure TDynArrayHashedSlow(Context: TObject);
    /// test the TSynDictionary class
    procedure TSynDictionarySlow(Context: TObject);
    /// test UTF-8 and Win-Ansi conversion (from or to, through RawUnicode)
    procedure Utf8Slow(Context: TObject);
    /// test the TSynTimeZone class and its cross-platform local time process
    procedure TimeZonesSlow(Context: TObject);
    /// test the TRawUtf8List class
    procedure TRawUtf8ListSlow(Context: TObject);
    /// test the TPipeStream class
    procedure TStreamSlow(Context: TObject);
    /// client side geniune 64 bit identifiers generation
    procedure TSynUniqueIdentifierSlow(Sender: TObject);
  published
    /// test RecordCopy(), TRttiMap and TRttiFilter
    procedure _Records;
    /// test the TSynList class
    procedure _TSynList;
    /// test the TDynArray object and methods - also launch background *Slow()
    procedure _TDynArray;
    /// test TSynNameValue class
    procedure _TSynNameValue;
    /// test TRawUtf8Interning process
    procedure _TRawUtf8Interning;
    {$ifdef FPC_X64MM}
    /// validate the FPC x86_64 memory manager allocation capacity
    procedure _fpcx64mm;
    {$endif FPC_X64MM}
    /// test T*ObjArray types and the ObjArray*() wrappers
    procedure _TObjArray;
    /// test StrIComp() and AnsiIComp() functions
    procedure FastStringCompare;
    /// test IdemPropName() and IdemPropNameU() functions
    procedure _IdemPropName;
    /// test our internal fast TGUID process functions
    procedure _GUID;
    /// test ParseCommandArgs() functions
    procedure _ParseCommandArgs;
    /// test TExecutableCommandLine class
    procedure _TExecutableCommandLine;
    /// test IsMatch() function
    procedure _IsMatch;
    /// test TExprParserMatch class
    procedure _TExprParserMatch;
    /// the Soundex search feature (i.e. TSynSoundex and all related
    // functions)
    procedure Soundex;
    /// test low-level integer/Int64 functions
    procedure Integers;
    /// test crc32c in both software and hardware (SSE4.2) implementations
    procedure _crc32c;
    /// test RDRAND Intel x86/x64 opcode if available, or fast gsl_rng_taus2
    procedure _Random32;
    /// test TSynBloomFilter class
    procedure BloomFilters;
    /// test DeltaCompress/DeltaExtract functions
    procedure DeltaCompression;
    /// the new fast Currency to/from string conversion
    procedure Curr64;
    /// the camel-case / camel-uncase features, used for i18n from Delphi RTII
    procedure _CamelCase;
    /// the low-level bit management functions
    procedure Bits;
    /// the fast .ini file content direct access
    procedure IniFiles;
    /// validate Unicode / Ansi Charset conversion methods
    procedure Charsets;
    /// test UrlEncode() and UrlDecode() functions
    // - this method use some ISO-8601 encoded dates and times for the testing
    procedure UrlDecoding;
    /// test mime types recognition
    procedure MimeTypes;
    /// test multipart/formdata encoding and incremental decoding
    procedure MultiPartDecoder;
    /// test ASCII Baudot encoding
    procedure BaudotCode;
    /// the ISO-8601 date and time encoding
    // - test especially the conversion to/from text
    procedure Iso8601DateAndTime;
    /// test the SMBIOS decoding features
    procedure DmiSmbios;
    /// test Security IDentifier (SID) process
    procedure _SID;
    /// test OS errors support
    procedure OsErrors;
    /// test the SecurityDescriptor / SDDL process
    procedure _SDDL;
    /// validates the median computation using the "Quick Select" algorithm
    procedure QuickSelect;
    /// test the TSynCache class
    procedure _TSynCache;
    /// low-level TSynFilter classes
    procedure _TSynFilter;
    /// low-level TSynValidate classes
    procedure _TSynValidate;
    /// low-level TSynLogFile class and OS detection
    procedure Debugging;
    {$ifdef OSWINDOWS}
    /// some Windows-specific tests
    procedure WindowsSpecificApi;
    {$endif OSWINDOWS}
  end;



implementation


{ TOrmPeople }

function TOrmPeople.DataAsHex(aClient: TRestClientUri): RawUtf8;
begin
  result := aClient.CallBackGetResult('DataAsHex', [], RecordClass, fID);
end;

class function TOrmPeople.Sum(aClient: TRestClientUri; a, b: double;
  Method2: boolean): double;
var
  err: integer;
const
  METHOD: array[boolean] of RawUtf8 = ('sum', 'sum2');
begin
  result := GetExtended(pointer(
    aClient.CallBackGetResult(METHOD[Method2], ['a', a, 'b', b])), err);
end;


{ TComplexNumber }

constructor TComplexNumber.Create(aReal, aImaginary: double);
begin
  Real := aReal;
  Imaginary := aImaginary;
end;


{ TPersistentAutoCreateFieldsTest }

constructor TPersistentAutoCreateFieldsTest.CreateFake;
begin
  inherited Create;
  text := 'text';
  Value1.Real := 1.5;
  Value1.Imaginary := 2.5;
  Value2.Real := 1.7;
  Value2.Imaginary := 2.7;
end;


{ TTestCoreBase }

procedure TTestCoreBase.Setup;
begin
  rnd := ThreadRandom; // reference to the main thread generator
end;

{$ifdef FPC_X64MM}

procedure TTestCoreBase._fpcx64mm;
const
  Sizes: array[0 .. 13] of PtrUInt = (
    264744, 264745,
    327640, 327641, 327642,
    655320, 655321, 655322,
    4194264, 4194265, 4194266,
    6291416, 6291417, 6291418);
var
  i: PtrInt;
  p: pointer;
begin
  for i := 0 to high(Sizes) do
  begin
    p := GetMem(Sizes[i]);
    try
      Check(MemSize(p) >= Sizes[i], 'MemSize');
    finally
      FreeMem(p);
    end;
  end;
end;

{$endif FPC_X64MM}

procedure TTestCoreBase._CamelCase;
var
  v, v2, all: RawUtf8;
  k: TSetCase;
begin
  CheckEqual(UnCamelCase(''), '');
  v := UnCamelCase('On');
  CheckEqual(v, 'On');
  v := UnCamelCase('ON');
  CheckEqual(v, 'ON');
  v := UnCamelCase('OnLine');
  CheckEqual(v, 'On line');
  v := UnCamelCase('OnLINE');
  CheckEqual(v, 'On LINE');
  v := UnCamelCase('OnMyLINE');
  CheckEqual(v, 'On my LINE');
  v := UnCamelCase('On_MyLINE');
  CheckEqual(v, 'On - My LINE');
  v := UnCamelCase('On__MyLINE');
  CheckEqual(v, 'On: My LINE');
  v := UnCamelCase('Email1');
  CheckEqual(v, 'Email 1');
  v := UnCamelCase('Email12');
  CheckEqual(v, 'Email 12');
  v := UnCamelCase('KLMFlightNumber');
  CheckEqual(v, 'KLM flight number');
  v := UnCamelCase('GoodBBCProgram');
  CheckEqual(v, 'Good BBC program');
  CheckEqual(CamelCase(''), '');
  CheckEqual(CamelCase('a'), 'a');
  CheckEqual(CamelCase('A'), 'A');
  CheckEqual(CamelCase('abc'), 'abc');
  CheckEqual(CamelCase('Abc'), 'Abc');
  CheckEqual(CamelCase('AbcDef'), 'AbcDef');
  CheckEqual(CamelCase('Abc_Def'), 'AbcDef');
  CheckEqual(CamelCase('AbcDef_'), 'AbcDef');
  CheckEqual(CamelCase('Abc__Def'), 'AbcDef');
  CheckEqual(CamelCase('AbcDef__'), 'AbcDef');
  CheckEqual(CamelCase('Abc__Def__'), 'AbcDef');
  CheckEqual(CamelCase('variable name'), 'variableName');
  CheckEqual(CamelCase('Variable Name'), 'VariableName');
  CheckEqual(CamelCase('Variable: Name'), 'VariableName');
  CheckEqual(CamelCase('VARIABLE NAME'), 'VARIABLENAME');
  CheckEqual(CamelCase('VariableName'), 'VariableName');
  CheckEqual(LowerCamelCase(''), '');
  CheckEqual(LowerCamelCase('a'), 'a');
  CheckEqual(LowerCamelCase('A'), 'a');
  CheckEqual(LowerCamelCase('abc'), 'abc');
  CheckEqual(LowerCamelCase('Abc'), 'abc');
  CheckEqual(LowerCamelCase('AbcDef'), 'abcDef');
  CheckEqual(LowerCamelCase('Abc_Def'), 'abcDef');
  CheckEqual(LowerCamelCase('AbcDef_'), 'abcDef');
  CheckEqual(LowerCamelCase('Abc__Def'), 'abcDef');
  CheckEqual(LowerCamelCase('AbcDef__'), 'abcDef');
  CheckEqual(LowerCamelCase('Abc__Def__'), 'abcDef');
  CheckEqual(LowerCamelCase('variable name'), 'variableName');
  CheckEqual(LowerCamelCase('Variable Name'), 'variableName');
  CheckEqual(LowerCamelCase('Variable: Name'), 'variableName');
  CheckEqual(LowerCamelCase('VARIABLE NAME'), 'variablename');
  CheckEqual(LowerCamelCase('VariableName'), 'variableName');
  CheckEqual(SnakeCase(''), '');
  CheckEqual(SnakeCase('a'), 'a');
  CheckEqual(SnakeCase('A'), 'a');
  CheckEqual(SnakeCase('abc'), 'abc');
  CheckEqual(SnakeCase('Abc'), 'abc');
  CheckEqual(SnakeCase('AbcDef'), 'abc_def');
  CheckEqual(SnakeCase('Abc_Def'), 'abc_def');
  CheckEqual(SnakeCase('AbcDef_'), 'abc_def_');
  CheckEqual(SnakeCase('Abc__Def'), 'abc_def');
  CheckEqual(SnakeCase('Abc__Def', '-'), 'abc-def');
  CheckEqual(SnakeCase('AbcDef__'), 'abc_def_');
  CheckEqual(SnakeCase('Abc__Def__'), 'abc_def_');
  CheckEqual(SnakeCase('Abc12Def'), 'abc_12_def');
  CheckEqual(SnakeCase('X64Def', '-'), 'x64-def');
  CheckEqual(SnakeCase('XY64Def', '-'), 'xy-64-def');
  CheckEqual(SnakeCase('column1', '-'), 'column-1');
  CheckEqual(SnakeCase('column100', '-'), 'column-100');
  CheckEqual(SnakeCase('Column 1', '-'), 'column-1');
  CheckEqual(SnakeCase('variable name'), 'variable_name');
  CheckEqual(SnakeCase('Variable Name'), 'variable_name');
  CheckEqual(SnakeCase('VARIABLE NAME'), 'variable_name');
  CheckEqual(SnakeCase('VariableName'), 'variable_name');
  v := 'Something';
  TitleCaseSelf(v);
  CheckEqual(v, 'Something');
  v := 'something';
  TitleCaseSelf(v);
  CheckEqual(v, 'Something');
  v := 'Some title';
  TitleCaseSelf(v);
  CheckEqual(v, 'Some Title');
  v := 'some title';
  TitleCaseSelf(v);
  CheckEqual(v, 'Some Title');
  for k := low(k) to high(k) do
  begin
    v := GetEnumNameTrimed(TypeInfo(TSetCase), ord(k));
    v2 := SetCase(v, k);
    CheckUtf8((v = v2) = (k in [scNoTrim, scTrimLeft, scPascalCase, scTitleCase]), v);
    v := SetCase(v, k);
    CheckEqual(v, v2, 'SetCase(self)');
    Append(all, v, ',');
  end;
  CheckEqual(all, 'NoTrim,TrimLeft,AnyRemoved,Un camel case,Un Camel Title,' +
    'lowercase,lower-case,lowerCaseFirst,UPPERCASE,snake_case,SCREAMING_SNAKE_CASE,' +
    'kebab-case,dot.case,TitleCase,camelCase,PascalCase,');
end;

function GetBitsCount64(const Bits; Count: PtrInt): PtrInt;
begin
  // reference implementation
  result := 0;
  while Count > 0 do
  begin
    dec(Count);
    if Count in TBits64(Bits) then // bt dword[rdi],edx is slow in such a loop
      inc(result);                 // ... but simple and correct :)
  end;
end;

function GetBitsCountPurePascal(value: PtrInt): PtrInt;
begin
  result := value;
  {$ifdef CPU64}
  result := result - ((result shr 1) and $5555555555555555);
  result := (result and $3333333333333333) +
            ((result shr 2) and $3333333333333333);
  result := (result + (result shr 4)) and $0f0f0f0f0f0f0f0f;
  inc(result, result shr 8); // avoid slow multiplication
  inc(result, result shr 16);
  inc(result, result shr 32);
  result := result and $7f;
  {$else}
  result := result - ((result shr 1) and $55555555);
  result := (result and $33333333) + ((result shr 2) and $33333333);
  result := (result + (result shr 4)) and $0f0f0f0f;
  inc(result, result shr 8);
  inc(result, result shr 16);
  result := result and $3f;
  {$endif CPU64}
end;

function BSRdwordPurePascal(c: cardinal): cardinal;
const
  _debruijn32: array[0..31] of byte = (
    0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
    8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31);
begin // http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn
  if c <> 0 then
  begin
    c := c or (c shr 1);
    c := c or (c shr 2);
    c := c or (c shr 4);
    c := c or (c shr 8);
    c := c or (c shr 16);
    c := c * $07c4acdd; // explicit step for 32-bit truncation
    result := _debruijn32[c shr 27];
  end
  else
    result := 255;
end;

function BSRqwordPurePascal(const q: Qword): cardinal;
var
  c: cardinal;
begin
  c := q shr 32;
  if c = 0  then
    result := BsrDwordPurePascal(cardinal(q)) // search in lowest 32-bit
  else
    result := BsrDwordPurePascal(c) or 32;   // search in highest 32-bit
end;

function BsfDWordPurePascal(c: cardinal): cardinal; // not published yet
const
  _debruijn32: array[0..31] of byte = (
    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9);
begin
  if c <> 0 then
  begin
    c := c and not (c - 1); // isolate lowest set bit
    c := c * $077cb531;     // truncate to 32 bits
    result := _debruijn32[c shr 27];
  end
  else
    result := 255;
end;

procedure TTestCoreBase.Bits;
const
  N = 1000000;

  procedure TestPopCnt(const ctxt: string);
  var
    timer: TPrecisionTimer;
    i, c: integer;
    v: QWord;
  begin
    CheckEqual(GetBitsCountPtrInt(0), 0);
    CheckEqual(GetBitsCountPtrInt(2), 1);
    CheckEqual(GetBitsCountPtrInt(7), 3);
    CheckEqual(GetBitsCountPtrInt($f), 4);
    CheckEqual(GetBitsCountPtrInt($ff), 8);
    CheckEqual(GetBitsCountPtrInt($fff), 12);
    CheckEqual(GetBitsCountPtrInt($ffff), 16);
    CheckEqual(GetBitsCountPtrInt(-1), POINTERBITS);
    v := 0;
    for i := 0 to 63 do
    begin
      Check(not GetBit(v, i));
      Check(not GetBitPtr(@v, i));
    end;
    v := QWord(-1);
    for i := 0 to 63 do
    begin
      Check(GetBit(v, i));
      Check(GetBitPtr(@v, i));
    end;
    CheckEqual(GetBitsCount(v, 0), 0);
    CheckEqual(GetBitsCount64(v, 0), 0);
    for i := 0 to POINTERBITS - 1 do
    begin
      CheckEqual(GetBitsCountPtrInt(PtrInt(1) shl i), 1);
      if i < POINTERBITS - 1 then
      begin
        CheckEqual(GetBitsCountPtrInt(PtrInt(3) shl i), 2);
        CheckEqual(GetBitsCountPtrInt((PtrInt(1) shl (i + 1)) - 1), i + 1);
      end;
      if i < POINTERBITS - 2 then
        CheckEqual(GetBitsCountPtrInt(PtrInt(7) shl i), 3);
      if i < POINTERBITS - 3 then
        CheckEqual(GetBitsCountPtrInt(PtrInt(15) shl i), 4);
      CheckEqual(GetBitsCount64(v, i + 1), i + 1);
      CheckEqual(GetBitsCount(v, i + 1), i + 1);
    end;
    for i := 1 to 32 do
    begin
      v := ALLBITS_CARDINAL[i];
      CheckEqual(GetBitsCountPtrInt(v), i);
      CheckEqual(GetBitsCount(v, POINTERBITS), i);
      CheckEqual(GetBitsCount(v, i), i);
    end;
    for i := 1 to 1000 do
    begin
      v := i;
      c := GetBitsCount64(v, POINTERBITS);
      CheckEqual(GetBitsCountPtrInt(v), c);
      CheckEqual(GetBitsCount(v, POINTERBITS), c);
      {$ifdef FPC}
      CheckEqual(popcnt(v), c);
      {$endif FPC}
      c := BSRdwordPurePascal(v);
      CheckEqual(c, BSRdword(v));
      CheckEqual(c, BSRqword(v), 'bsrq1');
      v := v * v * 19;
      CheckEqual(BSRdwordPurePascal(v), BSRdword(v));
      c := GetBitsCount64(v, POINTERBITS);
      CheckEqual(GetBitsCountPtrInt(v), c);
      {$ifdef FPC}
      CheckEqual(popcnt(v), c);
      {$endif FPC}
      v := rnd.Next;
      c := BSRdwordPurePascal(v);
      CheckEqual(c, BSRdword(v));
      CheckEqual(c, BSRqword(v), 'bsrq2');
      {$ifdef CPU64}
      v := v or (PtrUInt(rnd.Next) shl 32);
      {$endif CPU64}
      c := GetBitsCount64(v, POINTERBITS);
      CheckEqual(GetBitsCountPtrInt(v), c);
      CheckEqual(GetBitsCount(v, POINTERBITS), c);
      {$ifdef FPC}
      CheckEqual(popcnt(v), c);
      {$endif FPC}
      {$ifdef CPU32}
      v := v or (QWord(rnd.Next) shl 32);
      {$endif CPU32}
      CheckEqual(BSRqwordPurePascal(v), BSRqword(v), 'bsrq3');
    end;
    CheckEqual(BSRdwordPurePascal(0), BSRdword(0));
    CheckEqual(BSRqwordPurePascal(0), BSRqword(0));
    CheckEqual(BSRdword(0), 255);
    CheckEqual(BSRqword(0), 255);
    for i := 1 to 15 do
    begin
      v := i;
      repeat
        CheckEqual(BSRdwordPurePascal(v), BSRdword(v), 'bsrdi');
        CheckEqual(BSRqwordPurePascal(v), BSRqword(v), 'bsrqi');
        v := v shl 1;
      until v = 0; // all 64-bit
    end;
    timer.Start;
    for i := 1 to N do
      GetBitsCountPtrInt(i);
    NotifyTestSpeed(ctxt, N, N shl POINTERSHR, @timer, {onlylog=}true);
  end;

var
  gen, ref: TLecuyer;
  Bits: TByteToByte;
  Bits64: Int64 absolute Bits;
  Si, i: integer;
  c: cardinal;
  {$ifdef FPC}
  u: PtrUInt;
  timer: TPrecisionTimer;
  {$endif FPC}
begin
  {$ifdef ASMINTEL}
  GetBitsCountPtrInt := @GetBitsCountPurePascal;
  TestPopCnt('pas');
  GetBitsCountPtrInt := @GetBitsCountPas; // x86/x86_64 assembly
  TestPopCnt('asm');
  if cfPOPCNT in CpuFeatures then
  begin
    GetBitsCountPtrInt := @GetBitsCountSSE42;
    TestPopCnt('sse4.2');
  end;
  {$else}
  TestPopCnt('pas');
  {$endif ASMINTEL}
  {$ifdef FPC}
  timer.Start;
  for u := 1 to N do
    i := popcnt(u);
  NotifyTestSpeed('FPC', N, N shl POINTERSHR, @timer, {onlylog=}true);
  {$endif FPC}
  FillcharFast(Bits, SizeOf(Bits), 0);
  for i := 0 to high(Bits) * 8 + 7 do
  begin
    Check(not GetBit(Bits, i));
    Check(not GetBitPtr(@Bits, i));
  end;
  ref.SeedGenerator(0); // will reproduce the same gen.Next values
  gen := ref;
  for i := 1 to 100 do
  begin
    Si := gen.Next(SizeOf(Bits) shl 3);
    SetBit(Bits, Si);
    Check(GetBit(Bits, Si));
    Check(GetBitPtr(@Bits, Si));
  end;
  gen.SeedGenerator(0); // rewind
  for i := 1 to 100 do
    Check(GetBit(Bits, gen.Next(SizeOf(Bits) shl 3)));
  gen := ref; // rewind
  for i := 1 to 100 do
  begin
    Si := gen.Next(SizeOf(Bits) shl 3);
    UnSetBit(Bits, Si);
    Check(not GetBit(Bits, Si));
    Check(not GetBitPtr(@Bits, Si));
  end;
  Check(IsZero(@Bits, SizeOf(Bits)));
  for i := 0 to high(Bits) * 8 + 7 do
    Check(not GetBit(Bits, i));
  for i := 0 to 63 do
    Check(not GetBit64(Bits64, i));
  gen.SeedGenerator(0);
  for i := 1 to 30 do
  begin
    Si := gen.Next(64);
    SetBit64(Bits64, Si);
    Check(GetBit64(Bits64, Si));
  end;
  gen := ref;
  for i := 1 to 30 do
    Check(GetBit64(Bits64, gen.Next(64)));
  gen := ref;
  for i := 1 to 30 do
  begin
    Si := gen.Next(64);
    UnSetBit64(Bits64, Si);
    Check(not GetBit64(Bits64, Si));
  end;
  Check(IsZero(@Bits, SizeOf(Bits)));
  for i := 0 to 63 do
    Check(not GetBit64(Bits64, i));
  c := 1;
  for i := 1 to 32 do
  begin
    Check(GetAllBits($ffffffff, i));
    Check(not GetAllBits(0, i));
    Check(GetAllBits(c, i));
    Check(not GetAllBits(c and  - 2, i));
    Check(GetAllBits(ALLBITS_CARDINAL[i], i));
    c := c or (1 shl i);
  end;
end;

procedure TTestCoreBase.Curr64;
var
  tmp: string[63];
  i, err: Integer;
  V1: currency;
  V2: TSynExtended;
  i64: Int64;
  v: RawUtf8;
begin
  Check(TruncTo2Digits(1) = 1);
  Check(TruncTo2Digits(1.05) = 1.05);
  Check(TruncTo2Digits(1.051) = 1.05);
  Check(TruncTo2Digits(1.0599) = 1.05);
  Check(TruncTo2Digits(-1) = -1);
  Check(TruncTo2Digits(-1.05) = -1.05);
  Check(TruncTo2Digits(-1.051) = -1.05);
  Check(TruncTo2Digits(-1.0599) = -1.05);
  Check(SimpleRoundTo2Digits(1) = 1);
  Check(SimpleRoundTo2Digits(1.05) = 1.05);
  Check(SimpleRoundTo2Digits(1.051) = 1.05);
  Check(SimpleRoundTo2Digits(1.0549) = 1.05);
  Check(SimpleRoundTo2Digits(1.0550) = 1.05);
  Check(SimpleRoundTo2Digits(1.0551) = 1.06);
  Check(SimpleRoundTo2Digits(1.0599) = 1.06);
  Check(SimpleRoundTo2Digits(-1) = -1);
  Check(SimpleRoundTo2Digits(-1.05) = -1.05);
  Check(SimpleRoundTo2Digits(-1.051) = -1.05);
  Check(SimpleRoundTo2Digits(-1.0549) = -1.05);
  Check(SimpleRoundTo2Digits(-1.0550) = -1.05);
  Check(SimpleRoundTo2Digits(-1.0551) = -1.06);
  Check(SimpleRoundTo2Digits(-1.0599) = -1.06);
  Check(StrToCurr64('.5') = 5000);
  Check(StrToCurr64('.05') = 500);
  Check(StrToCurr64('.005') = 50);
  Check(StrToCurr64('.0005') = 5);
  Check(StrToCurr64('.00005') = 0);
  Check(StrToCurr64('0.5') = 5000);
  Check(StrToCurr64('0.05') = 500);
  Check(StrToCurr64('0.005') = 50);
  Check(StrToCurr64('0.0005') = 5);
  Check(StrToCurr64('0.00005') = 0);
  Check(StrToCurr64('1.5') = 15000);
  Check(StrToCurr64('1.05') = 10500);
  Check(StrToCurr64('1.005') = 10050);
  Check(StrToCurr64('1.0005') = 10005);
  Check(StrToCurr64('1.00005') = 10000);
  Check(StrToCurr64(pointer(Curr64ToStr(1))) = 1);
  Check(StrToCurr64(pointer(Curr64ToStr(12))) = 12);
  Check(StrToCurr64(pointer(Curr64ToStr(123))) = 123);
  Check(StrToCurr64(pointer(Curr64ToStr(1234))) = 1234);
  Check(StrToCurr64(pointer(Curr64ToStr(12345))) = 12345);
  Check(StrToCurr64(pointer(Curr64ToStr(123456))) = 123456);
  Check(StrToCurr64(pointer(Curr64ToStr(12340000))) = 12340000);
  Check(StrToCurr64(pointer(Curr64ToStr(12345000))) = 12345000);
  Check(StrToCurr64(pointer(Curr64ToStr(12345600))) = 12345600);
  Check(StrToCurr64(pointer(Curr64ToStr(12345670))) = 12345670);
  Check(StrToCurr64(pointer(Curr64ToStr(12345678))) = 12345678);
  tmp[0] := AnsiChar(Curr64ToPChar(1, @tmp[1]));
  Check(tmp = '0.0001');
  tmp[0] := AnsiChar(Curr64ToPChar(12, @tmp[1]));
  Check(tmp = '0.0012');
  tmp[0] := AnsiChar(Curr64ToPChar(123, @tmp[1]));
  Check(tmp = '0.0123');
  tmp[0] := AnsiChar(Curr64ToPChar(1234, @tmp[1]));
  Check(tmp = '0.1234');
  for i := 0 to 5000 do
  begin
    if i < 500 then
      V1 := i * 3
    else
      V1 := rnd.NextQWord shr 28;
    if rnd.Next and 3 = 0 then
      V1 := -V1;
    v := Curr64ToStr(PInt64(@V1)^);
    tmp[0] := AnsiChar(Curr64ToPChar(PInt64(@V1)^, @tmp[1]));
    CheckEqual(RawUtf8(tmp), v);
    V2 := GetExtended(pointer(v), err);
    Check(err = 0);
    CheckSame(V1, V2, 1E-4);
    i64 := StrToCurr64(pointer(v));
    CheckEqual(PInt64(@V1)^, i64);
  end;
end;

procedure TTestCoreBase.FastStringCompare;

  procedure _HasAnyChar(const text, forbidden: RawUtf8; expected: boolean = true);
  var
    any: TSynAnsicharSet;
    i: PtrInt;
  begin
    Check(ContainsChars(text, forbidden) = expected);
    any := [];
    for i := 1 to length(forbidden) do
      include(any, forbidden[i]);
    Check(HasAnyChar(text, any) = expected);
  end;

  function _StrIEqualW(p1, p2: PWideChar): boolean; // for Delphi 7-2027
  begin
    result := StrIEqualW(pointer(p1), pointer(p2));
  end;

var
  fn: TFileName;
begin
  CheckEqual(CompareText('', ''), 0);
  Check(CompareText('abcd', '') > 0);
  Check(CompareText('', 'abcd') < 0);
  CheckEqual(StrIComp(nil, nil), 0);
  Check(StrIEqual(nil, nil));
  CheckEqual(StrIComp(PAnsiChar('abcD'), nil), 1);
  CheckEqual(StrIComp(nil, PAnsiChar('ABcd')), -1);
  CheckEqual(StrIComp(PAnsiChar('abcD'), PAnsiChar('ABcd')), 0);
  Check(StrIEqual(nil, nil));
  Check(StrIEqual(PAnsiChar('abcD'), PAnsiChar('ABcd')));
  Check(not StrIEqual(PAnsiChar('abcD'), PAnsiChar('ABc')));
  Check(not StrIEqual(PAnsiChar('abcD'), PAnsiChar('ABce')));
  Check(not StrIEqual(PAnsiChar('abcD'), PAnsiChar('ABcde')));
  Check(not StrIEqual(nil, PAnsiChar('test')));
  Check(not StrIEqual(PAnsiChar('test'), nil));
  Check(StrIEqual(PAnsiChar('Test'), PAnsiChar('test')));
  Check(not StrIEqual(PAnsiChar('abc'), PAnsiChar('xyz')));
  Check(_StrIEqualW('abcD', 'ABcd'));
  Check(not _StrIEqualW('abcD', 'ABc'));
  Check(not _StrIEqualW('abcD', 'ABce'));
  Check(not _StrIEqualW('abcD', 'ABcde'));
  Check(_StrIEqualW(nil, nil));
  Check(not _StrIEqualW(nil, 'test'));
  Check(not _StrIEqualW('test', nil));
  Check(_StrIEqualW('Test', 'test'));
  Check(not _StrIEqualW('abc', 'xyz'));
  Check(SameTextS('', ''));
  Check(SameTextS('a', 'a'));
  Check(SameTextS('a', 'A'));
  Check(SameTextS('ab', 'Ab'));
  Check(SameTextS('aBC', 'AbC'));
  Check(not SameTextS('aBC', 'Ab'));
  Check(not SameTextS('aBC', 'Abd'));
  Check(not SameTextS('aBC', 'Abcd'));
  Check(StrIComp(PAnsiChar('abcD'), PAnsiChar('ABcF')) =
    StrComp(PAnsiChar('ABCD'), PAnsiChar('ABCF')));
  CheckEqual(StrComp(PAnsiChar('abcD'), nil), 1, 'abcD');
  CheckEqual(StrComp(nil, PAnsiChar('ABcd')), -1, 'nil ABCd');
  CheckEqual(StrComp(nil, nil), 0, 'nil nil');
  CheckEqual(StrComp(PAnsiChar('ABCD'), PAnsiChar('ABCD')), 0, 'ABCD');
  CheckEqual(StrComp(PAnsiChar('ABCD'), PAnsiChar('ABCE')), -1, 'ABCDE');
  CheckEqual(StrComp(PAnsiChar('ABCD'), PAnsiChar('ABCC')), 1, 'ABCC');
  CheckEqual(AnsiIComp(pointer(PAnsiChar('abcD')), pointer(PAnsiChar('ABcd'))), 0);
  Check(AnsiIComp(pointer(PAnsiChar('abcD')), pointer(PAnsiChar('ABcF'))) =
    StrComp(PAnsiChar('ABCD'), PAnsiChar('ABCF')));
  Check(StrIComp(PAnsiChar('abcD'), PAnsiChar('ABcd')) =
    AnsiIComp(PAnsiChar('abcD'), PAnsiChar('ABcd')));
  Check(StrIComp(PAnsiChar('abcD'), PAnsiChar('ABcF')) =
    AnsiIComp(PAnsiChar('ABCD'), PAnsiChar('ABCF')));
  CheckEqual(strcspn(PAnsiChar('ab'), PAnsiChar('a'#0)), 0);
  CheckEqual(strcspn(PAnsiChar('ab'), PAnsiChar('b'#0)), 1);
  CheckEqual(strcspn(PAnsiChar('1234ab'), PAnsiChar('a'#0)), 4);
  CheckEqual(strcspn(PAnsiChar('12345ab'), PAnsiChar('a'#0)), 5);
  CheckEqual(strcspn(PAnsiChar('123456ab'), PAnsiChar('a'#0)), 6);
  CheckEqual(strcspn(PAnsiChar('1234567ab'), PAnsiChar('a'#0)), 7);
  CheckEqual(strcspn(PAnsiChar('12345678ab'), PAnsiChar('a'#0)), 8);
  CheckEqual(strcspn(PAnsiChar('1234ab'), PAnsiChar('c'#0)), 6);
  CheckEqual(strcspn(PAnsiChar('12345678901234567ab'),
    PAnsiChar('cccccccccccccccccccd')), 19);
  CheckEqual(strspn(PAnsiChar('abcdef'), PAnsiChar('debca')), 5);
  CheckEqual(strspn(PAnsiChar('baabbaabcd'), PAnsiChar('ab')), 8);
  CheckEqual(strspn(PAnsiChar('abcdef'), PAnsiChar('g'#0)), 0);
  CheckEqual(strspn(PAnsiChar('abcdef'), PAnsiChar('a'#0)), 1);
  CheckEqual(strspn(PAnsiChar('bbcdef'), PAnsiChar('b'#0)), 2);
  CheckEqual(strspn(PAnsiChar('bbcdef'), PAnsiChar('bf')), 2);
  CheckEqual(strspn(PAnsiChar('bcbdef'), PAnsiChar('cb')), 3);
  CheckEqual(strspn(PAnsiChar('baabcd'), PAnsiChar('ab')), 4);
  CheckEqual(strspn(PAnsiChar('abcdef'), PAnsiChar('debca')), 5);
  CheckEqual(strspn(PAnsiChar('baabbaabcd'), PAnsiChar('ab')), 8);
  CheckEqual(strspn(PAnsiChar('baabbaabbaabcd'), PAnsiChar('ab')), 12);
  CheckEqual(strspn(PAnsiChar('baabbaabbaabbabcd'), PAnsiChar('ab')), 15);
  CheckEqual(strspn(PAnsiChar('baabbaabbaabbaabcd'), PAnsiChar('ab')), 16);
  CheckEqual(strspn(PAnsiChar('baabbaabbaababaabcd'), PAnsiChar('ab')), 17);
  _HasAnyChar('', '', false);
  _HasAnyChar('', 'a', false);
  _HasAnyChar('', 'aa', false);
  _HasAnyChar('a', '', false);
  _HasAnyChar('abcde', '', false);
  _HasAnyChar('abdef', 'cg', false);
  _HasAnyChar('a', 'c', false);
  _HasAnyChar('a', 'cd', false);
  _HasAnyChar('a', 'cdef', false);
  _HasAnyChar('a', 'cdefg', false);
  _HasAnyChar('a', 'cdefga');
  _HasAnyChar('abcde', 'a');
  _HasAnyChar('abcde', 'b');
  _HasAnyChar('abcde', 'c');
  _HasAnyChar('abcde', 'e');
  _HasAnyChar('abcde', 'ga');
  _HasAnyChar('abcde', 'gb');
  _HasAnyChar('abcde', 'gc');
  _HasAnyChar('abcde', 'ge');
  _HasAnyChar('abcde', 'ihga');
  _HasAnyChar('abcde', 'ihgb');
  _HasAnyChar('abcde', 'ihgc');
  _HasAnyChar('abcde', 'ihge');
  _HasAnyChar('abcde', 'jihga');
  _HasAnyChar('abcde', 'jihgb');
  _HasAnyChar('abcde', 'jihgc');
  _HasAnyChar('abcde', 'jihge');
  _HasAnyChar('abcde', 'jihgak');
  _HasAnyChar('abcde', 'jihgbk');
  _HasAnyChar('abcde', 'jihgck');
  _HasAnyChar('abcde', 'jihgek');
  Check(HasOnlyChar('abab', ['a' .. 'c']));
  Check(HasOnlyChar('abab', ['a' .. 'c']));
  Check(HasOnlyChar('abbab', ['a' .. 'c']));
  Check(HasOnlyChar('abab', ['a' .. 'b']));
  Check(not HasOnlyChar('abaeb', ['a' .. 'c']));
  Check(not HasOnlyChar('eabab', ['a' .. 'c']));
  Check(not HasOnlyChar('ababe', ['a' .. 'c']));
  Check(HasOnlyChar('ababe', ['a' .. 'e']));
  CheckEqual(GetFileNameWithoutExtOrPath(''), '');
  CheckEqual(GetFileNameWithoutExtOrPath('toto.ext'), 'toto');
  CheckEqual(GetFileNameWithoutExtOrPath('toto'), 'toto');
  {$ifdef OSWINDOWS}
  CheckEqual(GetFileNameWithoutExtOrPath('c:\temp\toto.ext'), 'toto');
  CheckEqual(GetFileNameWithoutExtOrPath('c:\temp\toto'), 'toto');
  {$else}
  CheckEqual(GetFileNameWithoutExtOrPath('/var/tmp/toto.ext'), 'toto');
  CheckEqual(GetFileNameWithoutExtOrPath('/var/tmp/toto'), 'toto');
  {$endif OSWINDOWS}
  fn := '/var/toto.ext';
  Check(EqualFileNameNotNull(fn, fn));
  Check(EqualFileNameNotNull(fn, '/var/toto.ext'));
  Check(not EqualFileNameNotNull(fn, '/var/toto.ex2'));
  Check(not EqualFileNameNotNull(fn, '/var/toto.ex'));
  Check(not EqualFileNameNotNull(fn, '/Var/toto.ext'));
end;

procedure TTestCoreBase.IniFiles;
var
  Content, S, N, V: RawUtf8;
  Si, Ni, Vi, i, j: integer;
  fs, fd, f2: TFileName;
  P: PUtf8Char;
const
  VUP: array[0..3] of PAnsiChar = ('VALUE', 'value', 'value2', nil);
begin
  Content := '';
  for i := 1 to 1000 do
  begin
    Si := rnd.Next(20);
    Ni := rnd.Next(50);
    Vi := Si * Ni + Ni;
    if Si = 0 then
      S := ''
    else
      S := 'Section' + Int32ToUtf8(Si);
    N := Int32ToUtf8(Ni);
    V := Int32ToUtf8(Vi);
    UpdateIniEntry(Content, S, N, V);
    for j := 1 to 5 do
      Check(FindIniEntry(Content, S, N) = V, 'FindIniEntry');
    Check(FindIniEntry(Content, S, 'no') = '');
    Check(FindIniEntry(Content, 'no', N) = '');
  end;
  fs := WorkDir + 'test.ini';
  fd := WorkDir + 'test.ini.synlz';
  f2 := WorkDir + 'test2.ini';
  Check(FileFromString(Content, fs), 'test.ini');
  Check(AlgoSynLZ.FileCompress(fs, fd, $ABA51051), 'synLZ');
  if CheckFailed(AlgoSynLZ.FileUnCompress(fd, f2, $ABA51051), 'unSynLZ') then
    exit;
  S := StringFromFile(f2);
  Check(S = Content, f2);
  Content := 'name=value'#13#10' name2= value2 '#13#10 +
             ' name 3  =  value3 '#13#10' name4: value 4 '#13#10;
  CheckEqual(FindIniNameValueU(Content, 'NAME='), 'value');
  CheckEqual(FindIniNameValueU(Content, 'NAME2='), 'value2');
  CheckEqual(FindIniNameValueU(Content, 'NAME3='), '');
  CheckEqual(FindIniNameValueU(Content, 'NAME 3='), 'value3');
  CheckEqual(FindIniNameValueU(Content, 'NAME4='), 'value 4');
  CheckEqual(FindIniNameValueU(Content, 'NAME4:'), 'value 4');
  Check(ExistsIniName(pointer(Content), 'NAME='), 'exist1');
  Check(ExistsIniName(pointer(Content), 'NAME2='), 'exist2');
  Check(ExistsIniName(pointer(Content), 'NAME 3='), 'exist2');
  Check(ExistsIniNameValue(pointer(Content), 'NAME=', @VUP));
  Check(ExistsIniNameValue(pointer(Content), 'NAME2=', @VUP));
  Check(not ExistsIniNameValue(pointer(Content), 'NAME3=', @VUP));
  Check(not ExistsIniNameValue(pointer(Content), 'NAME 3=', @VUP));
  Check(ExistsIniNameValue(pointer(Content), 'NAME 3  =', @VUP));
  Check(not ExistsIniNameValue(pointer(Content), 'NAME  3  =', @VUP));
  CheckEqual(FindIniNameValueU('name=value', 'NAME='), 'value');
  CheckEqual(FindIniNameValueU('name = value', 'NAME='), 'value');
  CheckEqual(FindIniNameValueU('toto='#10'name = value ', 'NAME='), 'value');
  CheckEqual(FindIniNameValueU('toto='#10'name = ', 'NAME='), '');
  Content := 'abc'#13#10'def'#10'ghijkl'#13'1234567890';
  P := pointer(Content);
  Check(GetNextLine(P, P) = 'abc');
  Check(GetNextLine(P, P) = 'def');
  Check(GetNextLine(P, P) = 'ghijkl');
  Check(GetNextLine(P, P) = '1234567890');
  Check(P = nil);
  Check(FindNameValue(pointer(Content), 'A')^ = 'b');
  Check(FindNameValue(pointer(Content), 'AB')^ = 'c');
  Check(FindNameValue(pointer(Content), 'D')^ = 'e');
  Check(FindNameValue(pointer(Content), '1')^ = '2');
  Check(FindNameValue(pointer(Content), 'GHIJK')^ = 'l');
  Check(FindNameValue(pointer(Content), 'B') = nil);
  Check(FindNameValue(pointer(Content), 'L') = nil);
  Check(FindNameValue(pointer(Content), '2') = nil);
  Check(FindNameValue(pointer(Content), 'TOTO') = nil);
  Check(FindNameValue(Content, 'AB', S));
  Check(S = 'c');
  Check(FindNameValue(Content, 'DEF', S));
  Check(S = '');
  Check(FindNameValue(Content, 'G', S));
  Check(S = 'hijkl');
  Check(FindNameValue(Content, '1234', S));
  Check(S = '567890');
  Check(not FindNameValue(Content, 'H', S));
  Check(S = '');
end;

procedure TTestCoreBase.Soundex;
var
  e: cardinal;
  PC: PAnsiChar;
  Soundex: TSynSoundEx;
  s: WinAnsiString;
begin
  Check(SoundExAnsi(PAnsiChar(' 120 ')) = 0);
  if SOUNDEX_BITS = 8 then
    {%H-}e := $2050206
  else
    e := $2526;
  Check(SoundExAnsi(PAnsiChar('bonjour')) = e);
  Check(SoundExAnsi(PAnsiChar(' 123 bonjour.  m'), @PC) = e);
  Check((PC <> nil) and
        (PC^ = '.'));
  s := ' 123 bonjourtreslongmotquidepasse  m';
  s[15] := #232;
  s[28] := #233;
  Check(SoundExAnsi(pointer(s), @PC) <> 0);
  Check((PC <> nil) and
        (PC^ = ' '));
  Check(SoundExAnsi(PAnsiChar('BOnjour')) = e);
  Check(SoundExAnsi(PAnsiChar('Bnjr')) = e);
  Check(SoundExAnsi(PAnsiChar('bonchour')) = e);
  Check(SoundExAnsi(PAnsiChar('mohammad')) =
        SoundExAnsi(PAnsiChar('mohhhammeeet')));
  if SOUNDEX_BITS = 8 then
    {%H-}e := $2050206
  else
    e := $25262;
  Check(SoundExAnsi(PAnsiChar('bonjours')) = e);
  Check(SoundExAnsi(PAnsiChar('BOnjours')) = e);
  Check(SoundExAnsi(PAnsiChar('Bnjrs')) = e);
  Check(SoundExAnsi(PAnsiChar(' 120 ')) = 0);
  if SOUNDEX_BITS = 8 then
    {%H-}e := $2050206
  else
    e := $2526;
  Check(SoundExUtf8('bonjour') = e);
  Check(SoundExUtf8(' 123 bonjour.  m', @PC) = e);
  Check((PC <> nil) and
        (PC^ = 'm'));
  Check(SoundExUtf8(Pointer(WinAnsiToUtf8(s)), @PC) <> 0);
  Check((PC <> nil) and
        (PC^ = 'm'));
  Check(SoundExUtf8('BOnjour') = e);
  Check(SoundExUtf8('Bnjr') = e);
  Check(SoundExUtf8('bonchour') = e);
  Check(SoundExUtf8('mohammad') = SoundExUtf8('mohhhammeeet'));
  if SOUNDEX_BITS = 8 then
    {%H-}e := $2050206
  else
    e := $25262;
  Check(SoundExUtf8('bonjours') = e);
  Check(SoundExUtf8('BOnjours') = e);
  Check(SoundExUtf8('Bnjrs') = e);
  Check(Soundex.Prepare(PAnsiChar('mohamad'), sndxEnglish));
  Check(Soundex.Ansi('moi rechercher mohammed ici'));
  Check(Soundex.Utf8('moi rechercher mohammed ici'));
  Check(Soundex.Ansi('moi mohammed'));
  Check(Soundex.Utf8('moi mohammed'));
  Check(not Soundex.Ansi('moi rechercher mouette ici'));
  Check(not Soundex.Utf8('moi rechercher mouette ici'));
  Check(not Soundex.Ansi('moi rechercher mouette'));
  Check(not Soundex.Utf8('moi rechercher mouette'));
end;

procedure TTestCoreBase.TRawUtf8ListSlow(Context: TObject);
const
  MAX = 20000;
  ONLYLOG = false;
var
  i, n, len: PtrInt; // @len = PPtrInt
  L: TRawUtf8List;
  B: TBinDictionary;
  O: TSynMonitorTime;
  v: TRawUtf8DynArray;
  v64: Int64;
  sl: TStrings;
  timer: TPrecisionTimer;
  cv: TCachedValues;

  procedure TestSort;
  begin
    L.Clear;
    Check(L.Count = 0);
    Check(L.IndexOf('5') < 0);
    Check(L.Add('toto') = 0);
    Check(L.Count = 1);
    Check(L.IndexOf('titi') < 0);
    Check(L.IndexOf('toto') = 0);
    CheckEqual(L.Text, 'toto');
    L.Sort;
    CheckEqual(L.Text, 'toto');
    Check(L.AddObject('titi', TObject.Create) = 1);
    CheckEqual(L.IndexOf('toto'), 0);
    CheckEqual(L.IndexOf('titi'), 1);
    Check(L.Objects[0] = nil);
    Check(L.Objects[1] <> nil);
    CheckEqual(L.GetText(','), 'toto,titi');
    L.Sort;
    CheckEqual(L.GetText(','), 'titi,toto');
    Check(L.Objects[0] <> nil);
    Check(L.Objects[1] = nil);
    CheckEqual(L.IndexOf('toto'), 1);
    CheckEqual(L.IndexOf('titi'), 0);
  end;

  procedure TestBinDictionary;
  var
    i, len: PtrInt; // @len = PPtrInt
  begin
    CheckEqual(B.Count, MAX + 1);
    Check(B.IndexOf(nil, 0) < 0);
    for i := MAX downto 0 do
    begin
      len := 0;
      Check(PInteger(B.Find(pointer(v[i]), length(v[i]), @len))^ = i);
      Check(len = 4);
    end;
  end;

begin
  SetLength(v, MAX + 1); // allocate once the strings
  for i := 0 to MAX do
    UInt32ToUtf8(i, v[i]);
  // validate TRawUtf8List
  L := TRawUtf8List.CreateEx([fObjectsOwned]);
  try // no hash table involved
    timer.Start;
    for i := 0 to MAX do
    begin
      O := TSynMonitorTime.Create; // any TObject would fit
      O.MicroSec := i;
      Check(L.AddObject(v[i], O) = i);
    end;
    NotifyTestSpeed('TRawUtf8List.Add no hash', MAX + 1, 0, @timer, ONLYLOG);
    Check(L.Count = MAX + 1);
    for i := 0 to MAX do
    begin
      Check(IsInt64(Pointer(L[i]), length(L[i]), @v64));
      Check(v64 = i);
    end;
    for i := 0 to MAX do
      Check(TSynMonitorTime(L.Objects[i]).MicroSec = i);
    sl := L.ToStrings;
    Check(sl is TVirtualStringList);
    CheckEqual(sl.Count, L.Count);
    CheckEqual(sl.Capacity, L.Count);
    for i := 0 to MAX do
    begin
      Check(StrToInt(sl[i]) = i);
      Check(TSynMonitorTime(sl.Objects[i]).MicroSec = i);
    end;
    sl.Free;
    timer.Start;
    Check(L.IndexOf('') < 0);
    for i := MAX downto MAX - 99 do // O(n) worst case: appear at the end
      Check(L.IndexOf(v[i]) = i);
    NotifyTestSpeed('TRawUtf8List.IndexOf no hash', 100, 0, @timer, ONLYLOG);
    Check(L.IndexOf('5') = 5);
    if MAX {%H-}>= 999 then
      Check(L.IndexOf('999') = 999);
    for i := MAX downto 0 do
      if i and 1 = 0 then
        L.Delete(i); // delete half the array
    Check(L.Count = MAX div 2);
    for i := 0 to L.Count - 1 do
      Check(GetInteger(Pointer(L[i])) = TSynMonitorTime(L.Objects[i]).MicroSec);
    Check(L.IndexOf('5') = 2);
    Check(L.IndexOf('6') < 0);
    Check(L.Exists('5'));
    Check(not L.Exists('6'));
    TestSort;
  finally
    L.Free;
  end;
  L := TRawUtf8List.CreateEx([fObjectsOwned, fNoDuplicate, fCaseSensitive]);
  try // with hash table
    timer.Start;
    for i := 1 to MAX do
    begin
      O := TSynMonitorTime.Create; // any TSynPersistent would fit
      O.MicroSec := i;
      Check(L.AddObject(v[i], O) = i - 1);
    end;
    NotifyTestSpeed('TRawUtf8List.Add hashed', MAX, 0, @timer, ONLYLOG);
    timer.Start;
    for i := 1 to MAX do
      Check(L.IndexOf(v[i]) = i - 1);
    NotifyTestSpeed('TRawUtf8List.IndexOf hashed', MAX, 0, @timer, ONLYLOG);
    Check(not L.Exists(''));
    Check(L.IndexOf('abcd') < 0);
    Check(L.Count = MAX);
    n := 0;
    for i := 1 to MAX do
    begin
      Check(L.IndexOf(v[i]) = n);
      Check(TSynMonitorTime(L.Objects[n]).MicroSec = i);
      if i and 127 = 0 then
        CheckEqual(L.Delete(v[i]), n, 'delete')
      else
        inc(n);
    end;
    CheckEqual(L.Count, n);
    for i := 1 to MAX do
      Check((L.IndexOf(v[i]) >= 0) = (i and 127 <> 0));
    L.SaveToFile(WorkDir + 'utf8list.txt');
    L.Clear;
    CheckEqual(L.Count, 0);
    L.LoadFromFile(WorkDir + 'utf8list.txt');
    CheckEqual(L.Count, n);
    for i := 1 to MAX do
      Check((L.IndexOf(v[i]) >= 0) = (i and 127 <> 0));
    DeleteFile(WorkDir + 'utf8list.txt');
    TestSort;
  finally
    L.Free;
  end;
  // validate TBinDictionary
  B := TBinDictionary.Create;
  try // with hash table
    timer.Start;
    for i := 0 to MAX do
    begin
      CheckEqual(B.Count, i);
      Check(B.Add(pointer(v[i]), @i, length(v[i]), 4) = i);
    end;
    NotifyTestSpeed('TBinDictionary.Add', MAX + 1, 0, @timer, ONLYLOG);
    timer.Start;
    TestBinDictionary;
    NotifyTestSpeed('TBinDictionary.Find', MAX + 1, 0, @timer, ONLYLOG);
    B.Clear;
    for i := 0 to MAX do
    begin
      CheckEqual(B.Count, i);
      Check(B.Update(pointer(v[i]), @i, length(v[i]), 4) = i);
    end;
    for i := 0 to MAX do
      if i and 127 = 0 then
        Check(B.Update(pointer(v[i]), @i, length(v[i]), 4) = i)
      else if i and 255 = 0 then
        Check(B.Add(pointer(v[i]), @i, length(v[i]), 4) < 0);
    for i := 0 to MAX do
    begin
      len := 0;
      Check(MemCmp(B.Keys(i, @len), pointer(v[i]), length(v[i])) = 0);
      Check(len = length(v[i]));
      len := 0;
      Check(PInteger(B.Values(i, @len))^ = i);
      Check(len = 4);
    end;
    TestBinDictionary;
    B.Clear;
    Check(B.Count = 0);
    Check(B.IndexOf(nil, 0) < 0);
    Check(B.Add(nil, nil, 0, 0) = 0);
    Check(B.Count = 1);
    Check(B.IndexOf(nil, 0) = 0);
    len := 1;
    Check(PInteger(B.Find(nil, 0, @len))^ = 0);
    Check(len = 0);
  finally
    B.Free;
  end;
  // validate TCachedValues
  cv.Safe.Init;
  cv.CustomCompare := nil;
  cv.Reset;
  for i := 0 to MAX do
    check(not cv.Exists(v[i]));
  for i := 0 to MAX do
    check(cv.Add(v[i]));
  for i := 0 to MAX do
    check(not cv.Add(v[i]));
  for i := 0 to MAX do
    check(cv.Exists(v[i]));
  check(not cv.Exists('toto'));
  cv.Reset;
  for i := 0 to MAX do
    check(not cv.Exists(v[i]));
end;

type
  TCity = record
    Name: string;
    Country: string;
    Latitude: double;
    Longitude: double;
  end;
  TCityDynArray = array of TCity;

  TAmount = packed record
    firmID: integer;
    amount: RawUtf8;
  end;
  TAmountDynArray = array of TAmount;

  TAmountI = packed record
    firmID: integer;
    amount: integer;
  end;
  TAmountIDynArray = array of TAmountI;

procedure TTestCoreBase.TDynArrayHashedSlow(Context: TObject);
var
  ACities: TDynArrayHashed;
  Cities: TCityDynArray;
  CitiesCount: integer;
  City: TCity;
  added: boolean;
  N: string;
  i, j: integer;
  A: TAmount;
  AI: TAmountI;
  AmountCollection: TAmountDynArray;
  AmountICollection: TAmountIDynArray;
  AmountDA, AmountIDA1, AmountIDA2: TDynArrayHashed;
const
  CITIES_MAX = 200000;
begin
  // default Init() will hash and compare binary content before string, i.e. firmID
  AmountDA.Init(TypeInfo(TAmountDynArray), AmountCollection);
  Check(AmountDA.Info.Parser = ptDynArray);
  Check(AmountDA.Info.ArrayFirstField = ptInteger);
  Check(@AmountDA.HashItem = @DynArrayHashOne(ptInteger));
  for i := 1 to 100 do
  begin
    A.firmID := i;
    A.amount := UInt32ToUtf8(i);
    Check(AmountDA.Add(A) = i - 1);
  end;
  AmountDA.ForceReHash;
  for i := 1 to length(AmountCollection) do
    Check(AmountDA.FindHashed(i) = i - 1);
  // default Init() will hash and compare the WHOLE binary content, i.e. 8 bytes
  AmountIDA1.Init(TypeInfo(TAmountIDynArray), AmountICollection);
  Check(AmountIDA1.Info.Parser = ptDynArray);
  Check(AmountIDA1.Info.ArrayFirstField = ptInt64);
  Check(@AmountIDA1.HashItem = @DynArrayHashOne(ptInt64));
  for i := 1 to 100 do
  begin
    AI.firmID := i;
    AI.amount := i * 2;
    Check(AmountIDA1.Add(AI) = i - 1);
  end;
  AmountIDA1.ForceReHash;
  for i := 1 to length(AmountICollection) do
  begin
    AI.firmID := i;
    AI.amount := i * 2;
    Check(AmountIDA1.FindHashed(AI) = i - 1);
  end;
  AmountIDA1.Clear;
  // specific hash & compare of the firmID integer first field
  AmountIDA2.InitSpecific(
    TypeInfo(TAmountIDynArray), AmountICollection, ptInteger);
  Check(AmountIDA2.Info.Parser = ptDynArray);
  Check(AmountIDA2.Info.ArrayFirstField = ptInt64); // global TRttiCustom untouched
  Check(@AmountIDA2.HashItem = @DynArrayHashOne(ptInteger));
  for i := 1 to 100 do
  begin
    AI.firmID := i;
    AI.amount := i * 2;
    Check(AmountIDA2.Add(AI) = i - 1);
  end;
  AmountIDA2.ForceReHash;
  for i := 1 to length(AmountICollection) do
    Check(AmountIDA2.FindHashed(i) >= 0);
  // valide generic-like features
  // see http://docwiki.embarcadero.com/CodeExamples/en/Generics_Collections_TDictionary_(Delphi)
  ACities.Init(TypeInfo(TCityDynArray), Cities, nil, nil, nil, @CitiesCount);
  City.Name := 'Iasi';
  City.Country := 'Romania';
  City.Latitude := 47.16;
  City.Longitude := 27.58;
  ACities.Add(City);
  City.Name := 'London';
  City.Country := 'United Kingdom';
  City.Latitude := 51.5;
  City.Longitude := -0.17;
  ACities.Add(City);
  City.Name := 'Buenos Aires';
  City.Country := 'Argentina';
  City.Latitude := 0;
  City.Longitude := 0;
  ACities.Add(City);
  Check(ACities.Count = 3);
  ACities.ForceReHash; // will use default hash, and search by Name = 1st field
  City.Name := 'Iasi';
  Check(ACities.FindHashedAndFill(City) = 0);
  Check(City.Name = 'Iasi');
  Check(City.Country = 'Romania');
  CheckSame(City.Latitude, 47.16);
  CheckSame(City.Longitude, 27.58);
  Check(ACities.FindHashedAndDelete(City) = 0);
  Check(City.Name = 'Iasi');
  Check(ACities.Scan(City) < 0);
  Check(ACities.FindHashed(City) < 0);
  City.Name := 'Buenos Aires';
  City.Country := 'Argentina';
  City.Latitude := -34.6;
  City.Longitude := -58.45;
  Check(ACities.FindHashedAndUpdate(City, {addifnotexisting=}false) >= 0);
  City.Latitude := 0;
  City.Longitude := 0;
  Check(City.Name = 'Buenos Aires');
  Check(ACities.FindHashedAndFill(City) >= 0);
  CheckSame(City.Latitude, -34.6);
  CheckSame(City.Longitude, -58.45);
  Check(ACities.FindHashedForAdding(City, added) >= 0);
  Check(not added);
  City.Name := 'Iasi';
  City.Country := 'Romania';
  City.Latitude := 47.16;
  City.Longitude := 27.58;
  i := ACities.FindHashedForAdding(City, added);
  Check(added);
  Check(i > 0);
  if i > 0 then
  begin
    Check(Cities[i].Name = ''); // FindHashedForAdding left void content
    Cities[i] := City; // should fill Cities[i] content by hand
  end;
  CheckEqual(ACities.Count, 3);
  Check(City.Name = 'Iasi');
  Check(ACities.FindHashed(City) >= 0);
  // add CITIES_MAX items
  for i := 1 to 2000 do
  begin
    City.Name := IntToString(i);
    City.Latitude := i * 3.14;
    City.Longitude := i * 6.13;
    CheckEqual(ACities.FindHashedAndUpdate(City, true), i + 2, 'multiple ReHash');
    CheckEqual(ACities.FindHashed(City), i + 2);
  end;
  ACities.Capacity := CITIES_MAX + 30; // will trigger HASH_PO2
  for i := 2001 to CITIES_MAX do
  begin
    City.Name := IntToString(i);
    City.Latitude := i * 3.14;
    City.Longitude := i * 6.13;
    if i = 8703 then
      City.Latitude := i * 3.14;
    CheckEqual(ACities.FindHashedAndUpdate(City, true), i + 2);
    CheckEqual(ACities.FindHashed(City.Name), i + 2);
  end;
  for i := 1 to CITIES_MAX do
  begin
    N := IntToString(i);
    Check(ACities.FindHashed(N) = i + 2);
  end;
  for i := 1 to CITIES_MAX do
  begin
    N := IntToString(i);
    j := ACities.FindHashed(N);
    Check(j >= 0);
    if i and 127 = 0 then
    begin
      Check(ACities.FindHashedAndDelete(N) >= 0, 'delete');
      j := ACities.FindHashed(N);
      Check(j < 0);
    end;
  end;
  for i := 1 to CITIES_MAX do
  begin
    N := IntToString(i);
    j := ACities.FindHashed(N);
    if i and 127 = 0 then
      Check(j < 0, 'deteled')
    else if Check(j >= 0, N) then
    begin
      Check(Cities[j].Name = N);
      CheckSame(Cities[j].Latitude, i * 3.14);
      CheckSame(Cities[j].Longitude, i * 6.13);
    end;
  end;
end;

type
  TPipeThread = class(TLoggedThread)
  protected
    Pipe: TPipeStream;
    WriteData: RawByteString;
    Hash: cardinal;
    Bytes, Expected: integer;
    procedure DoExecute; override;
  end;
const
  THREAD_ITER = 3; // stream 3 * 100K content between two TPipeThread
{.$define PIPEDEBUG}

procedure TPipeThread.DoExecute;
var
  tmp: TByteToAnsiChar; // very small 256 bytes buffer for stress reading
  n: integer;
begin
  if WriteData <> '' then
    // from W thread
    repeat
      {$ifdef PIPEDEBUG}ConsoleWrite('before Write');{$endif PIPEDEBUG}
      n := Pipe.Write(pointer(WriteData)^, length(WriteData));
      {$ifdef PIPEDEBUG}ConsoleWrite(['Write(', length(WriteData), ')=', n]);{$endif PIPEDEBUG}
      if n <> length(WriteData) then
        exit; // should block until Write() all data unless Pipe.Close was called
      Hash := crc32c(Hash, pointer(WriteData), n);
      inc(Bytes, n);
      {$ifdef PIPEDEBUG}ConsoleWrite('Write Stop');{$endif PIPEDEBUG}
      SleepHiRes(Random(50)); // simulate a blocking network connection
    until Bytes = Expected // execute Write() three times (HTTP-like body)
  else
  begin
    // from R thread
    {$ifdef PIPEDEBUG}ConsoleWrite('Read Start');{$endif PIPEDEBUG}
    repeat
      {$ifdef PIPEDEBUG}ConsoleWrite('before Read');{$endif PIPEDEBUG}
      n := Pipe.Read(tmp, SizeOf(tmp)); // n=256 until n=160 at end Write()
      {$ifdef PIPEDEBUG}ConsoleWrite(['Read(', SizeOf(tmp), ')=', n]);{$endif PIPEDEBUG}
      if n <= 0 then
        break;
      Hash := crc32c(Hash, @tmp, n);
      inc(Bytes, n);
      if Hash and 255 = 0 then
        SleepHiRes(Random(30)); // wait a few times during the whole process
      {$ifdef PIPEDEBUG}ConsoleWrite(['Read Bytes=', Bytes]);{$endif PIPEDEBUG}
    until Bytes = Expected; // execute Read() per 256-bytes (TFTP-like) chunk
    {$ifdef PIPEDEBUG}ConsoleWrite(['Read Stop, bytes=', Bytes]);{$endif PIPEDEBUG}
  end;
end;

procedure TTestCoreBase.TStreamSlow(Context: TObject);
var
  P: TPipeStream;
  R, W: TPipeThread;
  s1, s2: TStream;
  S, D: RawUtf8;
  ps: PAnsiChar;
  Tix: Int64;
  i, n, c, buflen, chunk: integer;
  crc: cardinal;
  timer: TPrecisionTimer;
  tmp: TBuffer1K; // small 1K buffer to stress (should be e.g. 64KB in practice)
begin
  S := RandomAnsi7(100000);
  // validate TBufferedStreamReader
  D := S;
  s1 := TRawByteStringStream.Create(S);
  try
    for buflen := 8 to 32 do
      for chunk := 1 to buflen * 3 do
      begin
        s2 := TBufferedStreamReader.Create(s1, buflen);
        try
          ps := UniqueRawUtf8(D);
          checkEqual(D, S);
          FillCharFast(ps^, length(D), 48);
          CheckNotEqual(D, S);
          repeat
            i := s2.Read(ps^, chunk);
            Check(i >= 0, 's2.ReadA');
            Check(i <= chunk, 's2.ReadB');
            inc(ps, i);
          until i = 0;
          CheckEqual(s2.Position, length(D));
          CheckEqual(s, D);
        finally
          s2.Free;
        end;
      end;
  finally
    s1.Free;
  end;
  // basic integrity from two threads
  P := TPipeStream.Create(512);
  R := TPipeThread.Create({suspended=}true, nil, nil, TSynLog, 'rd');
  W := TPipeThread.Create({suspended=}true, nil, nil, TSynLog, 'wr');
  try
    P.Options := [psoCheckThread];
    R.Pipe := P;
    R.Expected := length(S) * THREAD_ITER;
    R.Start;
    CheckEqual(P.Size, 0);
    CheckEqual(P.Position, 0);
    CheckEqual(P.Seek(0, soFromCurrent), 0);
    W.Pipe := P;
    W.WriteData := S;
    W.Expected := R.Expected;
    W.Start;
    W.WaitFor;
    CheckEqual(W.Expected, R.Expected);
    CheckEqual(W.Bytes, W.Expected, 'W.Bytes');
    R.WaitFor;
    CheckEqual(R.Bytes, R.Expected, 'R.Bytes');
    CheckEqual(R.Hash, W.Hash, 'Hash');
    CheckEqual(P.Size, R.Expected);
    CheckEqual(P.Position, R.Expected);
    CheckEqual(P.Seek(0, soFromCurrent), R.Expected);
    CheckEqual(P.Size, R.Expected);
    CheckEqual(P.ExpectedSize, -1);
  finally
    W.Free;
    R.Free;
    P.Free;
  end;
  // tiny ring buffer / wrap-around - no thread needed
  timer.Start;
  P := TPipeStream.Create(SizeOf(tmp));
  try
    CheckEqual(P.ExpectedSize, -1);
    P.ExpectedSize := 777;
    CheckEqual(P.Position, 0);
    CheckEqual(P.Size, 777, 'ExpectedSize before');
    CheckEqual(P.ExpectedSize, 777);
    ps := pointer(S);
    c := length(S) div SizeOf(tmp); // loop c=97 times
    for i := 1 to c do
    begin
      // try variable Write+Read (1..1024 bytes)
      if i and 31 = 7 then
        n := SizeOf(tmp) // whole 1K buffer once in a while
      else if i and 31 = 0 then
        n := 1 // another very intriguing number
      else
        n := Random32(SizeOf(tmp)) + 1; // good enough
      // verify Write/Read data roundtrip
      crc := crc32c(0, ps, n);
      CheckEqual(P.Write(ps^, n), n, 'write all');
      inc(ps, n);
      FillCharFast(tmp, n, 0);
      CheckEqual(P.Read(tmp, SizeOf(tmp)), n, 'read trunc');
      CheckEqual(crc, crc32c(0, @tmp, n), 'crc');
      CheckEqual(P.Pending, 0, 'pipe should be empty after full read');
    end;
    n := ps - pointer(S); // compute final length: around half of length(S)
    Check(n <= length(S), 'ps overflow');
    CheckEqual(P.Position, n, 'Position');
    CheckEqual(P.Size, 777, 'ExpectedSize after');
    CheckEqual(P.ExpectedSize, 777);
    P.ExpectedSize := -1;
    CheckEqual(P.Size, n, 'ExpectedSize reset');
    CheckEqual(P.Position, n, 'Position unchanged');
  finally
    P.Free;
  end;
  NotifyTestSpeed('TPipeStream', c, n, @timer);
  // read timeout
  P := TPipeStream.Create(64);
  try
    P.ReadTimeout := 50;
    Tix := GetTickCount64;
    CheckEqual(P.Read(tmp, 64), 0);
    Check(GetTickCount64 - Tix >= 30, 'rdto');
  finally
    P.Free;
  end;
  // write timeout
  P := TPipeStream.Create(64);
  try
    P.WriteTimeout := 50;
    CheckEqual(P.Write(tmp, 64), 64);
    Tix := GetTickCount64;
    n := P.Write(tmp, SizeOf(tmp));
    Check(n < SizeOf(tmp));
    Check(GetTickCount64 - Tix >= 30, 'wrto');
  finally
    P.Free;
  end;
  // close while blocked
  P := TPipeStream.Create(64);
  try
    W := TPipeThread.Create({suspended=}true, nil, nil, TSynLog, 'wr2');
    try
      W.Pipe := P;
      W.WriteData := S;
      W.Expected := length(s);
      W.Start;
      SleepHiRes(50);
      P.Abort;
      W.WaitFor;
      CheckEqual(W.Bytes, 0, 'close');
    finally
      W.Free;
    end;
  finally
    P.Free;
  end;
end;

type
  TRec = packed record
    a: integer;
    b: byte;
    c: double;
    D: Currency;
  end;
  TRecs = array of TRec;

  TProvince = record
    Name: RawUtf8;
    Comment: RawUtf8;
    Year: cardinal;
    Cities: TCityDynArray;
  end;

  TFV2 = packed record
    V1: TFV;
    value: integer;
    V2: TFV;
    Text: string;
  end;
  TFV2s = array of TFV2;

  TSynValidates = array of TSynValidate;

  TDataItem = record
    Modified: TDateTime;
    Data: string;
  end;
  TDataItems = array of TDataItem;

  TRawUtf8DynArray1 = type TRawUtf8DynArray;
  TRawUtf8DynArray2 = array of SpiUtf8;
  TAnsiStringDynArray = array of AnsiString;

function FVSort(const A, B): integer;
begin
  // string/PChar comparison of first "Detailed" field
  result := SysUtils.StrComp(
    PChar(pointer(TFV(A).Detailed)), PChar(pointer(TFV(B).Detailed)));
end;

procedure TTestCoreBase._TDynArray;
var
  AI, AI2: TIntegerDynArray;
  AU, AU2: TRawUtf8DynArray;
  AV1, AV2: TVariantDynArray;
  AR: TRecs;
  AF: TFVs;
  AF2: TFV2s;
  i, j, k, Len, count, AIcount: integer;
  U, U2: RawUtf8;
  P: PUtf8Char;
  PA: PAnsiChar;
  PI: PIntegerArray;
  AB: TBooleanDynArray;
  R: TRec;
  F, F1: TFV;
  F2: TFV2;
  City: TCity;
  Province: TProvince;
  AV: TSynValidates;
  V: TSynValidate;
  AIP, AI2P, AUP, ARP, AFP, ACities, AVP, dyn1, dyn2: TDynArray;
  dyniter: TDynArrayLoadFrom;
  B: boolean;
  dp: TDataItem;
  dyn1Array, dyn2Array: TDataItems;
  Test, Test2: RawByteString;
  ST: TCustomMemoryStream;
  Index: TIntegerDynArray;
  W: TJsonWriter;
  {$ifndef HASEXTRECORDRTTI}
  JSON_BASE64_MAGIC_UTF8: RawUtf8;
  {$endif HASEXTRECORDRTTI}
  tmp: TSynTempBuffer;
const
  MAGIC: array[0..1] of word = (34, $fff0);
  BUILDDATETIME: TDateTime = 36215.12; // circumvent a weird FPC/Android issue (Alf)

  procedure Fill(var F: TFV; const i: integer);
  begin
    F.Major := i;
    F.Minor := i + 1;
    F.Release := i + 2;
    F.Build := i + 3;
    F.Main := IntToString(i + 1000);
    F.Detailed := IntToString(2000 - i);
    F.BuildDateTime := BUILDDATETIME;
    F.BuildYear := i + 2011;
  end;

  procedure TestAF2;
  var
    i: integer;
    F1, F2: TFV;
  begin
    for i := 0 to AFP.Count - 1 do
    begin
      Check(AF2[i].value = i);
      Check(AF2[i].Text = IntToString(i));
      Fill(F1, i * 2);
      Fill(F2, i * 2 + 1);
      Check(RecordEquals(F1, AF2[i].V1, TypeInfo(TFV)));
      Check(RecordEquals(F2, AF2[i].V2, TypeInfo(TFV)));
    end;
  end;

  procedure Test64K;
  var
    i, E, n: integer;
    D: TDynArray;
    IA: TIntegerDynArray;
  begin
    D.Init(TypeInfo(TIntegerDynArray), IA, @n);
    D.Capacity := 16300;
    for i := 0 to 16256 do
    begin
      E := i * 5;
      Check(D.Add(E) = i);
      Check(IA[i] = i * 5);
    end;
    Check(D.Count = 16257);
    Check(D.Capacity = 16300);
    Check(length(IA) = D.Capacity);
    for i := 0 to 16256 do
      Check(IA[i] = i * 5);
    CheckHash(D.SaveTo, $55A23EC0, 'test64k');
  end;

  procedure TestCities;
  var
    i: PtrInt;
  begin
    for i := 0 to ACities.Count - 1 do
      with Province.Cities[i] do
      begin
        {$ifdef UNICODE}
        Check(StrToInt(Name) = i);
        {$else}
        Check(GetInteger(pointer(Name)) = i);
        {$endif UNICODE}
        CheckSame(Latitude, i * 3.14);
        CheckSame(Longitude, i * 6.13);
      end;
  end;

begin
  {$ifdef ASMX64AVX1}
  HasValidUtf8Avx2 := (cpuHaswell in X64CpuFeatures);
  {$else}
  HasValidUtf8Avx2 := false; // IsValidUtf8Buffer = @IsValidUtf8Pas
  {$endif ASMX64AVX1}
  // run the slowest tests in background thread(s)
  Run(NumericalConversionsSlow, self, 'NumericalConversions', true, false);
  Run(TDynArrayHashedSlow, self, 'TDynArrayHashed', true, false);
  Run(TSynDictionarySlow, self, 'TSynDictionary', true, false);
  Run(Utf8Slow, self, 'UTF-8', true, false);
  Run(TimeZonesSlow, self, 'TimeZones', true, false);
  Run(TRawUtf8ListSlow, self, 'TRawUtf8List', true, false);
  Run(TStreamSlow, self, 'TPipeStream', true, false);
  Run(TSynUniqueIdentifierSlow, self, 'TSynUniqueIdentifier', true, false);
  Run(CustomRTLSlow, self, 'CustomRTL', true, false);
  { TODO : implement TypeInfoToHash() if really needed }
  {
  h := TypeInfoToHash(TypeInfo(TAmount));
  Check(h=$9032161B,'TypeInfoToHash(TAmount)');
  h := TypeInfoToHash(TypeInfo(TAmountDynArray));
  Check(h=$887ED692,'TypeInfoToHash(TAmountDynArray)');
  h := TypeInfoToHash(TypeInfo(TAmountIDynArray));
  Check(h=$4051BAC,'TypeInfoToHash(TAmountIDynArray)');
  }
  Check(not IsRawUtf8DynArray(nil), 'IsRawUtf8DynArray0');
  Check(IsRawUtf8DynArray(TypeInfo(TRawUtf8DynArray)), 'IsRawUtf8DynArray1');
  Check(IsRawUtf8DynArray(TypeInfo(TRawUtf8DynArray1)), 'IsRawUtf8DynArray11');
  Check(IsRawUtf8DynArray(TypeInfo(TRawUtf8DynArray2)), 'IsRawUtf8DynArray12');
  Check(not IsRawUtf8DynArray(TypeInfo(TRawByteStringDynArray)), 'TRawByteStringDynArray');
  Check(not IsRawUtf8DynArray(TypeInfo(TAnsiStringDynArray)), 'TAnsiStringDynArray');
  Check(not IsRawUtf8DynArray(TypeInfo(TAmount)), 'IsRawUtf8DynArray2');
  Check(not IsRawUtf8DynArray(TypeInfo(TIntegerDynArray)), 'IsRawUtf8DynArray2');
  Check(not IsRawUtf8DynArray(TypeInfo(TPointerDynArray)), 'IsRawUtf8DynArray3');
  Check(not IsRawUtf8DynArray(TypeInfo(TAmountDynArray)), 'IsRawUtf8DynArray4');
  SetLength(AU, 2);
  AU[0] := 'true';
  AU[1] := 'false';
  SetLength(AU2, 2);
  AU2[0] := 'True';
  AU2[1] := 'False';
  Check(DynArrayEquals(TypeInfo(TRawUtf8DynArray), AU, AU2,
    nil, nil, {CaseInsensitive=}True));
  AU := nil; // for test below
  SetLength(AV1, 2);
  AV1[0] := 'true';
  AV1[1] := 'false';
  SetLength(AV2, 2);
  AV2[0] := 'True';
  AV2[1] := 'False';
  Check(DynArrayEquals(TypeInfo(TVariantDynArray), AV1, AV2,
    nil, nil, {CaseInsensitive=}True));
  AV1[0] := SynUnicode('true');
  AV1[1] := SynUnicode('false');
  SetLength(AV2, 2);
  AV2[0] := SynUnicode('True');
  AV2[1] := SynUnicode('False');
  Check(DynArrayEquals(TypeInfo(TVariantDynArray), AV1, AV2,
    nil, nil, {CaseInsensitive=}True));
  W := TJsonWriter.CreateOwnedStream;
  // validate TBooleanDynArray
  dyn1.Init(TypeInfo(TBooleanDynArray), AB);
  SetLength(AB, 4);
  for i := 0 to 3 do
    AB[i] := i and 1 = 1;
  Test := dyn1.SaveToJson;
  check(Test = '[false,true,false,true]');
  Check(AB <> nil);
  dyn1.Clear;
  Check(AB = nil);
  Check(dyn1.Count = 0);
  Check(dyn1.LoadFromJson(pointer(Test)) <> nil);
  Check(length(AB) = 4);
  Check(dyn1.Count = 4);
  for i := 0 to 3 do
    Check(AB[i] = (i and 1 = 1));
  Test := dyn1.SaveTo;
  dyn1.Clear;
  Check(AB = nil);
  Check(dyn1.LoadFrom(pointer(Test), PAnsiChar(Test) + length(Test)) <> nil);
  Check(dyn1.Count = 4);
  for i := 0 to 3 do
    Check(AB[i] = (i and 1 = 1));
  dyn1.Clear;
  Check(AB = nil);
  Check(dyn1.LoadFromBinary(Test));
  Check(dyn1.Count = 4);
  for i := 0 to 3 do
    Check(AB[i] = (i and 1 = 1));
  Check(dyniter.Init(TypeInfo(TBooleanDynArray), Test));
  Check(dyniter.Count = 4);
  for i := 0 to 3 do
  begin
    Check(dyniter.FirstField(@B));
    Check(B = (i and 1 = 1));
    B := not B;
    Check(dyniter.Step(@B));
    Check(B = (i and 1 = 1));
  end;
  Check(not dyniter.Step(@B));
  Check(not dyniter.FirstField(@B));
  // validate TIntegerDynArray
  Test64K;
  AIP.Init(TypeInfo(TIntegerDynArray), AI);
  for i := 0 to 1000 do
  begin
    Check(AIP.Count = i);
    Check(AIP.Add(i) = i);
    Check(AIP.Count = i + 1);
    Check(AI[i] = i);
  end;
  for i := 0 to 1000 do
    Check(AIP.IndexOf(i) = i);
  for i := 0 to 1000 do
  begin
    Check(IntegerScanExists(Pointer(AI), i + 1, i));
    Check(IntegerScanExists(Pointer(AI), AIP.Count, i));
    Check(not IntegerScanExists(Pointer(AI), AIP.Count, i + 2000));
  end;
  Test := AIP.SaveTo;
  CheckHash(Test, $60DCA314, 'hash32i');
  PI := IntegerDynArrayLoadFrom(pointer(Test), AIcount);
  Check(AIcount = 1001);
  Check(PI <> nil);
  for i := 0 to 1000 do
    Check(PI[i] = i);
  W.AddDynArrayJson(AIP);
  U := W.Text;
  P := pointer(U);
  for i := 0 to 1000 do
    Check(GetNextItemCardinal(P) = cardinal(i));
  CheckHash(U, $CBDFDAFC, 'hash32a');
  for i := 0 to 1000 do
  begin
    Test2 := AIP.ItemSave(@i);
    Check(length(Test2) = 4);
    k := 0;
    AIP.ItemLoad(pointer(Test2), PAnsiChar(Test2) + length(Test2), @k);
    Check(k = i);
    Check(AIP.ItemLoadFind(pointer(Test2), PAnsiChar(Test2) + length(Test2)) = i);
  end;
  AIP.Reverse;
  for i := 0 to 1000 do
    Check(AI[i] = 1000 - i);
  AIP.Clear;
  Check(AIP.LoadFrom(pointer(Test), PAnsiChar(Test) + length(Test)) <> nil);
  for i := 0 to 1000 do
    Check(AIP.IndexOf(i) = i);
  AIP.Clear;
  Check(AIP.LoadFromBinary(Test));
  for i := 0 to 1000 do
    Check(AIP.IndexOf(i) = i);
  for i := 1000 downto 0 do
    if i and 3 = 0 then
      AIP.Delete(i);
  Check(AIP.Count = 750);
  for i := 0 to 1000 do
    if i and 3 = 0 then
      Check(AIP.IndexOf(i) < 0)
    else
      Check(AIP.IndexOf(i) >= 0);
  AIP.Clear;
  Check(AIP.LoadFromJson(pointer(U)) <> nil);
  for i := 0 to 1000 do
    Check(AI[i] = i);
  AIP.Init(TypeInfo(TIntegerDynArray), AI, @AIcount);
  for i := 0 to 50000 do
  begin
    Check(AIP.Count = i, 'use of AIcount should reset it to zero');
    Check(AIP.Add(i) = i);
    Check(AIP.Count = i + 1);
    Check(AI[i] = i);
  end;
  AIP.Compare := SortDynArrayInteger;
  AIP.Sort;
  Check(AIP.Count = 50001);
  for i := 0 to AIP.Count - 1 do
    Check(AIP.Find(i) = i);
  Test := AIP.SaveTo;
  CheckHash(Test, $69562803, 'hash32b');
  AIP.Reverse;
  for i := 0 to 50000 do
    Check(AI[i] = 50000 - i);
  SetLength(AI, AIcount);
  AIP.Init(TypeInfo(TIntegerDynArray), AI);
  AIP.Compare := SortDynArrayInteger;
  AIP.Sort;
  Test := AIP.SaveTo;
  CheckHash(Test, $69562803, 'hash32c');
  AIP.Reverse;
  AIP.Slice(AI2, 2000, 1000);
  Check(length(AI2) = 2000);
  for i := 0 to 1999 do
    Check(AI2[i] = 49000 - i);
  AIP.AddArray(AI2, 1000, 2000);
  Check(AIP.Count = 51001);
  for i := 0 to 50000 do
    Check(AI[i] = 50000 - i);
  for i := 0 to 999 do
    Check(AI[i + 50001] = 48000 - i);
  AIP.Count := 50001;
  AIP.AddArray(AI2);
  Check(AIP.Count = 52001);
  for i := 0 to 50000 do
    Check(AI[i] = 50000 - i);
  for i := 0 to 1999 do
    Check(AI[i + 50001] = 49000 - i);
  AIP.Clear;
  with DynArray(TypeInfo(TIntegerDynArray), AI) do
  begin
    Check(LoadFromBinary(Test));
    for i := 0 to count - 1 do
      Check(AI[i] = i);
  end;
  Check(AIP.Count = 50001);
  AI2P.Init(TypeInfo(TIntegerDynArray), AI2);
  AIP.AddDynArray(@AI2P);
  Check(AIP.Count = 52001);
  for i := 0 to 50000 do
    Check(AI[i] = i);
  for i := 0 to 1999 do
    Check(AI[i + 50001] = 49000 - i);
  // validate TSynValidates (an array of classes is an array of PtrInt)
  AVP.Init(TypeInfo(TSynValidates), AV);
  for i := 0 to 1000 do
  begin
    Check(AVP.Count = i);
    PtrInt(V) := i;
    Check(AVP.Add(V) = i);
    Check(AVP.Count = i + 1);
    Check(AV[i] = V);
  end;
  Check(length(AV) = 1001);
  Check(AVP.Count = 1001);
  for i := 0 to 1000 do
  begin
    // untyped const must be the same exact type !
    PtrInt(V) := i;
    Check(AVP.IndexOf(V) = i);
  end;
  Test := AVP.SaveTo;
  CheckHash(Test, {$ifdef CPU64} $2CB4A314 {$else} $60DCA314 {$endif}, 'AVP.SaveTo');
  // validate TRawUtf8DynArray
  AUP.Init(TypeInfo(TRawUtf8DynArray), AU);
  for i := 0 to 1000 do
  begin
    Check(AUP.Count = i);
    U := UInt32ToUtf8(i + 1000);
    Check(AUP.Add(U) = i);
    Check(AUP.Count = i + 1);
    Check(AU[i] = U);
  end;
  for i := 0 to 1000 do
  begin
    U := Int32ToUtf8(i + 1000);
    Check(AUP.IndexOf(U) = i);
  end;
  U := '3000';
  Check(AUP.IndexOf(U) < 0);
  Test := AUP.SaveTo;
  CheckHash(@Test[2], length(Test) - 1, $1EC51463, 'hash32e');
  // trimed Test[1]=ElemSize
  for i := 0 to 1000 do
  begin
    U := Int32ToUtf8(i + 1000);
    Check(RawUtf8DynArrayLoadFromContains(
      pointer(Test), pointer(U), length(U), false) = i);
    Check(RawUtf8DynArrayLoadFromContains(
      pointer(Test), pointer(U), length(U), true) = i);
  end;
  for i := 0 to 1000 do
  begin
    U := UInt32ToUtf8(i + 1000);
    Test2 := AUP.ItemSave(@U);
    Check(length(Test2) > 4);
    U := '';
    AUP.ItemLoad(pointer(Test2), PAnsiChar(Test2) + length(Test2), @U);
    Check(GetInteger(pointer(U)) = i + 1000);
    Check(AUP.ItemLoadFind(pointer(Test2), PAnsiChar(Test2) + length(Test2)) = i);
  end;
  W.CancelAll;
  W.AddDynArrayJson(AUP);
  W.SetText(U);
  CheckHash(U, $1D682EF8, 'hash32f');
  P := pointer(U);
  if Check(P^ = '[') then
    inc(P);
  for i := 0 to 1000 do
  begin
    Check(P^ = '"');
    inc(P);
    Check(GetNextItemCardinal(P) = cardinal(i + 1000));
    if P = nil then
      break;
  end;
  Check(P = nil);
  AUP.Clear;
  Check(AUP.LoadFrom(pointer(Test),
    PAnsiChar(Test) + length(Test)) - pointer(Test) = length(Test));
  for i := 0 to 1000 do
    Check(GetInteger(pointer(AU[i])) = i + 1000);
  AUP.Clear;
  Check(AUP.LoadFromBinary(Test));
  for i := 0 to 1000 do
    Check(GetInteger(pointer(AU[i])) = i + 1000);
  Check(dyniter.Init(TypeInfo(TRawUtf8DynArray), Test));
  Check(dyniter.Count = 1001);
  for i := 0 to 1000 do
  begin
    Check(dyniter.FirstField(@U2));
    Check(GetInteger(pointer(U2)) = i + 1000);
    U2 := '';
    Check(dyniter.Step(@U2));
    Check(GetInteger(pointer(U2)) = i + 1000);
  end;
  Check(not dyniter.Step(@U2));
  Check(not dyniter.FirstField(@U2));
  AUP.Clear;
  Check(AUP.LoadFromJson(pointer(U)) <> nil);
  for i := 0 to 1000 do
    Check(GetInteger(pointer(AU[i])) = i + 1000);
  for i := 0 to 1000 do
  begin
    U := Int32ToUtf8(i + 1000);
    Check(AUP.IndexOf(U) = i);
  end;
  for i := 1000 downto 0 do
    if i and 3 = 0 then
      AUP.Delete(i);
  Check(AUP.Count = 750);
  for i := 0 to 1000 do
  begin
    U := Int32ToUtf8(i + 1000);
    if i and 3 = 0 then
      Check(AUP.IndexOf(U) < 0)
    else
      Check(AUP.IndexOf(U) >= 0);
  end;
  U := 'inserted';
  AUP.Insert(500, U);
  Check(AUP.IndexOf(U) = 500);
  j := 0;
  for i := 0 to AUP.Count - 1 do
    if i <> 500 then
    begin
      U := Int32ToUtf8(j + 1000);
      if j and 3 = 0 then
        Check(AUP.IndexOf(U) < 0)
      else
        Check(AUP.IndexOf(U) >= 0);
      inc(j);
    end;
  AUP.CreateOrderedIndex(Index, SortDynArrayAnsiString);
  Check(StrComp(pointer(AU[Index[750]]), pointer(AU[Index[749]])) > 0);
  for i := 1 to AUP.Count - 1 do
    Check(AU[Index[i]] > AU[Index[i - 1]]);
  AUP.Compare := SortDynArrayAnsiString;
  AUP.Sort;
  Check(AUP.Sorted);
  Check(AU[AUP.Count - 1] = 'inserted');
  for i := 1 to AUP.Count - 1 do
    Check(AU[i] > AU[i - 1]);
  j := 0;
  for i := 0 to AUP.Count - 1 do
    if i <> 500 then
    begin
      U := Int32ToUtf8(j + 1000);
      if j and 3 = 0 then
        Check(AUP.Find(U) < 0)
      else
        Check(AUP.Find(U) >= 0);
      inc(j);
    end;
  AUP.Sorted := false;
  j := 0;
  for i := 0 to AUP.Count - 1 do
    if i <> 500 then
    begin
      U := Int32ToUtf8(j + 1000);
      if j and 3 = 0 then
        Check(AUP.Find(U) < 0)
      else
        Check(AUP.Find(U) >= 0);
      inc(j);
    end;
  // validate packed binary record (no string inside)
  ARP.Init(TypeInfo(TRecs), AR);
  for i := 0 to 1000 do
  begin
    Check(ARP.Count = i);
    R.A := i;
    R.B := i + 1;
    R.C := i * 2.2;
    R.D := i * 3.25;
    Check(ARP.Add(R) = i);
    Check(ARP.Count = i + 1);
  end;
  for i := 0 to 1000 do
  begin
    with AR[i] do
    begin
      Check(a = i);
      Check(B = byte(i + 1));
      CheckSame(c, i * 2.2);
      CheckSame(D, i * 3.25);
    end;
    R.A := i;
    R.B := i + 1;
    R.C := i * 2.2;
    R.D := i * 3.25;
    Check(ARP.IndexOf(R) = i); // will work (packed + no ref-counted types inside)
  end;
  W.CancelAll;
  W.AddDynArrayJson(ARP);
  U := W.Text;
  {$ifndef HASEXTRECORDRTTI} // enhanced RTTI won't let binary serialization
  P := pointer(U);
  JSON_BASE64_MAGIC_UTF8 := RawUnicodeToUtf8(@MAGIC, 2);
  U2 := RawUtf8('[') + JSON_BASE64_MAGIC_UTF8 +
        RawUtf8(BinToBase64(ARP.SaveTo)) + RawUtf8('"]');
  Check(U = U2);
  {$endif HASEXTRECORDRTTI}
  ARP.Clear;
  Check(ARP.LoadFromJson(pointer(U)) <> nil);
  if Check(ARP.Count = 1001) then
    for i := 0 to 1000 do
      with AR[i] do
      begin
        Check(a = i);
        Check(B = byte(i + 1));
        CheckSame(c, i * 2.2);
        CheckSame(D, i * 3.25);
      end;
  // validate packed record with strings inside
  AFP.Init(TypeInfo(TFVs), AF);
  for i := 0 to 1000 do
  begin
    Check(AFP.Count = i);
    Fill(F, i);
    Check(AFP.Add(F) = i);
    Check(AFP.Count = i + 1);
  end;
  Fill(F, 100);
  Check(RecordEquals(F, AF[100], TypeInfo(TFV)));
  Len := 38;
  {$ifdef UNICODE}
  inc(Len, length(F.Main) + length(F.Detailed)); // adjust wideChars binary size
  {$endif UNICODE}
  RecordSave(F, tmp, TypeInfo(TFV));
  Check(tmp.len = Len);
  Fill(F, 0); // reset
  Check(RecordLoad(F, tmp.buf, TypeInfo(TFV), nil, tmp.BufEnd) - tmp.buf = Len);
  tmp.Done;
  Check(RecordEquals(F, AF[100], TypeInfo(TFV)));
  Test := RecordSaveBase64(F, TypeInfo(TFV));
  Check(Test <> '');
  Fill(F, 0);
  Check(RecordLoadBase64(pointer(Test), length(Test), F, TypeInfo(TFV)));
  Check(RecordEquals(F, AF[100], TypeInfo(TFV)));
  Test := RecordSaveBase64(F, TypeInfo(TFV), true);
  Check(Test <> '');
  Fill(F, 0);
  Check(RecordLoadBase64(pointer(Test), length(Test), F, TypeInfo(TFV), true));
  Check(RecordEquals(F, AF[100], TypeInfo(TFV)));
  for i := 0 to 1000 do
    with AF[i] do
    begin
      Check(Major = i);
      Check(Minor = i + 1);
      Check(Release = i + 2);
      Check(Build = i + 3);
      Check(Main = IntToString(i + 1000));
      Check(Detailed = IntToString(2000 - i));
      CheckSame(BuildDateTime, BUILDDATETIME);
      Check(BuildYear = i + 2011);
    end;
  for i := 0 to 1000 do
  begin
    Fill(F, i);
    Check(AFP.IndexOf(F) = i);
  end;
  Test := AFP.SaveTo;
  // binary follows the in-memory layout and here Main/Detailed are string
  CheckHash(Test, {$ifdef UNICODE} $080CE771 {$else} $0001179D {$endif}, 'hash32h');
  for i := 0 to 1000 do
  begin
    Fill(F, i);
    AFP.ItemCopy(@F, @F1);
    Check(AFP.ItemEquals(@F, @F1));
    Test2 := AFP.ItemSave(@F);
    Check(length(Test2) > 4);
    AFP.ItemClear(@F);
    AFP.ItemLoad(pointer(Test2), PAnsiChar(Test2) + length(Test2), @F);
    Check(AFP.ItemEquals(@F, @F1));
    Check(AFP.ItemLoadFind(pointer(Test2), PAnsiChar(Test2) + length(Test2)) = i);
  end;
  W.CancelAll;
  W.AddDynArrayJson(AFP);
  // note: error? ensure TTestCoreBase run after TTestLowLevelTypes
  // -> otherwise custom serialization is still active with no Build* fields
  U := W.Text;
  {$ifdef HASEXTRECORDRTTI} // thanks to enhanced RTTI
  Check(IdemPChar(pointer(U), '[{"MAJOR":0,"MINOR":1,"RELEASE":2,"BUILD":3,' +
    '"MAIN":"1000","DETAILED":"2000","BUILDDATETIME":"1999-02-24T02:52:48",' +
    '"BUILDYEAR":2011},{"MAJOR":1,"MINOR":2,"RELEASE":3,"BUILD":4,'));
  CheckHash(U, $74523E0F, 'hash32i');
  {$else}
  CheckEqual(U, '[' + JSON_BASE64_MAGIC_UTF8 + BinToBase64(Test) + '"]');
  {$endif HASEXTRECORDRTTI}
  AFP.Clear;
  Check(AFP.LoadFrom(
    pointer(Test), PAnsiChar(Test) + length(Test)) - pointer(Test) = length(Test));
  for i := 0 to 1000 do
  begin
    Fill(F, i);
    Check(AFP.IndexOf(F) = i);
  end;
  Check(dyniter.Init(TypeInfo(TFVs), Test));
  Check(dyniter.Count = 1001);
  for i := 0 to 1000 do
  begin
    Check(dyniter.Step(@F1));
    Fill(F, i);
    Check(AFP.ItemEquals(@F, @F1));
  end;
  Check(not dyniter.Step(@F1));
  ST := TMemoryStream.Create;
  AFP.SaveToStream(ST);
  AFP.Clear;
  ST.Position := 0;
  AFP.LoadFromStream(ST);
  Check(ST.Position = length(Test));
  for i := 0 to 1000 do
  begin
    Fill(F, i);
    Check(AFP.IndexOf(F) = i);
  end;
  ST.Free;
  AFP.Clear;
  Check(AFP.LoadFromJson(pointer(U)) <> nil);
  for i := 0 to 1000 do
  begin
    Fill(F, i);
    Check(RecordEquals(F, AF[i], AFP.Info.Cache.ItemInfoRaw));
  end;
  for i := 0 to 1000 do
  begin
    Fill(F, i);
    F.BuildYear := 10;
    Check(AFP.IndexOf(F) < 0);
    F.BuildYear := i + 2011;
    F.Detailed := '??';
    Check(AFP.IndexOf(F) < 0);
  end;
  for i := 1000 downto 0 do
    if i and 3 = 0 then
      AFP.Delete(i);
  Check(AFP.Count = 750);
  for i := 0 to 1000 do
  begin
    Fill(F, i);
    if i and 3 = 0 then
      Check(AFP.IndexOf(F) < 0)
    else
      Check(AFP.IndexOf(F) >= 0);
  end;
  Fill(F, 5000);
  AFP.Insert(500, F);
  Check(AFP.IndexOf(F) = 500);
  j := 0;
  for i := 0 to AFP.Count - 1 do
    if i <> 500 then
    begin
      Fill(F, j);
      if j and 3 = 0 then
        Check(AFP.IndexOf(F) < 0)
      else
        Check(AFP.IndexOf(F) >= 0);
      inc(j);
    end;
  Finalize(Index);
  AFP.CreateOrderedIndex(Index, FVSort);
  for i := 1 to AUP.Count - 1 do
    Check(AF[Index[i]].Detailed > AF[Index[i - 1]].Detailed);
  AFP.Compare := FVSort;
  AFP.Sort;
  for i := 1 to AUP.Count - 1 do
    Check(AF[i].Detailed > AF[i - 1].Detailed);
  j := 0;
  for i := 0 to AFP.Count - 1 do
    if i <> 500 then
    begin
      Fill(F, j);
      if j and 3 = 0 then
        Check(AFP.Find(F) < 0)
      else
        Check(AFP.Find(F) >= 0);
      inc(j);
    end;
  W.Free;
  // validate packed record with records of strings inside
  AFP.Init(Typeinfo(TFV2s), AF2);
  for i := 0 to 1000 do
  begin
    Fill(F2.V1, i * 2);
    F2.Value := i;
    Fill(F2.V2, i * 2 + 1);
    F2.Text := IntToString(i);
    Check(AFP.Add(F2) = i);
  end;
  Check(AFP.Count = 1001);
  TestAF2;
  Test := AFP.SaveTo;
  AFP.Clear;
  Check(AFP.Count = 0);
  Check(AFP.LoadFromBinary(Test));
  Check(AFP.Count = 1001);
  TestAF2;
  // validate https://synopse.info/forum/viewtopic.php?pid=16581#p16581
  dp.Modified := Now;
  dp.Data := '1';
  dyn1.Init(TypeInfo(TDataItems), dyn1Array);
  dyn1.Add(dp);
  dp.Modified := Now;
  dp.Data := '2';
  dyn2.Init(TypeInfo(TDataItems), dyn2Array);
  check(dyn2.count = 0);
  dyn2.Add(dp);
  check(length(dyn2Array) = 1);
  check(dyn2.count = 1);
  dyn2.AddArray(dyn1Array);
  check(dyn2.count = 2);
  check(dyn2.ItemEquals(@dyn2Array[0], @dp));
  check(dyn2.ItemEquals(@dyn2Array[1], @dyn1Array[0]));
  dyn2.AddDynArray(@dyn1);
  check(dyn2.count = 3);
  check(dyn2.ItemEquals(@dyn2Array[0], @dp));
  check(dyn2.ItemEquals(@dyn2Array[1], @dyn1Array[0]));
  check(dyn2.ItemEquals(@dyn2Array[2], @dyn1Array[0]));
  // valide generic-like features
  // see http://docwiki.embarcadero.com/CodeExamples/en/Generics_Collections_TDictionary_(Delphi)
  ACities.Init(TypeInfo(TCityDynArray), Province.Cities);
  City.Name := 'Iasi';
  City.Country := 'Romania';
  City.Latitude := 47.16;
  City.Longitude := 27.58;
  ACities.Add(City);
  City.Name := 'London';
  City.Country := 'United Kingdom';
  City.Latitude := 51.5;
  City.Longitude := -0.17;
  ACities.Add(City);
  City.Name := 'Buenos Aires';
  City.Country := 'Argentina';
  City.Latitude := 0;
  City.Longitude := 0;
  ACities.Add(City);
  Check(ACities.Count = 3);
  ACities.Compare := SortDynArrayString; // will search by Name = 1st field
  City.Name := 'Iasi';
  Check(ACities.FindAndFill(City) = 0);
  Check(City.Name = 'Iasi');
  Check(City.Country = 'Romania');
  CheckSame(City.Latitude, 47.16);
  CheckSame(City.Longitude, 27.58);
  Check(ACities.FindAndDelete(City) = 0);
  Check(City.Name = 'Iasi');
  Check(ACities.Find(City) < 0);
  City.Name := 'Buenos Aires';
  City.Country := 'Argentina';
  City.Latitude := -34.6;
  City.Longitude := -58.45;
  Check(ACities.FindAndUpdate(City) >= 0);
  City.Latitude := 0;
  City.Longitude := 0;
  Check(City.Name = 'Buenos Aires');
  Check(ACities.FindAndFill(City) >= 0);
  CheckSame(City.Latitude, -34.6);
  CheckSame(City.Longitude, -58.45);
  Check(ACities.FindAndAddIfNotExisting(City) >= 0);
  City.Name := 'Iasi';
  City.Country := 'Romania';
  City.Latitude := 47.16;
  City.Longitude := 27.58;
  Check(ACities.FindAndAddIfNotExisting(City) < 0);
  Check(City.Name = 'Iasi');
  Check(ACities.FindAndUpdate(City) >= 0);
  ACities.Sort;
  for i := 1 to high(Province.Cities) do
    Check(Province.Cities[i].Name > Province.Cities[i - 1].Name);
  Check(ACities.Count = 3);
  // complex record test
  Province.Name := 'Test';
  Province.Comment := 'comment';
  Province.Year := 1000;
  Test := RecordSave(Province, TypeInfo(TProvince));
  FastRecordClear(@Province, TypeInfo(TProvince));
  Check(Province.Name = '');
  Check(Province.Comment = '');
  Check(length(Province.Cities) = 0);
  Check(ACities.Count = 0);
  Province.Year := 0;
  PA := RecordLoad(Province, pointer(Test), TypeInfo(TProvince), nil,
    PAnsiChar(pointer(Test)) + length(Test));
  Check((PA <> nil) and (PA^ = #0));
  Check(Province.Name = 'Test');
  Check(Province.Comment = 'comment');
  Check(Province.Year = 1000);
  Check(length(Province.Cities) = 3);
  Check(ACities.Count = 3);
  for i := 1 to high(Province.Cities) do
    Check(Province.Cities[i].Name > Province.Cities[i - 1].Name);
  Province.Cities := nil;
  Test := RecordSave(Province, TypeInfo(TProvince));
  FastRecordClear(@Province, TypeInfo(TProvince));
  Check(Province.Name = '');
  Check(Province.Comment = '');
  Check(length(Province.Cities) = 0);
  Check(ACities.Count = 0);
  Check(RecordLoad(Province, Test, TypeInfo(TProvince)));
  Check(Province.Name = 'Test');
  Check(Province.Comment = 'comment');
  Check(Province.Year = 1000);
  Check(length(Province.Cities) = 0);
  Check(ACities.Count = 0);
  // big array test
  ACities.Init(TypeInfo(TCityDynArray), Province.Cities);
  ACities.Clear;
  for i := 0 to 10000 do
  begin
    City.Name := IntToString(i);
    City.Latitude := i * 3.14;
    City.Longitude := i * 6.13;
    Check(ACities.Add(City) = i);
  end;
  Check(ACities.Count = Length(Province.Cities));
  Check(ACities.Count = 10001);
  TestCities;
  count := 7;
  ACities.Init(TypeInfo(TCityDynArray), Province.Cities, @count);
  CheckEqual(count, 0);
  for i := 0 to 100000 do
  begin
    City.Name := IntToString(i);
    City.Latitude := i * 3.14;
    City.Longitude := i * 6.13;
    Check(ACities.Add(City) = i);
  end;
  CheckEqual(count, 100001);
  CheckEqual(ACities.Count, count);
  TestCities;
end;

function BufEquals(P, n, b: PtrInt): boolean;
begin
  // slower than FillChar, faster than for loop, but fast enough for testing
  result := false;
  {$ifdef CPU32}
  b := b * $01010101;
  {$else}
  b := b * $0101010101010101;
  {$endif CPU32}
  inc(n, P - SizeOf(P));
  if n >= P then
    repeat
      if PPtrInt(P)^ <> b then
        exit;
      inc(PPtrInt(P));
    until n < P;
  inc(n, SizeOf(P));
  if P < n then
    repeat
      if PByte(P)^ <> byte(b) then
        exit;
      inc(P);
    until P >= n;
  result := true;
end;

function IsBufIncreasing(P: PByteArray; n: PtrInt; b: byte): boolean;
var
  i: PtrInt;
begin
  result := false;
  for i := 0 to n - 1 do
    if P[i] <> b then
      exit
    else
      inc(b);
  result := true;
end;

procedure TTestCoreBase.CustomRTLSlow(Sender: TObject);
// note: mormot.core.os.posix.inc redirects FillCharFast/MoveFast to the libc
var
  buf: RawByteString;

  procedure Validate(rtl: boolean);
  var
    i, len, filled, moved: PtrInt;
    b1, b2: byte;
    timer: TPrecisionTimer;
    P: PByteArray;
    msg: string;
    {$ifdef ASMX64NOTPIC}
    cputxt: RawUtf8;
    {$endif ASMX64NOTPIC}
    elapsed: Int64;
  begin
    // first validate FillCharFast
    b1 := 0;
    len := 1;
    repeat
      b2 := (b1 + 1) and 255;
      buf[len + 1] := AnsiChar(b1);
      if rtl then
        FillChar(pointer(buf)^, len, b2)
      else
        FillCharFast(pointer(buf)^, len, b2);
      Check(BufEquals(PtrInt(buf), len, b2));
      Check(ord(buf[len + 1]) = b1);
      b1 := b2;
      if len < 16384 then
        inc(len)
      else
        inc(len, 777 + len shr 4);
    until len >= length(buf);
    // benchmark FillChar/FillCharFast
    {$ifdef ASMX64NOTPIC}
    cputxt := GetSetName(TypeInfo(TX64CpuFeatures), X64CpuFeatures);
    {$endif ASMX64NOTPIC}
    if rtl then
      msg := 'FillChar'
    else
      {$ifdef ASMX64NOTPIC}
      FormatString('FillCharFast [%]', [{%H-}cputxt], msg);
      {$else}
      msg := 'FillCharFast';
      {$endif ASMX64NOTPIC}
    // now make the same test with no Check() but with timing
    // small len makes timer.Resume/Pause unreliable -> single shot measure
    b1 := 0;
    len := 1;
    filled := 0;
    timer.Start;
    repeat
      b2 := (b1 + 1) and 255;
      if rtl then
        FillChar(pointer(buf)^, len, b2)
      else
        FillCharFast(pointer(buf)^, len, b2);
      inc(filled, len);
      b1 := b2;
      if len < 16384 then
        inc(len)
      else
        inc(len, 777 + len shr 4);
    until len >= length(buf);
    NotifyTestSpeed(msg, 1, filled, @timer);
    // validate negative count of Move/MoveFast (should not make any GPF)
    if rtl then
      move(buf[1], buf[2], -100)
    else
      moveFast(buf[1], buf[2], -100);
    // validates overlapping forward Move/MoveFast
    if rtl then
      msg := 'Move'
    else
      {$ifdef ASMX64NOTPIC}
      FormatString('MoveFast [%]', [{%H-}cputxt], msg);
      {$else}
      msg := 'MoveFast';
      {$endif ASMX64NOTPIC}
    P := pointer(buf);
    for i := 0 to length(buf) - 1 do
      P[i] := i; // fills with 0,1,2,...
    Check(IsBufIncreasing(P, length(buf), 0));
    timer.Start;
    for i := 1 to 20 do     
    begin
      len := 1;
      moved := 0;
      repeat
        if rtl then
          Move(P[moved + 1], P[moved], len)
        else
          MoveFast(P[moved + 1], P[moved], len);
        inc(moved, len);
        Check(P[moved] = P[moved - 1]);
        inc(len);
      until moved + len >= length(buf);
    end;
    NotifyTestSpeed(msg, 1, moved * 20, @timer);
    CheckHash(buf, $813F6468);
    // forward and backward overlapped moves on small buffers
    elapsed := 0;
    moved := 0;
    for len := 1 to 48 do
    begin
      timer.Start;
      if rtl then
        for i := 1 to 50000 do
        begin
          Move(P[100], P[i], len);
          Move(P[i], P[100], len);
        end
      else
        for i := 1 to 50000 do
        begin
          MoveFast(P[100], P[i], len);
          MoveFast(P[i], P[100], len);
        end;
      inc(moved, 100000 * len);
      inc(elapsed, NotifyTestSpeed('%b %', [len, msg], 1, 100000 * len, @timer,
        {onlylog=}true));
    end;
    timer.FromExternalMicroSeconds(elapsed);
    NotifyTestSpeed('small %', [msg], 1, moved, @timer);
    CheckHash(buf, $DBB1A444);
    // forward and backward non-overlapped moves on big buffers
    len := (length(buf) - 3200) shr 1;
    timer.Start;
    for i := 1 to 25 do
      if rtl then
      begin
        Move(P[len], P[i], len - i * 10);
        Move(P[i], P[len], len - i * 10);
      end
      else
      begin
        MoveFast(P[len], P[i], len - i * 10);
        MoveFast(P[i], P[len], len - i * 10);
      end;
    NotifyTestSpeed('big %', [msg], 1, 50 * len, @timer);
    CheckHash(buf, $88D61C65);
    // forward and backward overlapped moves on big buffers
    len := length(buf) - 3200;
    for i := 1 to 3 do
      if rtl then
      begin
        Move(P[3100], P[i], len - i);
        Move(P[i], P[3200], len - i);
      end
      else
      begin
        MoveFast(P[3100], P[i], len - i);
        MoveFast(P[i], P[3200], len - i);
      end;
    CheckHash(buf, $B49DB8A5);
  end;

{$ifdef ASMX64NOTPIC}
var
  bak, cpu: TX64CpuFeatures;
{$endif ASMX64NOTPIC}
begin
  Check(FileIsExecutable(Executable.ProgramFileName));
  Check(not FileIsExecutable(Executable.ProgramFilePath));
  SetLength(buf, 16 shl 20); // 16MB
  {$ifdef ASMX64NOTPIC} // activate and validate SSE2 + AVX branches
  bak := X64CpuFeatures;
  Check(IntelAvx512 - CpuFeatures * CPUAVX512FEATURES = [], 'avx512');
  Check(not (cpuAVX512 in bak) or
        (CPUAVX512X64V4 - IntelAvx512 = []), 'x86-64-v4');
  cpu := bak - [cpuHaswell, cpuAvx2, cpuAVX512];
  X64CpuFeatures := []; // default SSE2 128-bit process
  Validate({rtl=}false);
  {$ifdef ASMX64AVX1} // oldest Delphi doesn't support AVX asm
  if cpuAvx in cpu then
  begin
    X64CpuFeatures := [cpuAvx]; // AVX 256-bit process
    Validate(false);
  end;
  {$endif ASMX64AVX1}
  X64CpuFeatures := bak; // there is no AVX move/fillchar (still 256-bit wide)
  if (cpu <> []) and
     (cpu <> [cpuAvx]) then
    Validate(false);
  // no Validate(true): RedirectCode(@System.FillChar,@FillcharFast)
  {$else}
  Validate(true);
  Validate(false);
  {$endif ASMX64NOTPIC}
end;

type
  TR = record
    One: integer;
    S1: AnsiString;
    Three: byte;
    S2: WideString;
    Five: boolean;
    v: Variant;
    R: Int64Rec;
    Arr: array[0..10] of AnsiString;
    Dyn: array of integer;
    Bulk: array[0..19] of byte;
  end;

  TLicenseData = record
    CustomerNum: Integer;
    CustomerName: RawUtf8;
    CustomerAddress: RawUtf8;
    LicenceDate: TDate;
    ProductName: RawUtf8;
  end;

  TEnum = (e0, e1, e2, e3, e4);

  TPeople2 = class(TSynPersistent)
  private
    fFirstName: string;
    fLastName: RawUtf8;
    fYearOfBirth: Int64;
    fYearOfDeath: integer;
    fEnum: TEnum;
    function GetEnum: TEnum;
    procedure SetEnum(const Value: TEnum);
  published // properties are in another order
    property YearOfBirth: Int64
      read fYearOfBirth write fYearOfBirth;
    property LastName: RawUtf8
      read fLastName write fLastName;
    property FirstName: string
      read fFirstName write fFirstName;
    property YearOfDeath: integer
      read fYearOfDeath write fYearOfDeath;
    property Enum: TEnum
      read GetEnum write SetEnum;
  end;

  TPeopleR = packed record
    LastName, FirstName: RawUtf8;
    YearOfBirth, Unused: integer;
    Enum: TEnum;
  end;

  TTipoUsuario = (ti0, ti1, ti2);

  TUsuario = class(TAuthUser)
   protected
     FTipo: TTipoUsuario;
     FEmpresaID: TID;
     FIdExterno: TNullableInteger;
   public
     function IdExternoEquals(const value: variant): boolean;
   published
     property Tipo: TTipoUsuario read FTipo write FTipo;
     property EmpresaID: TID read FEmpresaID write FEmpresaID;
     property IdExterno: TNullableInteger read FIdExterno write FIdExterno;
   end;

   TDTOUsuario = packed record
     ID: Int64;
     IdExterno: variant;
     Email: RawUtf8;
     Nome: RawUtf8;
     Cpf: RawUtf8;
   end;

function TPeople2.GetEnum: TEnum;
begin
  result := fEnum;
end;

procedure TPeople2.SetEnum(const Value: TEnum);
begin
  fEnum := Value;
end;

function TUsuario.IdExternoEquals(const value: variant): boolean;
begin // circumvent weird FPC compiler issue with variant sub types
  result := VariantCompare(PVariant(@FIdExterno)^, value) = 0;
end;

procedure TTestCoreBase._Records;
var
  A, B, C: TR;
  i, j: PtrInt;
  lic: TLicenseData;
  o1: TOrmPeople;
  o2: TPeople2;
  r: TPeopleR;
  p: TRecordPeople;
  m: TRttiMap;
  fo, fr: TRttiFilter;
  err, err2: string;
  oa: TOrmPeopleObjArray;
  pa: array of TRecordPeople;
  ua: TUsuario;
  ub: TDTOUsuario;
begin
  // FillZeroRtti()
  CheckEqual(lic.CustomerName, '', 'c1');
  lic.CustomerName := 'Toto';
  FillZeroRtti(TypeInfo(TLicenseData), lic);
  CheckEqual(lic.CustomerName, '', 'c2');
  lic.CustomerName := '1234';
  FillZeroRtti(TypeInfo(TLicenseData), lic);
  CheckEqual(lic.CustomerName, '', 'c3');
  // validate RecordCopy()
  FillCharFast(A, SizeOf(A), 0);
  FillCharFast(B, SizeOf(B), 0);
  FillCharFast(C, SizeOf(C), 0);
  for i := 0 to High(A.Bulk) do
    A.Bulk[i] := i;
  A.S1 := 'one';
  A.S2 := 'two';
  A.Five := true;
  A.Three := $33;
  A.V := 'One Two';
  A.R.Lo := 10;
  A.R.Hi := 20;
  A.Arr[5] := 'five';
  SetLength(A.Dyn, 10);
  A.Dyn[9] := 9;
  RecordCopy(B, A, TypeInfo(TR)); // mORMot 2 doesn't overload RecordCopy()
  Check(A.One = B.One, 'c4');
  Check(A.S1 = B.S1, 'c5');
  Check(A.Three = B.Three);
  Check(A.S2 = B.S2);
  Check(A.Five = B.Five);
  Check(A.V = B.V);
  Check(Int64(A.R) = Int64(B.R));
  Check(A.Arr[5] = B.Arr[5]);
  Check(A.Arr[0] = B.Arr[0]);
  Check(A.Dyn[9] = B.Dyn[9]);
  Check(A.Dyn[0] = 0);
  for i := 0 to High(B.Bulk) do
    Check(B.Bulk[i] = i);
  for i := -10 to 0 do
    Check(CompareMem(@A.Bulk, @B.Bulk, i));
  for i := 0 to High(B.Bulk) do
  begin
    for j := 0 to i - 1 do
    begin
      inc(B.Bulk[j]); // validate each byte modification
      Check(not CompareMem(@A.Bulk, @B.Bulk, i));
      Check(not CompareMemSmall(@A.Bulk, @B.Bulk, i));
      Check(not CompareMemFixed(@A.Bulk, @B.Bulk, i));
      dec(B.Bulk[j]);
    end;
    Check(CompareMem(@A.Bulk, @B.Bulk, i));
    Check(CompareMemSmall(@A.Bulk, @B.Bulk, i));
    Check(CompareMemFixed(@A.Bulk, @B.Bulk, i));
  end;
  for i := 0 to High(B.Bulk) do
    Check(CompareMemSmall(@A.Bulk, @B.Bulk, i));
  for i := 0 to High(B.Bulk) do
    Check(CompareMemFixed(@A.Bulk, @B.Bulk, i));
  FillCharFast(A.Bulk, SizeOf(A.Bulk), 255);
  for i := 0 to High(B.Bulk) do
    Check(CompareMem(@A.Bulk, @B.Bulk, i) = (i = 0));
  for i := 0 to High(B.Bulk) do
    Check(CompareMemSmall(@A.Bulk, @B.Bulk, i) = (i = 0));
  for i := 0 to High(B.Bulk) do
    Check(CompareMemFixed(@A.Bulk, @B.Bulk, i) = (i = 0));
  B.Three := 3;
  B.Dyn[0] := 10;
  RecordCopy(C, B, TypeInfo(TR)); // mORMot 2 doesn't overload RecordCopy()
  CheckEqual(A.One, C.One, 'c6');
  Check(A.S1 = C.S1);
  CheckEqual(C.Three, 3);
  Check(A.S2 = C.S2);
  Check(A.Five = C.Five);
  Check(A.v = C.v);
  Check(Int64(A.R) = Int64(C.R));
  Check(A.Arr[5] = C.Arr[5]);
  Check(A.Arr[0] = C.Arr[0]);
  CheckEqual(A.Dyn[9], C.Dyn[9]);
  {Check(A.Dyn[0]=0) bug in original VCL?}
  CheckEqual(C.Dyn[0], 10);
  // TPeople2 <--> TOrmPeople class mapping
  o1 := TOrmPeople.Create;
  o2 := TPeople2.Create;
  try
    o1.FirstName := 'toto';
    o1.LastName := 'titi';
    o1.YearOfBirth := 1926;
    o1.YearOfDeath := 2010;
    CopyObject(o1, o2);
    CheckEqual(o1.FirstName, 'toto', 'c7');
    Check(o2.FirstName = 'toto', 'c8');
    CheckEqual(o1.LastName, 'titi');
    CheckEqual(o1.LastName, o2.LastName);
    CheckEqual(o1.YearOfBirth, o2.YearOfBirth);
    CheckEqual(o1.YearOfDeath, o2.YearOfDeath);
    // TRecordPeople <--> TOrmPeople record/class mapping
    p.YearOfBirth := -1;
    CheckEqual(p.YearOfBirth, -1);
    RecordZero(@p, TypeInfo(TRecordPeople));
    CheckEqual(p.FirstName, '', 'c9');
    CheckEqual(p.LastName, '');
    CheckEqual(p.YearOfBirth, 0);
    CheckEqual(p.YearOfDeath, 0);
    ObjectToRecord(o2, p, TypeInfo(TRecordPeople));
    CheckEqual(p.FirstName, 'toto', 'c10');
    CheckEqual(p.LastName, 'titi');
    CheckEqual(p.YearOfBirth, o2.YearOfBirth);
    CheckEqual(p.YearOfDeath, o2.YearOfDeath);
    o2.Enum := e1;
    ClearObject(o2);
    Check(o2.FirstName = '', 'c11');
    CheckEqual(o2.LastName, '');
    CheckEqual(o2.YearOfBirth, 0);
    CheckEqual(o2.YearOfDeath, 0);
    Check(o2.Enum = e0);
    RecordToObject(p, o2, TypeInfo(TRecordPeople));
    Check(o2.FirstName = 'toto');
    CheckEqual(o2.LastName, 'titi');
    CheckEqual(o2.YearOfBirth, p.YearOfBirth);
    CheckEqual(o2.YearOfDeath, p.YearOfDeath);
    // TPeopleR <--> TOrmPeople record/class mapping
    o2.Enum := e4;
    {$ifndef HASEXTRECORDRTTI} // oldest Delphi or FPC
    Rtti.RegisterType(TypeInfo(TEnum));
    if not RecordHasFields(TypeInfo(TPeopleR)) then
      Rtti.RegisterFromText(TypeInfo(TPeopleR),
        'LastName,FirstName:RawUtf8 YearOfBirth,Unused:integer Enum:TEnum');
    {$endif HASEXTRECORDRTTI}
    Check(RecordHasFields(TypeInfo(TPeopleR)), 'RecordHasFields');
    r.YearOfBirth := -1;
    CheckEqual(r.YearOfBirth, -1);
    RecordZero(@r, TypeInfo(TPeopleR));
    CheckEqual(r.FirstName, '');
    CheckEqual(r.LastName, '');
    CheckEqual(r.YearOfBirth, 0);
    CheckEqual(r.Unused, 0);
    Check(r.Enum = e0);
    ObjectToRecord(o2, r, TypeInfo(TPeopleR));
    CheckEqual(r.FirstName, 'toto');
    CheckEqual(r.LastName, 'titi');
    CheckEqual(r.YearOfBirth, o2.YearOfBirth);
    CheckEqual(r.Unused, 0);
    Check(r.Enum = e4);
    ClearObject(o2);
    Check(o2.FirstName = '');
    CheckEqual(o2.LastName, '');
    CheckEqual(o2.YearOfBirth, 0);
    CheckEqual(o2.YearOfDeath, 0);
    Check(o2.Enum = e0);
    RecordToObject(r, o2, TypeInfo(TPeopleR));
    Check(o2.FirstName = 'toto');
    CheckEqual(o2.LastName, 'titi');
    CheckEqual(o2.YearOfBirth, r.YearOfBirth);
    CheckEqual(o2.YearOfDeath, 0);
    Check(o2.Enum = e4);
    // TPeople2 <--> TPeopleR class/record mapping with TRttiMap
    m.Init(TPeople2, TypeInfo(TPeopleR)).AutoMap;
    RecordZero(@r, TypeInfo(TPeopleR));
    CheckEqual(r.FirstName, '');
    CheckEqual(r.LastName, '');
    CheckEqual(r.YearOfBirth, 0);
    CheckEqual(r.Unused, 0);
    Check(r.Enum = e0);
    m.ToB(o2, @r); // from class to DTO
    CheckEqual(r.FirstName, 'toto');
    CheckEqual(r.LastName, 'titi');
    CheckEqual(r.YearOfBirth, o2.YearOfBirth);
    CheckEqual(r.Unused, 0);
    Check(r.Enum = e4);
    // TPeople2 <--> TPeopleR class/record custom fields mapping with TRttiMap
    m.Init(TPeople2, TypeInfo(TPeopleR)).Map([
      'firstName',   'lastname', // inverted
      'lastname',    'firstName',
      'YearOfBirth', 'Unused']); // moved
    RecordZero(@r, TypeInfo(TPeopleR));
    CheckEqual(r.FirstName, '');
    CheckEqual(r.LastName, '');
    CheckEqual(r.YearOfBirth, 0);
    CheckEqual(r.Unused, 0);
    m.ToB(o2, @r); // from class to DTO
    CheckEqual(r.LastName, 'toto');
    CheckEqual(r.FirstName, 'titi');
    CheckEqual(r.YearOfBirth, 0);
    CheckEqual(r.Unused, o2.YearOfBirth);
    Check(r.Enum = e0);
    // TOrmPeople <--> TRecordPeople class/record fields mapping with TRttiMap
    m.Init(TOrmPeople, TypeInfo(TRecordPeople)).AutoMap;
    CheckEqual(p.FirstName, 'toto');
    CheckEqual(p.LastName, 'titi');
    CheckEqual(p.YearOfBirth, o1.YearOfBirth);
    CheckEqual(p.YearOfDeath, o1.YearOfDeath);
    o1.Free;
    o1 := m.ToA(@p); // from DTO to class
    CheckEqual(o1.FirstName, 'toto');
    CheckEqual(o1.LastName, 'titi');
    CheckEqual(p.YearOfBirth, o1.YearOfBirth);
    CheckEqual(p.YearOfDeath, o1.YearOfDeath);
    // TRttiFilter validation with o1 TOrmPeople instance
    fo := TRttiFilter.Create(o1.ClassType);
    try
      CheckEqual(fo.Count, 0);
      fo.Filter(nil);
      fo.Filter(o1);
      CheckEqual(fo.Count, 0);
      Check(fo.Validate(nil) = '');
      Check(fo.Validate(o1) = '');
      fo.Add('firstname', [TSynValidateNonVoidText.Create]);
      CheckEqual(fo.Count, 1);
      err := '???';
      err := fo.Validate(nil);
      Check(err = '', err);
      CheckEqual(o1.FirstName, 'toto');
      Check(fo.Validate(o1) = '');
      o1.FirstName := '';
      Check(fo.Validate(nil) = '');
      err2 := fo.Validate(o1);
      Check(err2 = 'FirstName: Expect at least 1 character', err2);
    finally
      fo.Free;
    end;
    // TRttiMap.RandomA/B and Compare methods - useful e.g. for testing DTOs
    m.Map('id', 'rowid');
    CheckEqual(o1.IDValue, 0, 'o1id1');
    CheckEqual(p.RowID, 0, 'pRowID1');
    for i := 1 to 100 do
    begin
      o1.IDValue := 0;
      CheckEqual(o1.IDValue, 0, 'o1id');
      p.RowID := 0;
      CheckEqual(p.RowID, 0, 'pRowID2');
      m.RandomA(o1);
      if o1.IDValue = 0 then
        m.RandomA(o1); // 1 chance over 2^64 - but not twice = 2^128
      CheckNotEqual(o1.IDValue, 0, 'rndo1id');
      CheckNotEqual(m.Compare(o1, @p), 0, 'rndA');
      CheckEqual(p.RowID, 0, 'pRowID3');
      m.ToB(o1, @p);
      CheckNotEqual(p.RowID, 0, 'pRowID4');
      CheckEqual(p.RowID, o1.IDValue, 'ids1');
      CheckEqual(m.Compare(o1, @p), 0, 'cmpA');
      p.RowID := 0;
      m.RandomB(@p);
      if p.RowID = 0 then
        m.RandomB(@p); // 1 chance over 2^64 - but not twice = 2^128
      CheckNotEqual(p.RowID, 0, 'pRowID4');
      CheckNotEqual(m.Compare(o1, @p), 0, 'rndB');
      m.ToA(o1, @p);
      CheckEqual(m.Compare(o1, @p), 0, 'cmpB');
      CheckEqual(p.RowID, o1.IDValue, 'ids2');
    end;
  finally
    o1.Free;
    o2.Free;
  end;
  // TRttiMap.ToArrayA/B methods
  Check(oa = nil);
  Check(pa = nil);
  m.ToArrayA(oa, pa);
  Check(oa = nil);
  Check(pa = nil);
  m.ToArrayB(oa, pa);
  Check(oa = nil);
  Check(pa = nil);
  SetLength(pa, 1);
  pa[0] := p;
  m.ToArrayA(oa, pa);
  CheckEqual(length(oa), 1);
  Check(oa[0] <> nil);
  CheckEqual(oa[0].FirstName, p.FirstName);
  CheckEqual(m.Compare(oa[0], @pa[0]), 0, 'array1');
  ObjArrayClear(oa);
  //  A:TDTOUsuario B:TUsuario with TNullableInteger
  Rtti.RegisterFromText(TypeInfo(TDTOUsuario),
    'ID:Int64 IdExterno:variant Email,Nome,Cpf:RawUtf8');
  m.Init(TUsuario, TypeInfo(TDTOUsuario)).AutoMap
   .Map([
     'DisplayName', 'Nome',
     'LogonName',   'Email'
  ]);
  ua := TUsuario.Create;
  try
    m.RandomA(ua);
    Check(m.Compare(ua, @ub) <> 0, 'ua0');
    m.ToA(ua, @ub);
    Check(ua.IdExternoEquals(ub.IdExterno));
    Check(m.Compare(ua, @ub) = 0, 'ua1');
    ub.IdExterno := 10;
    m.ToA(ua, @ub);
    Check(ua.IdExternoEquals(10));
  finally
    ua.Free;
  end;
  // TRttiFilter validation with p record
  fr := TRttiFilter.Create(TypeInfo(TRecordPeople));
  try
    CheckEqual(fr.Count, 0);
    fr.Filter(nil);
    p.FirstName := 'toto'; // reset the expected values
    p.LastName := 'titi';
    fr.Filter(@p);
    Check(fr.Validate(@p) = '');
    fr.AddClass('firstName', [TSynFilterUpperCase, TSynValidateNonVoidText]);
    CheckEqual(fr.Count, 2);
    CheckEqual(p.FirstName, 'toto');
    Check(fr.Validate(@p) = '');
    CheckEqual(p.FirstName, 'toto');
    Check(fr.Apply(@p) = '');
    CheckEqual(p.FirstName, 'TOTO');
    p.FirstName := '';
    err := fr.Validate(@p);
    Check(err = err2, err);
    err := fr.Apply(@p);
    Check(err = err2, err);
    CheckEqual(fr.Count, 2);
    fr.Clear;
    CheckEqual(fr.Count, 0);
    Check(fr.Validate(@p) = '');
    CheckEqual(p.FirstName, '');
    Check(fr.Apply(@p) = '');
    CheckEqual(p.FirstName, '');
    fr.AddClass('firstName', [TSynFilterLowerCase, TSynValidateNonVoidText]);
    CheckEqual(fr.Count, 2);
    fr.AddClass('lastNAME', [TSynValidateNonVoidText]);
    CheckEqual(fr.Count, 3);
    err := fr.Apply(@p);
    Check(err = err2, err);
    p.FirstName := 'TOTO';
    Check(fr.Validate(@p) = '');
    CheckEqual(p.FirstName, 'TOTO');
    Check(fr.Apply(@p) = '');
    CheckEqual(p.FirstName, 'toto');
    p.LastName := '';
    err := fr.Apply(@p);
    Check(err = 'LastName: Expect at least 1 character', err);
    p.FirstName := '';
    err := fr.Apply(@p);
    Check(err = err2, err);
  finally
    fr.Free;
  end;
end;

procedure TTestCoreBase._TSynList;
const
  MAX = 1000;
var
  {$ifdef FPC}
  p: TOrm; // FPC can iterate over pointers as class instances but not Delphi :(
  {$else}
  p: pointer;
  {$endif FPC}
  i: PtrInt;
  l: TSynList;
begin
  l := TSynList.Create;
  try
   CheckEqual(l.Count, 0);
   Check(not l.Exists(nil));
   Check(l.IndexOf(nil) < 0);
   for i := 0 to MAX - 1 do
     CheckEqual(l.Add(pointer(i)), i);
   CheckEqual(l.Count, MAX);
   Check(l.Exists(nil));
   for i := 0 to MAX - 1 do
     Check(l[i] = pointer(i));
   CheckEqual(l.IndexOf(nil), 0);
   p := l[MAX - 1];
   CheckEqual(l.IndexOf(p), MAX - 1);
   {$ifdef HASITERATORS}
   i := 0;
   for p in l do
   begin
     CheckEqual(PtrInt(p), i);
     inc(i);
   end;
   {$endif HASITERATORS}
  finally
    l.Free;
  end;
end;

procedure TTestCoreBase._GUID;
var
  i, j: integer;
  s, x, x2: RawUtf8;
  st, st2: string;
  g, g2: TGuid;
  h, h2: THash512Rec;
  pt: TRttiParserType;
const
  Guid: TGuid = '{c9a646d3-9c61-4cb7-bfcd-ee2522c8f633}';
begin
  CheckEqual(BitsToBytes(0), 0);
  for i := 1 to 8 do
    CheckEqual(BitsToBytes(i), 1);
  for i := 9 to 15 do
    CheckEqual(BitsToBytes(i), 2);
  s := GuidToRawUtf8(Guid);
  CheckEqual(s, '{C9A646D3-9C61-4CB7-BFCD-EE2522C8F633}');
  Check(s[16] = '4');
  Check(s[21] in ['8', '9', 'A', 'B']);
  Check(IsRandomGuid(@Guid));
  Check(TextToGuid(@s[2], @g2)^ = '}');
  Check(IsEqualGuid(g2, Guid));
  Check(GuidToString(Guid) = '{C9A646D3-9C61-4CB7-BFCD-EE2522C8F633}');
  Check(IsEqualGuid(RawUtf8ToGuid(s), Guid));
  Check(TrimGuid(s));
  CheckEqual(s, 'c9a646d39c614cb7bfcdee2522c8f633');
  FillZero(g);
  CheckEqual(GuidArrayToCsv([]), '');
  CheckEqual(GuidArrayToCsv([g]), '00000000-0000-0000-0000-000000000000');
  CheckEqual(GuidArrayToCsv([Guid, g, g2]),
    'C9A646D3-9C61-4CB7-BFCD-EE2522C8F633,00000000-0000-0000-0000-000000000000,' +
    'C9A646D3-9C61-4CB7-BFCD-EE2522C8F633');
  CheckEqual(MacTextFromHex(''), '');
  CheckEqual(MacTextFromHex('1'), '');
  CheckEqual(MacTextFromHex('12'), '12');
  CheckEqual(MacTextFromHex('123'), '');
  CheckEqual(MacTextFromHex('1234'), '12:34');
  CheckEqual(MacTextFromHex('12345'), '');
  ToHumanHex(x, @Guid, SizeOf(guid));
  CheckEqual(x, 'd3:46:a6:c9:61:9c:b7:4c:bf:cd:ee:25:22:c8:f6:33');
  CheckEqual(MacTextFromHex(mormot.core.text.BinToHex(@Guid, SizeOf(guid))), x);
  ToHumanHex(x, @Guid, SizeOf(guid), {reverse=}true);
  CheckEqual(x, '33:f6:c8:22:25:ee:cd:bf:4c:b7:9c:61:c9:a6:46:d3');
  x := 'c9:a6:46:d3:9c:61:4c:b7:bf:cd:ee:25:22:c8:f6:33';
  CheckEqual(MacTextFromHex(s), x);
  CheckEqual(MacTextFromHex(UpperCase(s)), x);
  CheckEqual(HumanHexCompare(x, x), 0);
  CheckEqual(HumanHexCompare(x, MacTextFromHex(s)), 0);
  x := MacToText(@Guid);
  CheckEqual(x, 'd3:46:a6:c9:61:9c');
  FillZero(g);
  CheckEqual(MacToText(@g), '00:00:00:00:00:00');
  Check(TextToMac(pointer(x), @g));
  CheckEqual(MacToText(@g), x);
  for i := 1 to 100 do
  begin
    x2 := x;
    delete(x2, rnd.Next(length(x2)) + 1, 2);
    Check(x <> x2);
    Check(HumanHexCompare(x, x2) <> 0);
    HumanHexCompare(x, x2);
  end;
  for i := 1 to 100 do
  begin
    x2 := x;
    j := rnd.Next(length(x2)) + 1;
    delete(x2, j, 1);
    Check(x <> x2);
    Check((HumanHexCompare(x, x2) = 0) = (x[j] = ':'));
  end;
  x2 := x;
  repeat
    i := PosExChar(':', x2);
    if i = 0 then
      break;
    delete(x2, i, 1);
    CheckEqual(HumanHexCompare(x, x2), 0);
  until false;
  delete(x2, 10, 2);
  Check(HumanHexCompare(x, x2) <> 0);
  s := s + s; // validates also our patched RTL
  CheckEqual(HumanHexCompare(s, s), 0);
  repeat
    i := rnd.Next(length(s)) + 1;
    delete(s, i, 1);
    Check(TrimGuid(s) = (length(s) = 32));
  until s = '';
  s := '   ';
  Check(not TrimGuid(s));
  CheckEqual(s, '');
  Check(not TrimGuid(s));
  CheckEqual(s, '');
  s := 'C9A646D3-9C61-4CB7-BFCD-EE2522C8F633';
  Check(IsEqualGuid(RawUtf8ToGuid(s), Guid));
  Check(TrimGuid(s));
  CheckEqual(s, 'c9a646d39c614cb7bfcdee2522c8f633');
  s := 'C9A646D39C614CB7BFCDEE2522C8F633';
  Check(IsEqualGuid(RawUtf8ToGuid(s), Guid));
  Check(TrimGuid(s));
  CheckEqual(s, 'c9a646d39c614cb7bfcdee2522c8f633');
  Check(TrimGuid(s));
  CheckEqual(s, 'c9a646d39c614cb7bfcdee2522c8f633');
  s[3] := 'Z';
  Check(not TrimGuid(s));
  CheckEqual(s, 'c9Z646d39c614cb7bfcdee2522c8f633');
  s := '   1234 678 --';
  Check(not TrimGuid(s));
  CheckEqual(s, '1234678');
  for i := 1 to 1000 do
  begin
    if i and 1 = 0 then
      RandomGuid(g)
    else
      TAesPrng.Main.FillGuid(g);
    Check(IsRandomGuid(@g));
    st := GuidToString(g);
    Check(st <> st2);
    st2 := SysUtils.GuidToString(g);
    Check(st = st2);
    Check(IsEqualGuid(StringToGuid(st), g));
    s := GuidToRawUtf8(g);
    Check(s[16] = '4');
    Check(s[21] in ['8', '9', 'A', 'B']);
    Check(st = mormot.core.unicode.Utf8ToString(s));
    st[rnd.Next(38) + 1] := ' ';
    g2 := StringToGuid(st);
    Check(IsZero(@g2, SizeOf(g2)));
    Check(TextToGuid(@s[2], @g2)^ = '}');
    Check(IsEqualGuid(g2, g));
    Check(IsEqualGuid(@g2, @g));
    Check(TrimGuid(s));
    CheckEqual(length(s), 32);
    Check(IsEqualGuid(RawUtf8ToGuid(s), g));
    inc(g.D1);
    Check(not IsEqualGuid(g2, g));
    Check(not IsEqualGuid(RawUtf8ToGuid(s), g));
  end;
  // oldest Delphi can't compile TypeInfo(TGuid) -> use PT_INFO[ptGuid]
  s := RecordSaveJson(g, PT_INFO[ptGuid]);
  FillCharFast(g2, SizeOf(g2), 0);
  Check(RecordLoadJsonInPlace(g2, pointer(s), PT_INFO[ptGuid]) <> nil);
  Check(IsEqualGuid(g2, g));
  FillCharFast(h, SizeOf(h), 1);
  for pt := ptGuid to ptHash512 do
  begin
    rnd.Fill(@h, PT_SIZE[pt]);
    s := SaveJson(h, PT_INFO[pt]); // ptHash* are not record types
    CheckUtf8(TextToVariantNumberType(pointer(s)) = varString,
      '%:%', [PT_INFO[pt].RawName, s]);
    FillCharFast(h2, SizeOf(h2), 0);
    Check(LoadJsonInPlace(h2, pointer(s), PT_INFO[pt]) <> nil);
    CheckUtf8(CompareMem(@h, @h2, PT_SIZE[pt]), '%', [PT_INFO[pt].RawName]);
  end;
  // validate IdentifierGuid()/DotNetIdentifierGuid()
  IdentifierGuid('www.opentofu.org', g, UUID_DNS);
  ToUtf8(g, s, @TwoDigitsHexLower);
  CheckEqual(s, 'df1e675d-b743-5f6c-9952-6311d0f141df');
  Check(not IsRandomGuid(@g), 'from identifier');
  IdentifierGuid('https://www.opentofu.org/', g, UUID_URL);
  ToUtf8(g, s, @TwoDigitsHexLower);
  CheckEqual(s, 'ace93eea-1a2c-5eed-b41b-718be15d2e50');
  IdentifierGuid('1.3.6.1.4', g, UUID_OID);
  ToUtf8(g, s, @TwoDigitsHexLower);
  CheckEqual(s, 'af9d40a5-7a36-5c07-b23a-851cd99fbfa5');
  IdentifierGuid('CN=Example,C=GB', g, UUID_X500);
  ToUtf8(g, s, @TwoDigitsHexLower);
  CheckEqual(s, '84e09961-4aa4-57f8-95b7-03edb1073253');
  DotNetIdentifierGuid('MyCompany.MyComponent', g);
  ToUtf8(g, s, @TwoDigitsHexLower);
  CheckEqual(s, 'ce5fa4ea-ab00-5402-8b76-9f76ac858fb5');
  Check(not IsRandomGuid(@g), 'from identifier');
  DotNetIdentifierGuid('YourProviderNameYourProviderName', g);
  ToUtf8(g, s, @TwoDigitsHexLower);
  CheckEqual(s, '6f8eac67-f87f-598a-71a0-67e48d8c468d');
  Check(not IsRandomGuid(@g), 'from identifier');
end;

procedure TTestCoreBase._ParseCommandArgs;

  procedure Test(const cmd: RawUtf8; const expected: array of RawUtf8;
     const flags: TParseCommands = []; posix: boolean = true);
  var
    tmp: RawUtf8;
    n, i: integer; // integer, not PtrInt
    a: TParseCommandsArgs;
    p: TRawUtf8DynArray;
  begin
    if CheckFailed(ParseCommandArgs(cmd, nil, nil, nil, posix) = flags) then
      exit;
    FillcharFast(a, SizeOf(a), 255); // ensure a[n]<>nil
    Check(ParseCommandArgs(cmd, @a, @n, @tmp, posix) = flags);
    if (flags <> []) or
       CheckFailed(n = length(expected)) then
      exit;
    for i := 0 to n - 1 do
      Check(StrComp(pointer(a[i]), pointer(expected[i])) = 0);
    Check(a[n] = nil, 'last param should be nil');
    Check(ExtractCommandArgs(cmd, p, posix) = flags);
    if Check(n = length(p)) then
      for i := 0 to n - 1 do
        CheckEqual(p[i], expected[i]);
  end;

begin
  Test('', [], [pcInvalidCommand]);
  Test('one', ['one']);
  Test('o', ['o']);
  Test(' o', ['o']);
  Test('one two', ['one', 'two']);
  Test('    one     two    ', ['one', 'two']);
  Test('"one" two', ['one', 'two']);
  Test('one "two"', ['one', 'two']);
  Test('one     "two"', ['one', 'two']);
  Test('one " two"', ['one', ' two']);
  Test('" one" two', [' one', 'two']);
  Test(''' one'' two', [' one', 'two']);
  Test('"one one" two', ['one one', 'two']);
  Test('one "two two"', ['one', 'two two']);
  Test('"1  2"    "3    4"', ['1  2', '3    4']);
  Test('"1 '' 2"    "3    4"', ['1 '' 2', '3    4']);
  Test('''1  2''    "3    4"', ['1  2', '3    4']);
  Test('1 ( "3    4"', [], [pcHasParenthesis]);
  Test('1 "3  "  4"', [], [pcUnbalancedDoubleQuote]);
  Test(''' "3  4"', [], [pcUnbalancedSingleQuote]);
  Test('one|two', [], [pcHasRedirection]);
  Test('one\|two', ['one|two'], []);
  Test('"one|two"', ['one|two']);
  Test('one>two', [], [pcHasRedirection]);
  Test('one\>two', ['one>two'], []);
  Test('"one>two"', ['one>two']);
  Test('one&two', [], [pcHasJobControl]);
  Test('one\&two', ['one&two'], []);
  Test('"one&two"', ['one&two']);
  Test('one`two', [], [pcHasSubCommand]);
  Test('''one`two''', ['one`two']);
  Test('one$two', [], [pcHasShellVariable]);
  Test('''one$two''', ['one$two']);
  Test('one$(two)', [], [pcHasSubCommand, pcHasParenthesis]);
  Test('one\$two', ['one$two'], []);
  Test('''one$(two)''', ['one$(two)']);
  Test('one*two', [], [pcHasWildcard]);
  Test('"one*two"', ['one*two']);
  Test('one*two', [], [pcHasWildcard]);
  Test('''one*two''', ['one*two']);
  Test('one\ two', ['one two'], []);
  Test('one\\two', ['one\two'], []);
  Test('one\\\\\\two', ['one\\\two'], []);
  Test('one|two', [], [pcHasRedirection], {posix=}false);
  Test('one&two', ['one&two'], [], false);
  Test(''' one'' two', ['''', 'one''', 'two'], [], false);
  Test('"one" two', ['one', 'two'], [], false);
  Test('one "two"', ['one', 'two'], [], false);
  Test('one     "two"', ['one', 'two'], [], false);
  Test('one " two"', ['one', ' two'], [], false);
  Test('" one" two', [' one', 'two'], [], false);
  Test('"one one" two', ['one one', 'two'], [], false);
end;

procedure TTestCoreBase._TExecutableCommandLine;
var
  c: TExecutableCommandLine;
  f: RawUtf8;
  t: integer;
begin
  c := TExecutableCommandLine.Create;
  try
    c.RawParams := CsvToRawUtf8DynArray('one two three', ' ');
    c.Parse(#10, '-', '--');
    CheckEqual(length(c.Args), 3);
    CheckEqual(length(c.Options), 0);
    CheckEqual(length(c.Names), 0);
    CheckEqual(length(c.Values), length(c.Names));
    Check(c.Arg('one', 'this is 1'));
    Check(c.Arg('two', 'this is 2'));
    Check(c.Arg('three', 'this is 3'));
    CheckEqual(c.DetectUnknown, '');
    CheckHash(c.FullDescription('this is test #1 executable', 'exename'), $9147E5C5);
    c.Clear;
    c.RawParams := CsvToRawUtf8DynArray('one two three', ' ');
    c.Parse(#10, '-', '--');
    CheckEqual(length(c.Args), 3);
    CheckEqual(length(c.Options), 0);
    CheckEqual(length(c.Names), 0);
    CheckEqual(length(c.Values), length(c.Names));
    Check(c.Arg(0, 'this is the main verb'));
    Check(c.Arg(1, 'the #directory name to process'));
    Check(c.Arg(2, 'some #comment text to add'));
    CheckHash(c.FullDescription('this is test #2 executable', 'exename'), $DDDDB7D4);
    Check(not c.Option('&verbose', 'generate verbose output'));
    CheckHash(c.FullDescription('this is test #2 executable', 'exename'), $2293B264);
    Check(not c.Get('logfolder', f, 'optional log #folder to write to'));
    Check(not c.Option('log', 'log the process to a local file'));
    Check(not c.Get('&threads', t, '#number of threads to run'));
    CheckEqual(c.DetectUnknown, '');
    CheckHash(c.FullDescription('this is test #2 executable', 'exename'), $3CFE0EB3);
    c.Clear;
    c.RawParams := CsvToRawUtf8DynArray('-t=10 --dest toto -v --wrong -p=4', ' ');
    c.Parse(#10, '-', '--');
    CheckEqual(length(c.Args), 0);
    CheckEqual(length(c.Options), 2);
    CheckEqual(length(c.Names), 3);
    CheckEqual(length(c.Values), length(c.Names));
    Check(c.Option('&verbose', 'generate verbose output'));
    Check(not c.Option('log', 'log the process to a local file'));
    t := 0;
    Check(c.Get('&threads', t, '#number of threads to run', 5));
    CheckEqual(t, 10);
    f := c.Param('dest', 'destination #folder', 'c:\');
    CheckEqual(f, 'toto');
    Check(not c.Get('logdest', f, 'optional log #folder'));
    CheckEqual(f, '');
    CheckHash(c.DetectUnknown, $5EA096A5);
    CheckHash(c.FullDescription('this is test #3 executable', 'exename'), $DFE40A21);
    c.Clear;
    c.RawParams := CsvToRawUtf8DynArray('-o file.txt --y -v -t 1', ' ');
    c.Parse(#10, '-', '--');
    CheckEqual(length(c.Args), 0);
    CheckEqual(length(c.Options), 2);
    CheckEqual(length(c.Names), 2);
    CheckEqual(length(c.Values), length(c.Names));
    Check(c.Option('y'));
    Check(c.Option('v'));
    Check(c.Get('o', f));
    CheckEqual(f, 'file.txt');
    Check(c.Get('t', t));
    CheckEqual(t, 1);
    // regression for #654: positional argument after a parameter
    c.Clear;
    c.RawParams := CsvToRawUtf8DynArray(
      '--run /config /opt/porter/x.config', ' ');
    Check(c.Parse(#10, '-', '--'));
    Check(c.Get('run', f));
    CheckEqual(f, '/config');
    CheckEqual(c.Args[0], '/opt/porter/x.config');
    CheckEqual(c.DetectUnknown, 'Unexpected "/opt/porter/x.config" argument'#10);
  finally
    c.Free;
  end;
end;

function GL(a, b: PAnsiChar; const c: RawUtf8): boolean;
begin
  // avoid Delphi compiler complains about PUtf8Char/PAnsiChar types
  result := GetLineContains(pointer(a), pointer(b), pointer(c));
end;

procedure TTestCoreBase._IsMatch;
var
  i, j: integer;
  V, cont: RawUtf8;
  match: TMatch;
  reuse, isword: boolean;

  procedure Contains;
  begin
    check(match.Match('12'));
    check(match.Match('12e'));
    check(match.Match('12er'));
    check(match.Match('a12'));
    check(match.Match('a12e'));
    check(match.Match('ab12'));
    check(match.Match('ab12er'));
    check(not match.Match('1'));
    check(not match.Match('a1'));
    check(not match.Match('a1b2'));
    check(not match.Match('1a2'));
  end;

begin
  V := '123456789ABC'#10'DEF0zxy';
  Check(GL(@V[1], nil, '1'));
  Check(GL(@V[1], nil, 'C'));
  Check(GL(@V[1], nil, '89'));
  Check(not GL(@V[1], nil, 'ZX'));
  Check(GL(@V[14], nil, 'ZXY'));
  Check(not GL(@V[1], nil, '890'));
  Check(GL(@V[1], @V[21], '89'));
  Check(GL(@V[14], @V[21], 'ZX'));
  Check(not GL(@V[1], @V[21], 'ZX'));
  Check(GL(@V[14], @V[21], 'ZXY'));
  Check(not GL(@V[1], @V[5], '89'));
  Check(not GL(@V[1], @V[15], 'ZXY'));
  Check(not GL(@V[14], @V[17], 'ZXY'));
  V := '1234567890123456'#13'1234567890123456789';
  for j := 1 to 16 do
  begin
    for i := j to 16 do
    begin
      CheckEqual(BufferLineLength(@V[j], @V[i]), i - j);
      CheckEqual(GetLineSize(@V[j], @V[i]), i - j);
    end;
    for i := 17 to 34 do
    begin
      CheckEqual(BufferLineLength(@V[j], @V[i]), 17 - j);
      CheckEqual(GetLineSize(@V[j], @V[i]), 17 - j);
    end;
    CheckEqual(GetLineSize(@V[j], nil), 17 - j);
  end;
  V := '12345678901234561234567890123456'#10'1234567890123456789';
  for j := 1 to 32 do
  begin
    for i := j to 32 do
    begin
      CheckEqual(BufferLineLength(@V[j], @V[i]), i - j);
      CheckEqual(GetLineSize(@V[j], @V[i]), i - j);
    end;
    for i := 33 to 50 do
    begin
      CheckEqual(BufferLineLength(@V[j], @V[i]), 33 - j);
      CheckEqual(GetLineSize(@V[j], @V[i]), 33 - j);
    end;
    CheckEqual(GetLineSize(@V[j], nil), 33 - j);
  end;
  Check(IsMatch('', '', true));
  Check(not IsMatch('', 'toto', true));
  Check(not IsMatch('Bidule.pas', '', true));
  Check(IsMatch('Bidule.pas', 'Bidule.pas', true));
  Check(IsMatch('Bidule.pas', 'BIDULE.pas', true));
  Check(IsMatch('Bidule.pas', 'Bidule.paS', true));
  Check(IsMatch('Bidule.pas', 'Bidule.pas', false));
  Check(not IsMatch('Bidule.pas', 'bidule.pas', false));
  Check(not IsMatch('bidule.pas', 'bidulE.pas', false));
  Check(not IsMatch('bidule.pas', 'bidule.paS', false));
  Check(not IsMatch('bidule.pas', 'bidule.pa', false));
  for i := 0 to 200 do
  begin
    V := Int32ToUtf8(i);
    Check(IsMatch(V, V, false) = IsMatch(V, V, true));
  end;
  Check(IsMatch('test*', 'test', false));
  Check(IsMatch('test*', 'test', true));
  Check(IsMatch('test*', 'teste', false));
  Check(IsMatch('test*', 'teste', true));
  Check(IsMatch('test*', 'tester', false));
  Check(IsMatch('test*', 'tester', true));
  Check(IsMatch('a*', 'anything', true));
  Check(IsMatch('a*', 'a', true));
  Check(IsMatch('*', 'anything', true));
  Check(IsMatch('*.pas', 'Bidule.pas', true));
  Check(IsMatch('*.pas', 'Bidule.pas', false));
  Check(IsMatch('*.PAS', 'Bidule.pas', true));
  Check(not IsMatch('*.PAS', 'Bidule.pas', false));
  Check(IsMatch('*.p?s', 'Bidule.pas', true));
  Check(IsMatch('*.p*S', 'Bidule.pas', true));
  Check(IsMatch('B*.PAS', 'bidule.pas', true));
  Check(IsMatch('*.p?s', 'bidule.pas', false));
  Check(IsMatch('*.p*s', 'bidule.pas', false));
  Check(IsMatch('b*.pas', 'bidule.pas', false));
  Check(not IsMatch('B*.das', 'Bidule.pas', true));
  Check(IsMatch('bidule.*', 'Bidule.pas', true));
  Check(IsMatch('ma?ch.*', 'match.exe', false));
  Check(IsMatch('ma?ch.*', 'mavch.dat', false));
  Check(IsMatch('ma?ch.*', 'march.on', false));
  Check(IsMatch('ma?ch.*', 'march.', false));
  Check(IsMatch('ab*.exyz', 'ab.exyz', true));
  Check(IsMatch('ab[ef]xyz', 'abexyz', false));
  Check(IsMatch('ab[ef]xyz', 'abexyz', true));
  Check(IsMatch('ab*.[ef]xyz', 'abcd.exyz', true));
  Check(IsMatch('ab*.[ef]xyz', 'ab.exyz', true));
  Check(IsMatch('ab*.[ef]xyz', 'abcd.exyz', true));
  Check(IsMatch('ab*.[ef]xyz', 'ab.fxyz', true));
  Check(IsMatch('ab*.[ef]xyz', 'abcd.fxyz', true));
  check(not IsMatch('ab[cd]e', 'abdde', false));
  check(not IsMatch('ab[cd]ex', 'abddex', false));
  check(not IsMatch('ab*.[cd]e', 'ab.dde', false));
  check(not IsMatch('ab*.[cd]ex', 'ab.ddex', false));
  V := 'this [e-n]s a [!zy]est';
  check(not IsMatch(V, V, false));
  Check(IsMatch(V, 'this is a test', false));
  Check(IsMatch(V, 'this is a rest', false));
  Check(not IsMatch(V, 'this is a zest', false));
  Check(not IsMatch(V, 'this as a test', false));
  Check(not IsMatch(V, 'this as a rest', false));
  Check(IsMatchs('test*', 'test', false));
  Check(IsMatchs('test*', 'test', true));
  Check(IsMatchs('test*', 'teste', false));
  Check(IsMatchs('test*', 'teste', true));
  Check(IsMatchs('test*', 'tester', false));
  Check(IsMatchs('test*', 'tester', true));
  Check(IsMatchs('a*', 'anything', true));
  Check(IsMatchs('a*', 'a', true));
  Check(IsMatchs('*', 'anything', true));
  Check(IsMatchs('*.pas', 'Bidule.pas', true));
  Check(IsMatchs('*.pas', 'Bidule.pas', false));
  Check(IsMatchs('*.PAS', 'Bidule.pas', true));
  Check(not IsMatchs('*.PAS', 'Bidule.pas', false));
  Check(IsMatchs('toto,test*', 'test', false));
  Check(IsMatchs('test*,toto', 'test', true));
  Check(IsMatchs('toto,titi,test*', 'teste', false));
  Check(IsMatchs('test*,titi,toto', 'teste', true));
  Check(IsMatchs('toto,test*,titi', 'tester', false));
  Check(IsMatchs('tata,test*', 'tester', true));
  Check(IsMatchs('a*,toto', 'anything', true));
  Check(IsMatchs('toto,a*', 'a', true));
  Check(IsMatchs('*,titi', 'anything', true));
  Check(IsMatchs('*.pas,*.txt', 'Bidule.pas', true));
  Check(IsMatchs('*.txt,*.pas', 'Bidule.pas', false));
  Check(IsMatchs('*.PAS,*.pas', 'Bidule.pas', false));
  Check(IsMatchs('*.txt,*.PAS', 'Bidule.pas', true));
  Check(not IsMatchs('*.PAS,*.pAs,*.PAs', 'Bidule.pas', false));
  for reuse := false to true do
  begin  // ensure very same behavior
    match.Prepare(V, false, reuse);
    Check(not match.Match(V));
    Check(match.Match('this is a test'));
    Check(match.Match('this is a rest'));
    Check(not match.Match('this is a zest'));
    match.Prepare('test', false, reuse);
    check(match.Match('test'));
    check(not match.Match('tes'));
    check(not match.Match('tests'));
    check(not match.Match('tesT'));
    match.Prepare('teST', true, reuse);
    check(match.Match('test'));
    check(match.Match('test'));
    match.Prepare('*', false, reuse);
    check(match.Match('test'));
    check(match.Match('tests'));
    match.Prepare('*', true, reuse);
    check(match.Match('test'));
    check(match.Match('tests'));
    match.Prepare('**', false, reuse);
    check(match.Match('test'));
    check(match.Match('tests'));
    match.Prepare('****', false, reuse);
    check(match.Match('test'));
    check(match.Match('tests'));
    match.Prepare('*.*', false, reuse);
    check(match.Match('te.st'));
    check(match.Match('te.st.'));
    check(match.Match('test.'));
    check(match.Match('.test'));
    check(match.Match('.'));
    check(not match.Match('test'));
    match.Prepare('*.*', true, reuse);
    check(match.Match('te.st'));
    check(match.Match('te.st.'));
    check(match.Match('test.'));
    check(match.Match('.test'));
    check(not match.Match('test'));
    check(match.Match('.'));
    match.Prepare('test*', false, reuse);
    check(match.Match('test'));
    check(match.Match('tests'));
    check(match.Match('tester'));
    check(not match.Match('atest'));
    check(not match.Match('tes'));
    check(not match.Match('tEst'));
    check(not match.Match('tesT'));
    check(not match.Match('t'));
    match.Prepare('*test', false, reuse);
    check(match.Match('test'));
    check(match.Match('stest'));
    check(match.Match('attest'));
    check(not match.Match('est'));
    check(not match.Match('testa'));
    check(not match.Match('tes'));
    check(not match.Match('tEst'));
    check(not match.Match('tesT'));
    check(not match.Match('t'));
    match.Prepare('*t', false, reuse);
    check(match.Match('t'));
    check(match.Match('st'));
    check(match.Match('tt'));
    check(match.Match('att'));
    check(not match.Match('s'));
    check(not match.Match('es'));
    check(not match.Match('ts'));
    match.Prepare('**', false, reuse);
    check(match.Match('') = reuse);
    check(match.Match('test'));
    match.Prepare('*test*', false, reuse);
    check(match.Match('test'));
    check(match.Match('tests'));
    check(match.Match('tester'));
    check(match.Match('atest'));
    check(match.Match('ateste'));
    check(match.Match('abtest'));
    check(match.Match('abtester'));
    check(not match.Match('tes'));
    check(not match.Match('ates'));
    check(not match.Match('tesates'));
    check(not match.Match('tesT'));
    check(not match.Match('Teste'));
    check(not match.Match('TEster'));
    check(not match.Match('atEst'));
    check(not match.Match('ateSTe'));
    match.Prepare('*12*', false, reuse);
    Contains;
    if reuse then
    begin
      cont := '12';
      match.PrepareContains(cont, false);
      Contains;
      cont := '12';
      match.PrepareContains(cont, true);
      Contains;
    end;
    match.Prepare('*teSt*', true, reuse);
    check(match.Match('test'));
    check(match.Match('teste'));
    check(match.Match('tester'));
    check(match.Match('atest'));
    check(match.Match('ateste'));
    check(match.Match('abtest'));
    check(match.Match('abtester'));
    check(match.Match('tesT'));
    check(match.Match('Teste'));
    check(match.Match('TEster'));
    check(match.Match('atEst'));
    check(match.Match('ateSTe'));
    check(match.Match('abteST'));
    check(match.Match('abtEster'));
    check(not match.Match('tes'));
    check(not match.Match('ates'));
    check(not match.Match('tesates'));
    match.Prepare('*te?t*', true, reuse);
    check(match.Match('test'));
    check(match.Match('tezt'));
    check(match.Match('teste'));
    check(match.Match('tezte'));
    check(match.Match('tester'));
    check(match.Match('atest'));
    check(match.Match('ateste'));
    check(not match.Match('tes'));
    check(not match.Match('tet'));
    check(not match.Match('ates'));
    check(not match.Match('tesates'));
    match.Prepare('?est*', true, reuse);
    check(match.Match('test'));
    check(match.Match('test'));
    check(match.Match('teste'));
    check(match.Match('tester'));
    check(not match.Match('tezte'));
    check(not match.Match('atest'));
    check(not match.Match('est'));
    check(not match.Match('este'));
    check(not match.Match('tes'));
    check(not match.Match('tet'));
    check(not match.Match('ates'));
    check(not match.Match('tesates'));
    match.Prepare('a*bx*cy*d', false, reuse);
    check(match.Match('abxcyd'));
    check(match.Match('a1bxcyd'));
    check(match.Match('a12bxcyd'));
    check(match.Match('a123bxcyd'));
    check(match.Match('abx1cyd'));
    check(match.Match('abx12cyd'));
    check(match.Match('abxcy1d'));
    check(match.Match('abxcy12d'));
    check(match.Match('abxcy123d'));
    check(not match.Match('abcyd'));
    check(not match.Match('abxcyde'));
    match.Prepare(
      '************************************************' +
      '************************************************' +
      '**************************************************.*', false, reuse);
    check(match.MatchThreadSafe('abxcyd.'));
    check(match.MatchThreadSafe('abxc.yd'));
    check(match.MatchThreadSafe('abxcy.d'));
    check(match.MatchThreadSafe('.'));
    check(match.MatchThreadSafe('.a'));
    check(match.MatchThreadSafe('.abxcyd'));
    check(not match.MatchThreadSafe('abxcyd'));
  end;
  for i := 32 to 127 do
  begin
    SetLength(V, 1);
    V[1] := AnsiChar(i);
    isword := (tcWord in TEXT_BYTES[i]);
    Check(IsMatch('[A-Za-z0-9]', V) = isword);
    Check(IsMatch('[01-456a-zA-Z789]', V) = isword);
    SetLength(V, 3);
    V[1] := AnsiChar(i);
    V[2] := AnsiChar(i);
    V[3] := AnsiChar(i);
    Check(IsMatch('[A-Za-z0-9]?[A-Za-z0-9]', V) = isword);
    Check(IsMatch('[A-Za-z0-9]*', V) = isword);
    Check(IsMatch('[a-z0-9]?[A-Z0-9]', V, true) = isword);
    Check(IsMatch('[A-Z0-9]*', V, true) = isword);
  end;
end;

procedure TTestCoreBase._TExprParserMatch;
var
  s: TExprParserMatch;

  procedure Test(const expression: RawUtf8; const ok, nok: array of RawUtf8);
  var
    i: PtrInt;
  begin
    Check(s.Parse(expression) = eprSuccess);
    for i := 0 to high(ok) do
      Check(s.Search(ok[i]));
    for i := 0 to high(nok) do
      Check(not s.Search(nok[i]));
  end;

begin
  s := TExprParserMatch.Create({casesensitive=}true);
  try // &=AND -=WITHOUT +=OR
    check(s.Parse('') = eprNoExpression);
    check(s.Parse('  ') = eprNoExpression);
    check(s.Parse('1+ ') = eprMissingFinalWord);
    Test('1', ['1', '1 2 3', '2 1'],
              ['2', '13', '2 3']);
    Test('   1   ', ['1', '1 2 3', '2 1'],
                    ['2', '13', '2 3']);
    Test('1+4', ['1', '1 2 3', '2 1', '2 4 3'],
                ['2', '13', '2 3', '41']);
    Test(' 1 + 4 ', ['1', '1 2 3', '2 1', '2 4 3'],
                    ['2', '13', '2 3', '41']);
    Test('1+4+5', ['1', '1 2 3', '2 1', '2 4 3'],
                  ['2', '13', '2 3', '41']);
    Test('1+(4+5)', ['1', '1 2 3', '2 1', '2 4 3'],
                    ['2', '13', '2 3', '41']);
    Test('1+4*+5', ['1', '1 2 3', '2 1', '2 4 3', '41'],
                   ['2', '13', '2 3']);
    Test('1+(4&555)', ['4 555 3', '555 4', '1', '1 2 3', '2 1'],
                      ['2', '13', '2 3', '41', '4 3', '3 555']);
    Test('1+(4 555)', ['4 555 3', '555 4', '1', '1 2 3', '2 1'],
                      ['2', '13', '2 3', '41', '4 3', '3 555']);
    Test('1-4', ['1', '1 2 3', '2 1', '2 1 3'],
                ['1 4', '4 2 1', '2', '13', '2 3', '41']);
    Test('1-(4&5)', ['1', '1 2 3', '2 1', '1 4', '1 5'],
                    ['2', '5 2 3 4 1', '2 3', '41', '4 3', '3 5', '1 4 5']);
    Test('1-(4&(5+6))', ['1', '1 2 3', '2 1', '1 4', '1 5', '1 6'],
        ['2', '5 2 3 4 1', '2 3', '41', '4 3', '3 5', '1 4 5', '1 4 6']);
    Test('1 - ( 4 & ( 57 + 6 ) )', ['1', '1 2 3', '2 1', '1 4', '1 57', '1 6'],
        ['2', '57 2 3 4 1', '2 3', '41', '4 3', '3 5"7', '1 4 57', '1 4 6']);
    Test('1 - ( 4 & ( 5? + 6 ) )', ['1', '1 2 3', '2 1', '1 4', '1 57', '1 6'],
        ['2', '57 2 3 4 1', '2 3', '41', '4 3', '3 5"7', '1 4 57', '1 4 6']);
    Test('1 - ( 4 & ( 5* + 6* ) )', ['1', '1 2 3', '2 1', '1 4', '1 57', '1 6'],
        ['2', '57 2 3 4 1', '2 3', '41', '4 3', '3 5"7', '1 4 57', '1 4 6']);
  finally
    s.Free;
  end;
end;

const
  REF_LECUYER_GENERATOR: TBlock512 = (
    2094674600, 1801471443, 1564436181, 3659342702,
    1831620425, 3729943674, 687904812,  2066320563,
    3494904290, 3023528103, 1358263417, 3202492728,
    1577967257, 3235083616, 712712534,  1900728807);
  REF_LECUYER_GENERATOR_TRAIL: TBlock512 = (
    2912814506, 4264204172, 1224264557, 457988427,
    3671383357, 2304790299, 1068635130, 1812365788,
    18904424,   1385490254, 3829840815, 3086100873,
    1986702847, 635322329,  2467062584, 3233345822);

procedure TTestCoreBase._Random32;
var
  i, n: PtrInt;
  q, qp: QWord;
  c: array[0..1000] of cardinal;
  timer: TPrecisionTimer;
  gen: TLecuyer;
begin
  RandomLecuyer(gen); // local instance to avoid any thread influence
  for i := 0 to high(c) do
    c[i] := gen.Next;
  QuickSortInteger(@c, 0, high(c));
  n := 0;
  for i := 0 to high(c) - 1 do
    if c[i + 1] = c[i] then
      inc(n);
  Check(n < 2, 'unique Random32'); // n=1 have been seen once
  timer.Start;
  Check(gen.Next(0) = 0);
  Check(gen.Next(1) = 0);
  for i := 1 to 100000 do
    Check(gen.Next(i) < cardinal(i));
  for i := 0 to 100000 do
    Check(gen.Next(maxInt - i) < cardinal(maxInt - i));
  qp := 0;
  n := 0;
  for i := 1 to 20000 do
  begin
    q := gen.NextQWord;
    Check((q = 0) or (q <> qp));
    if q and $ffffffff00000000 <> 0 then
      inc(n);
    qp := q;
  end;
  Check(n > 20000 - 20, 'Random64');
  n := 100000 * 2 + 20000 * 2;
  NotifyTestSpeed('Random32', n, n * 4, @timer);
  timer.Start;
  for i := 1 to 100 do
    gen.Fill(@c, SizeOf(c));
  NotifyTestSpeed('RandomBytes', 0, SizeOf(c) * 100, @timer);
  for i := 0 to high(REF_LECUYER_GENERATOR) do
  begin
    gen.SeedGenerator(i);
    FillCharFast(c, SizeOf(c), 0); // gen.Fill() will XOR the buffer
    gen.Fill(@c, SizeOf(c));
    CheckHash(@c, SizeOf(c), REF_LECUYER_GENERATOR[i], 'lecgen');
    CheckEqual(gen.Next, REF_LECUYER_GENERATOR_TRAIL[i], 'lecgentrail');
  end;
end;

procedure TTestCoreBase._TRawUtf8Interning;
var
  int: TRawUtf8Interning;
  i, v: integer;
  sr: PStrRecConst; // refers to UINT_999[]
  tmp: RawUtf8;
  vs: TRawUtf8DynArray;
  timer: TPrecisionTimer;
  caseinsensitive: boolean;

  procedure DoOne(const u: RawUtf8);
  var
    local: RawUtf8; // will force dec(RefCnt) when leaving DoOne()
  begin
    local := int.Unique(u);
    CheckEqual(local, u);
  end;

const
  MAX = 500000;
  ONESIZE = 32; // assume each SmallUInt32Utf8[] uses 32 heap bytes
  DIRSIZE = ONESIZE * (MAX + 1);
  INTSIZE = ONESIZE * 512;
begin
  for caseinsensitive := false to true do
  begin
    int := TRawUtf8Interning.Create(1, caseinsensitive);
    try
      CheckEqual(int.Count, 0);
      DoOne('test');
      CheckEqual(int.Count, 1);
      DoOne('test');
      CheckEqual(int.Count, 1);
      CheckEqual(int.Clean, 1);
      DoOne('single');
      CheckEqual(int.Count, 1);
      CheckEqual(int.Clean, 1);
      CheckEqual(int.Count, 0);
      CheckEqual(int.Clean, 0);
      CheckEqual(int.Count, 0);
      DoOne('single1');
      CheckEqual(int.Count, 1);
      DoOne('single1');
      CheckEqual(int.Count, 1);
      DoOne('test2');
      CheckEqual(int.Count, 2);
      DoOne('test2');
      CheckEqual(int.Count, 2);
      DoOne('single2');
      CheckEqual(int.Count, 3);
      CheckEqual(int.Clean, 3);
      CheckEqual(int.Count, 0);
      int.Unique(tmp, 'kept', 4);
      CheckEqual(tmp, 'kept');
      CheckEqual(GetRefCount(tmp), 2);
      tmp := '';
      if caseinsensitive then
        int.Unique(tmp, 'KEPT', 4) // should be identified as previous 'kept'
      else
        int.Unique(tmp, 'kept', 4);
      CheckEqual(tmp, 'kept');
      CheckEqual(GetRefCount(tmp), 2);
      CheckEqual(int.Count, 1);
      CheckEqual(int.Clean, 0);
      CheckEqual(int.Count, 1);
      tmp := '';
      CheckEqual(int.Clean, 1);
      CheckEqual(int.Count, 0);
      int.Clear;
      CheckEqual(int.Count, 0);
      CheckEqual(int.Clean, 0);
      CheckEqual(int.Count, 0);
    finally
      int.Free;
    end;
    int := TRawUtf8Interning.Create(16, caseinsensitive);
    try
      for i := 0 to MAX do
      begin
        v := i and 511;
        int.Unique(tmp, SmallUInt32Utf8[v]); // SmallUInt32Utf8[] have refcnt=-1
        check(Utf8ToInteger(tmp) = v);
      end;
      checkEqual(int.Count, 512);
      tmp := '';
      checkEqual(int.Count, 512);
      checkEqual(int.Clean, 512); // all int.Pool[] have refcnt=1 -> clean
      checkEqual(int.Count, 0);
    finally
      int.Free;
    end;
  end;
  int := TRawUtf8Interning.Create(4);
  try
    SetLength(vs, MAX + 1);
    timer.Start;
    for i := 0 to MAX do
    begin
      sr := @UINT_999[i and 511];
      int.Unique(vs[i], @sr^.TextLo, sr^.Header.length);
    end;
    NotifyTestSpeed('interning %', [KB(INTSIZE)], MAX, DIRSIZE, @timer);
    for i := 0 to MAX do
      check(Utf8ToInteger(vs[i]) = i and 511);
    check(int.Count = 512);
    check(int.Clean = 0);
    check(int.Count = 512);
    for i := 0 to MAX do
      check(Utf8ToInteger(vs[i]) = i and 511);
    timer.Start;
    vs := nil; // fair test
    NotifyTestSpeed('intern clear %', [KB(INTSIZE)], MAX, DIRSIZE, @timer);
    check(int.Count = 512);
    check(int.Clean = 512);
    check(int.Count = 0);
  finally
    int.Free;
  end;
  SetLength(vs, MAX + 1);
  timer.Start;
  for i := 0 to MAX do
  begin
    sr := @UINT_999[i and 511];
    FastSetString(vs[i], @sr^.TextLo, sr^.Header.length);
  end;
  NotifyTestSpeed('direct %', [KB(DIRSIZE)], MAX, DIRSIZE, @timer);
  for i := 0 to MAX do
    check(Utf8ToInteger(vs[i]) = i and 511);
  timer.Start;
  vs := nil; // fair test
  NotifyTestSpeed('direct clear %', [KB(DIRSIZE)], MAX, DIRSIZE, @timer);
end;

function kr32reference(buf: PAnsiChar; len: cardinal): cardinal;
var
  i: integer;
begin
  result := 0;
  for i := 0 to len - 1 do
    result := result * 31 + ord(buf[i]);
end;

function fnv32reference(crc: cardinal; buf: PAnsiChar; len: cardinal): cardinal;
var
  i: integer;
begin
  for i := 0 to len - 1 do
    crc := (crc xor ord(buf[i])) * 16777619;
  result := crc;
end;

function crc32creference(crc: cardinal; buf: PAnsiChar; len: cardinal): cardinal;
var
  tab: PCrc32tab;
begin
  tab := crc32ctab; // retrieve the lookup table once
  result := not crc;
  if buf <> nil then
    while len > 0 do
    begin
      result := tab[0, ToByte(result xor ord(buf^))] xor (result shr 8);
      dec(len);
      inc(buf);
    end;
  result := not result;
end;

function Hash32Reference(Data: PCardinal; Len: integer): cardinal;
var
  s1, s2: cardinal;
  i: integer;
begin
  if Data <> nil then
  begin
    s1 := 0;
    s2 := 0;
    for i := 1 to Len shr 2 do
    begin
      // 4 bytes (DWORD) by loop
      inc(s1, Data^);
      inc(s2, s1);
      inc(Data);
    end;
    case Len and 3 of // remaining 0..3 bytes
      1:
        inc(s1, PByte(Data)^);
      2:
        inc(s1, PWord(Data)^);
      3:
        inc(s1, PWord(Data)^ or (PByteArray(Data)^[2] shl 16));
    end;
    inc(s2, s1);
    result := s1 xor (s2 shl 16);
  end
  else
    result := 0;
end;

{$ifndef FPC} // RolDWord is an intrinsic function under FPC :)
function RolDWord(value: cardinal; count: integer): cardinal;
  {$ifdef HASINLINE} inline;{$endif}
begin
  result := (value shl count) or (value shr (32 - count));
end;
{$endif FPC}

function xxHash32reference(P: PAnsiChar; len: integer; seed: cardinal = 0): cardinal;
const
  PRIME32_1 = 2654435761;
  PRIME32_2 = 2246822519;
  PRIME32_3 = 3266489917;
  PRIME32_4 = 668265263;
  PRIME32_5 = 374761393;
var
  c1, c2, c3, c4: cardinal;
  PLimit, PEnd: PAnsiChar;
begin
  PEnd := P + len;
  if len >= 16 then
  begin
    PLimit := PEnd - 16;
    c1 := seed + PRIME32_1 + PRIME32_2;
    c2 := seed + PRIME32_2;
    c3 := seed;
    c4 := seed - PRIME32_1;
    repeat
      c1 := PRIME32_1 * RolDWord(c1 + PRIME32_2 * PCardinal(P)^, 13);
      c2 := PRIME32_1 * RolDWord(c2 + PRIME32_2 * PCardinal(P + 4)^, 13);
      c3 := PRIME32_1 * RolDWord(c3 + PRIME32_2 * PCardinal(P + 8)^, 13);
      c4 := PRIME32_1 * RolDWord(c4 + PRIME32_2 * PCardinal(P + 12)^, 13);
      inc(P, 16);
    until not (P <= PLimit);
    result := RolDWord(c1, 1) + RolDWord(c2, 7) + RolDWord(c3, 12) + RolDWord(c4, 18);
  end
  else
    result := seed + PRIME32_5;
  inc(result, len);
  while P <= PEnd - 4 do
  begin
    inc(result, PCardinal(P)^ * PRIME32_3);
    result := RolDWord(result, 17) * PRIME32_4;
    inc(P, 4);
  end;
  while P < PEnd do
  begin
    inc(result, PByte(P)^ * PRIME32_5);
    result := RolDWord(result, 11) * PRIME32_1;
    inc(P);
  end;
  result := result xor (result shr 15);
  result := result * PRIME32_2;
  result := result xor (result shr 13);
  result := result * PRIME32_3;
  result := result xor (result shr 16);
end;

procedure crcblockreference(crc128, data128: PBlock128);
var
  c: cardinal;
var
  tab: PCrc32tab;
begin
  tab := crc32ctab; // retrieve the lookup table once
  c := crc128^[0] xor data128^[0];
  crc128^[0] := tab[3, byte(c)] xor tab[2, byte(c shr 8)] xor
                tab[1, byte(c shr 16)] xor tab[0, c shr 24];
  c := crc128^[1] xor data128^[1];
  crc128^[1] := tab[3, byte(c)] xor tab[2, byte(c shr 8)] xor
                tab[1, byte(c shr 16)] xor tab[0, c shr 24];
  c := crc128^[2] xor data128^[2];
  crc128^[2] := tab[3, byte(c)] xor tab[2, byte(c shr 8)] xor
                tab[1, byte(c shr 16)] xor tab[0, c shr 24];
  c := crc128^[3] xor data128^[3];
  crc128^[3] := tab[3, byte(c)] xor tab[2, byte(c shr 8)] xor
                tab[1, byte(c shr 16)] xor tab[0, c shr 24];
end;

procedure TTestCoreBase._crc32c;
var
  crc: array[0..10000] of record
    S: RawByteString;
    crc: cardinal;
  end;
  totallen: Cardinal;
  s2, msg: RawByteString;

  procedure Test(hash: THasher; const name: string);
  var
    i: PtrInt;
    Timer: TPrecisionTimer;
    a: string[10];
  begin
    a := '123456789';
    Check(hash(0, @a, 0) = 0);
    Check(hash(0, @a, 1) = $2ACF889D);
    Check(hash(0, @a, 2) = $BD5FE6AF);
    Check(hash(0, @a, 3) = $7F40BC73);
    Check(hash(0, @a, 4) = $13790E51);
    Check(crc32cBy4(cardinal(not 0), PCardinal(@a)^) = cardinal(not $13790E51),
      'crc32cBy4');
    Check(hash(0, @a, 5) = $659AD21);
    Check(hash(0, @a, 6) = $85BF5A8C);
    Check(hash(0, @a, 7) = $8B0FB6FA);
    Check(hash(0, @a, 8) = $2E5336F0);
    Timer.Start;
    for i := 0 to High(crc) do
      with crc[i] do
        Check(hash(0, pointer(S), length(S)) = crc);
    msg := FormatUtf8('% %:%/s', [msg, name, KBNoSpace(Timer.PerSec(totallen))]);
  end;

  procedure test16(const text: RawUtf8; expected: cardinal);
  begin
    Check(crc16(pointer(text), length(text)) = expected);
  end;

var
  i, j: integer;
  c1, c2: cardinal;
  p: PAnsiChar;
  crc1, crc2: THash128;
  crcs: THash512Rec;
  digest: THash256;
  tmp: RawByteString;
  hmac32: THmacCrc32c;
  timer: TPrecisionTimer;
begin
  test16('', $ffff);
  test16('a', $9d77);
  test16('ab', $69f0);
  test16('toto', $e2ca);
  test16('123456789', $29b1);
  test16('123456789123456789', $a86d);
  totallen := 36;
  tmp := '123456789123456789';
  c2 := $12345678;
  c1 := HmacCrc32c(@c2, pointer(tmp), 4, length(tmp));
  check(c1 = $1C3C4B51);
  hmac32.Init(@c2, 4);
  hmac32.Update(pointer(tmp), length(tmp));
  check(hmac32.Done = c1);
  c2 := $12345678;
  HmacCrc256c(@c2, pointer(tmp), 4, length(tmp), digest);
  checkEqual(Sha256DigestToString(digest),
    '46da01fb9f4a97b5f8ba2c70512bc22aaa9b57e5030ced9f5c7c825ab5ec1715');
  FillZero(crc2);
  crcblock(@crc2, PBlock128(PAnsiChar('0123456789012345')));
  check(not IsZero(crc2));
  check(TBlock128(crc2)[0] = 1314793854);
  check(TBlock128(crc2)[1] = 582109780);
  check(TBlock128(crc2)[2] = 1177891908);
  check(TBlock128(crc2)[3] = 4047040040);
  FillZero(crc1);
  crcblockreference(@crc1, PBlock128(PAnsiChar('0123456789012345')));
  check(not IsZero(crc1));
  check(IsEqual(crc1, crc2));
  FillZero(crc1);
  crcblocks(@crc1, PBlock128(PAnsiChar('0123456789012345')), 1);
  check(not IsZero(crc1));
  check(IsEqual(crc1, crc2), 'crcblocks');
  FillZero(crc1);
  crcblockfast(@crc1, PBlock128(PAnsiChar('0123456789012345')));
  check(not IsZero(crc1));
  check(IsEqual(crc1, crc2));
  for i := 0 to high(crcs.b) do
    crcs.b[i] := i;
  for j := 1 to 4 do
  begin
    FillZero(crc2);
    crcblockreference(@crc2, @crcs.h0);
    if j > 1 then
      crcblockreference(@crc2, @crcs.h1);
    if j > 2 then
      crcblockreference(@crc2, @crcs.h2);
    if j > 3 then
      crcblockreference(@crc2, @crcs.h3);
    FillZero(crc1);
    crcblocks(@crc1, @crcs.h0, j);
    check(not IsZero(crc1));
    check(IsEqual(crc1, crc2), 'crcblocks4');
    FillZero(crc1);
    crcblocksfast(@crc1, @crcs.h0, j);
    check(not IsZero(crc1));
    check(IsEqual(crc1, crc2), 'crcblocksfast4');
    CheckEqual(Hash128Index(@crcs, 4, @crcs.r[j - 1]), j - 1);
    check(Hash128Index(@crcs, j - 1, @crcs.r[j - 1]) < 0);
  end;
  CheckEqual(Hash256Index(@crcs, 2, @crcs.r[0]), 0);
  check(Hash256Index(@crcs, 2, @crcs.r[1]) < 0);
  CheckEqual(Hash256Index(@crcs, 2, @crcs.r[2]), 1);
  check(Hash256Index(@crcs, 2, @crcs.r[3]) < 0);
  for i := 0 to 50000 do
  begin
    FillZero(crc1);
    crcblock(@crc1, @digest);
    check(not IsZero(crc1));
    if @crcblock <> @crcblockfast then
    begin
      FillZero(crc2);
      crcblockreference(@crc2, @digest);
      check(not IsZero(crc2));
      check(IsEqual(crc1, crc2));
      FillZero(crc2);
      crcblockfast(@crc2, @digest);
      check(not IsZero(crc2));
      check(IsEqual(crc1, crc2));
    end;
    for j := 0 to high(digest) do
      inc(digest[j]);
  end;
  for i := 0 to High(crc) do
    with {%H-}crc[i] do
    begin
      j := i shr 3 + 1; // circumvent weird FPC code generation bug in -O2 mode
      S := RandomWinAnsi(j);
      Check(length(S) = j);
      crc := crc32creference(0, pointer(S), length(S));
      inc(totallen, length(S));
      c2 := HmacCrc32c(@c1, pointer(S), 4, length(S));
      hmac32.Init(@c1, 4);
      hmac32.Update(pointer(S), length(S));
      CheckEqual(hmac32.Done, c2, 'hmac32');
      s2 := S;
      SymmetricEncrypt(i, s2);
      check(s2 <> S);
      SymmetricEncrypt(i, s2);
      CheckEqual(s2, S, 'SymmetricEncrypt');
      s2 := S;
      LecuyerEncrypt(i, s2);
      Check(s2 <> S);
      LecuyerEncrypt(i, s2);
      CheckEqual(s2, S, 'LecuyerEncrypt');
    end;
  p := pointer(crc32tab);
  Check(crc32fast(0, p, 5) = $DF4EC16C, 'crc32a');
  Check(crc32fast(0, p, 1024) = $6FCF9E13, 'crc32b');
  Check(crc32fast(0, p, 1024 - 5) = $70965738, 'crc32c');
  Check(crc32fast(0, p + 1, 2) = $41D912FF, 'crc32d');
  Check(crc32fast(0, p + 3, 1024 - 5) = $E5FAEC6C, 'crc32e');
  Test(crc32creference, 'pas');
  Test(crc32cinlined, 'inl');
  Test(crc32cfast, 'fast');
  {$ifdef ASMINTEL}
  {$ifndef OSDARWIN}
  // Not [yet] implemented on Darwin
  if cfSSE42 in CpuFeatures then
  begin
    Test(crc32csse42, 'sse42');
    AddConsole('%', [msg]);
    Check(hashsse42(0, p, 5) = $39B69E64, 'hashsse42a');
    Check(hashsse42(0, p, 1020) = $C43D29E6, 'hashsse42b');
    timer.Start; // only the profiling part of Test()
    for i := 0 to High(crc) do
      with crc[i] do
        CheckNotEqual(hashsse42(0, pointer(S), length(S)), crc);
    msg := FormatUtf8(' hashsse42:%/s', [KBNoSpace(Timer.PerSec(totallen))]);
    {$ifdef ASMX64}
    if (cfAesNi in CpuFeatures) and
       (cfCLMUL in CpuFeatures) then
      Test(crc32c, 'clmul'); // use SSE4.2+pclmulqdq instructions on x64
    {$endif ASMX64}
  end;
  {$endif OSDARWIN}
  {$else}
  if @crc32c <> @crc32cfast then
    Test(crc32c, 'armv8');
  {$endif ASMINTEL}
  AddConsole('%', [msg]);
end;

procedure TTestCoreBase.intadd(const Sender; Value: integer);
begin
  AddToCsv(UInt32ToUtf8(Value), fAdd);
end;

procedure TTestCoreBase.intdel(const Sender; Value: integer);
begin
  AddToCsv(UInt32ToUtf8(Value), fDel);
end;

procedure TTestCoreBase.Integers;

  procedure changes(const old, new, added, deleted: RawUtf8);
  var
    o, n: TIntegerDynArray;
  begin
    CsvToIntegerDynArray(pointer(old), o);
    CsvToIntegerDynArray(pointer(new), n);
    fAdd := '';
    fDel := '';
    NotifySortedIntegerChanges(pointer(o), pointer(n), length(o), length(n),
      intadd, intdel, self);
    CheckEqual(fAdd, added, 'added');
    CheckEqual(fDel, deleted, 'deleted');
  end;

  procedure includes(const values, includes, excludes, included, excluded: RawUtf8);

    procedure includes32;
    var
      v, i, e: TIntegerDynArray;
    begin
      CsvToIntegerDynArray(Pointer(values), v);
      CsvToIntegerDynArray(Pointer(excludes), e);
      ExcludeInteger(v, e, 32); // no sort
      Check(IntegerDynArrayToCsv(v) = excluded);
      v := nil;
      e := nil;
      CsvToIntegerDynArray(Pointer(values), v);
      CsvToIntegerDynArray(Pointer(excludes), e);
      ExcludeInteger(v, e, 2); // sort
      Check(IntegerDynArrayToCsv(v) = excluded);
      v := nil;
      e := nil;
      CsvToIntegerDynArray(Pointer(values), v);
      CsvToIntegerDynArray(Pointer(includes), i);
      IncludeInteger(v, i, 32); // no sort
      Check(IntegerDynArrayToCsv(v) = included);
      v := nil;
      e := nil;
      CsvToIntegerDynArray(Pointer(values), v);
      CsvToIntegerDynArray(Pointer(includes), i);
      IncludeInteger(v, i, 2); // sort
      Check(IntegerDynArrayToCsv(v) = included);
    end;

    procedure includes64;
    var
      v, i, e: TInt64DynArray;
    begin
      CsvToInt64DynArray(Pointer(values), v);
      CsvToInt64DynArray(Pointer(excludes), e);
      ExcludeInt64(v, e, 32); // no sort
      Check(Int64DynArrayToCsv(v) = excluded);
      v := nil;
      e := nil;
      CsvToInt64DynArray(Pointer(values), v);
      CsvToInt64DynArray(Pointer(excludes), e);
      ExcludeInt64(v, e, 2); // sort
      Check(Int64DynArrayToCsv(v) = excluded);
      v := nil;
      e := nil;
      CsvToInt64DynArray(Pointer(values), v);
      CsvToInt64DynArray(Pointer(includes), i);
      IncludeInt64(v, i, 32); // no sort
      Check(Int64DynArrayToCsv(v) = included);
      v := nil;
      e := nil;
      CsvToInt64DynArray(Pointer(values), v);
      CsvToInt64DynArray(Pointer(includes), i);
      IncludeInt64(v, i, 2); // sort
      Check(Int64DynArrayToCsv(v) = included);
    end;

  begin
    Includes32;
    Includes64;
  end;

var
  i8: TByteDynArray;
  i16: TWordDynArray;
  i32, i32_: TIntegerDynArray;
  i64: TInt64DynArray;
  i, n: PtrInt;
  c: integer;
  timer: TPrecisionTimer;
begin
  CheckEqual(SizeOf(cardinal), SizeOf(TDWordRec), 'TDWordRec');
  CheckEqual(SizeOf(Int64), SizeOf(Int64Rec), 'Int64Rec');
  CheckEqual(SizeOf(QWord), SizeOf(TQWordRec), 'TQWordRec');
  CheckEqual(SizeOf(TFileTime), SizeOf(TQWordRec), 'TFileTime');
  CheckEqual(9007199254740991, MAX_SAFE_JS_INTEGER);
  Check(IsPowerOfTwo(0));
  Check(IsPowerOfTwo(1));
  Check(IsPowerOfTwo(2));
  Check(not IsPowerOfTwo(3));
  Check(IsPowerOfTwo(4));
  Check(not IsPowerOfTwo(5));
  Check(not IsPowerOfTwo(6));
  Check(not IsPowerOfTwo(7));
  Check(IsPowerOfTwo(8));
  for i := 9 to 15 do
    Check(not IsPowerOfTwo(i));
  Check(IsPowerOfTwo(16));
  for i := 17 to 31 do
    Check(not IsPowerOfTwo(i));
  Check(IsPowerOfTwo(32));
  CheckEqual(NextPowerOfTwo(0), 1);
  CheckEqual(NextPowerOfTwo(1), 1);
  CheckEqual(NextPowerOfTwo(2), 2);
  CheckEqual(NextPowerOfTwo(3), 4);
  CheckEqual(NextPowerOfTwo(4), 4);
  for i := 5 to 8 do
    CheckEqual(NextPowerOfTwo(i), 8);
  for i := 9 to 16 do
    CheckEqual(NextPowerOfTwo(i), 16);
  for i := 17 to 32 do
    CheckEqual(NextPowerOfTwo(i), 32);
  for i := 1025 to 2048 do
    CheckEqual(NextPowerOfTwo(i), 2048);
  for i := 65537 to 131072 do
    CheckEqual(NextPowerOfTwo(i), 131072);
  for i := 33554433 to 67108864 - 1 do // millions tests in a few ms :)
  begin
    Check(not IsPowerOfTwo(i));
    Check(NextPowerOfTwo(i) = 67108864);
  end;
  Check(IsPowerOfTwo(67108864));
  Check(NextPowerOfTwo(67108864) = 67108864);
  n := 512;
  CheckEqual(MinPtrInt(1, n), 1);
  CheckEqual(MaxPtrInt(1, n), n);
  CheckEqual(MinPtrUInt(1, n), 1);
  CheckEqual(MaxPtrUInt(1, n), n);
  SetLength(i8, n);
  for i := 0 to n - 1 do
  begin
    i8[i] := i;
    CheckEqual(MinPtrInt(i, i), i);
    CheckEqual(MaxPtrInt(i, i), i);
    CheckEqual(MinPtrUInt(i, i), i);
    CheckEqual(MaxPtrUInt(i, i), i);
    CheckEqual(MinPtrInt(i, n), i);
    CheckEqual(MaxPtrInt(i, n), n);
    CheckEqual(MinPtrUInt(i, n), i);
    CheckEqual(MaxPtrUInt(i, n), n);
    CheckEqual(MinPtrInt(i, i + 1), i);
    CheckEqual(MaxPtrInt(i, i - 1), i);
    CheckEqual(MinPtrUInt(i, i + 1), i);
    if i > 0 then
      CheckEqual(MaxPtrUInt(i, i - 1), i);
    CheckEqual(bswap16(bswap16(i)), i);
    CheckEqual(bswap32(bswap32(i)), i);
    CheckEqual(bswap64(bswap64(i)), i);
  end;
  CheckEqual(bswap16($0001), $0100, 'bswap16');
  CheckEqual(bswap32($00010203), $03020100, 'bswap32');
  CheckEqual(Int64(bswap64($0001020304050607)), $0706050403020100, 'bswap64');
  CheckEqual(ByteScanIndex(pointer(i8), 100, 100), -1);
  CheckEqual(ByteScanIndex(pointer(i8), 101, 100), 100);
  CheckEqual(ByteScanIndex(@i8[1], 100, 0), -1, 'aligned read');
  CheckEqual(ByteScanIndex(@i8[1], 100, 1), 0, 'unaligned read');
  for i := 0 to n - 1 do
    Check(ByteScanIndex(pointer(i8), n, i) = i and 255);
  SetLength(i16, n);
  for i := 0 to n - 1 do
    i16[i] := i;
  CheckEqual(WordScanIndex(pointer(i16), 100, 100), -1);
  CheckEqual(WordScanIndex(pointer(i16), 101, 100), 100);
  CheckEqual(WordScanIndex(@i16[1], 100, 0), -1, 'aligned read');
  CheckEqual(WordScanIndex(@i16[1], 100, 1), 0, 'unaligned read');
  for i := 0 to n - 1 do
    Check(WordScanIndex(pointer(i16), n, i) = i);
  SetLength(i32, n);
  for i := 0 to n - 1 do
    i32[i] := i;
  CheckEqual(IntegerScanIndex(pointer(i32), 100, 100), -1);
  CheckEqual(IntegerScanIndex(pointer(i32), 101, 100), 100);
  CheckEqual(IntegerScanIndex(@i32[1], 100, 0), -1, 'aligned read');
  CheckEqual(IntegerScanIndex(@i32[1], 100, 1), 0, 'unaligned read');
  for i := 0 to n - 1 do
    CheckEqual(IntegerScanIndex(pointer(i32), n, i), i);
  i32 := nil;
  DeduplicateInteger(i32);
  CheckEqual(i32, nil);
  SetLength(i32, 2);
  i32[0] := 1;
  QuickSortInteger(i32);
  CheckEqual(i32[0], 0);
  CheckEqual(i32[1], 1);
  DeduplicateInteger(i32);
  CheckEqual(length(i32), 2);
  CheckEqual(i32[0], 0);
  CheckEqual(i32[1], 1);
  i32[0] := 1;
  DeduplicateInteger(i32);
  CheckEqual(length(i32), 1);
  CheckEqual(i32[0], 1);
  SetLength(i32, 6);
  i32[4] := 1;
  i32[5] := 2;
  DeduplicateInteger(i32); // (1, 0, 0, 0, 1, 2)
  CheckEqual(length(i32), 3);
  CheckEqual(i32[0], 0);
  CheckEqual(i32[1], 1);
  CheckEqual(i32[2], 2);
  SetLength(i32, 6);
  i32[4] := 3;
  i32[5] := 3;
  DeduplicateInteger(i32); // (0, 1, 2, 0, 3, 3)
  CheckEqual(length(i32), 4);
  CheckEqual(i32[0], 0);
  CheckEqual(i32[1], 1);
  CheckEqual(i32[2], 2);
  CheckEqual(i32[3], 3);
  i32_ := i32;
  DeleteInteger(i32_, 2);
  CheckEqual(length(i32), 4, 'unique');
  CheckEqual(i32[0], 0);
  CheckEqual(i32[1], 1);
  CheckEqual(i32[2], 2);
  CheckEqual(i32[3], 3);
  CheckEqual(length(i32_), 3, 'copied');
  CheckEqual(i32_[0], 0);
  CheckEqual(i32_[1], 1);
  CheckEqual(i32_[2], 3);
  for n := 1 to 1000 do
  begin
    SetLength(i32, n);
    for i := 0 to n - 1 do
      i32[i] := i and 15;
    DeduplicateInteger(i32);
    if n < 16 then
      CheckEqual(Length(i32), n)
    else
      CheckEqual(Length(i32), 16);
    for i := 0 to high(i32) do
      CheckEqual(i32[i], i);
  end;
  changes('', '', '', '');
  changes('1', '1', '', '');
  changes('', '1', '1', '');
  changes('1', '', '', '1');
  changes('1,2', '1,3', '3', '2');
  changes('2', '1,3', '1,3', '2');
  changes('', '1,3', '1,3', '');
  changes('1,2,3,4', '1,2,3,4', '', '');
  changes('1,2,3,4', '1,2,3,4,5', '5', '');
  changes('1,2,3,4', '1,3,4', '', '2');
  changes('1,2,3,4', '3,4', '', '1,2');
  changes('1,2,3,4', '1,4', '', '2,3');
  changes('1,2,3,4', '', '', '1,2,3,4');
  changes('1,2,3,4', '5,6', '5,6', '1,2,3,4');
  changes('1,2,4', '1,3,5,6', '3,5,6', '2,4');
  changes('1,2,4', '3,5,6', '3,5,6', '1,2,4');
  includes('1,2,3', '2', '2', '2', '1,3');
  includes('1,2,3', '2,3', '2,3', '2,3', '1');
  includes('1,2,3', '1,2,3', '1,2,3', '1,2,3', '');
  includes('1,2,3', '3,1,2', '3,1,2', '1,2,3', '');
  check({%H-}i64 = nil);
  DeduplicateInt64(i64);
  check(i64 = nil);
  SetLength(i64, 2);
  i64[0] := 1;
  QuickSortInt64(pointer(i64), 0, 1);
  check(i64[0] = 0);
  check(i64[1] = 1);
  DeduplicateInt64(i64);
  check(length(i64) = 2);
  check(i64[0] = 0);
  check(i64[1] = 1);
  i64[0] := 1;
  DeduplicateInt64(i64);
  check(length(i64) = 1);
  check(i64[0] = 1);
  SetLength(i64, 6);
  i64[4] := 1;
  i64[5] := 2;
  DeduplicateInt64(i64); // (1, 0, 0, 0, 1, 2)
  check(length(i64) = 3);
  check(i64[0] = 0);
  check(i64[1] = 1);
  check(i64[2] = 2);
  SetLength(i64, 6);
  i64[4] := 3;
  i64[5] := 3;
  DeduplicateInt64(i64); // (0, 1, 2, 0, 3, 3)
  check(length(i64) = 4);
  check(i64[0] = 0);
  check(i64[1] = 1);
  check(i64[2] = 2);
  check(i64[3] = 3);
  c := 4;
  AddSortedInt64(i64, c, 10);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '0,1,2,3,10');
  AddSortedInt64(i64, c, 20);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '0,1,2,3,10,20');
  AddSortedInt64(i64, c, 15);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '0,1,2,3,10,15,20');
  RemoveSortedInt64SmallerThan(i64, c, -100);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '0,1,2,3,10,15,20');
  RemoveSortedInt64SmallerThan(i64, c, 0);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '0,1,2,3,10,15,20');
  RemoveSortedInt64SmallerThan(i64, c, 1);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '1,2,3,10,15,20');
  RemoveSortedInt64SmallerThan(i64, c, 2);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '2,3,10,15,20');
  RemoveSortedInt64SmallerThan(i64, c, 9);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '10,15,20');
  RemoveSortedInt64SmallerThan(i64, c, 17);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '20');
  RemoveSortedInt64SmallerThan(i64, c, 20);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '20');
  RemoveSortedInt64SmallerThan(i64, c, 170);
  Check(i64 = nil);
  CheckEqual(c, 0);
  CheckEqual(Int64DynArrayToCsv(pointer(i64), c), '');
  for n := 1 to 1000 do
  begin
    SetLength(i64, n);
    for i := 0 to n - 1 do
      i64[i] := i and 15;
    DeduplicateInt64(i64);
    if n < 16 then
      check(Length(i64) = n)
    else
      check(Length(i64) = 16);
    for i := 0 to high(i64) do
      check(i64[i] = i);
  end;
  SetLength(i32, 100000);
  n := 10;
  repeat
    rnd.Fill(pointer(i32), n * 4);
    timer.Start;
    QuickSortInteger(pointer(i32), 0, n - 1);
    NotifyTestSpeed('QuickSortInteger', n, 0, @timer, {onlylog=}true);
    for i := 1 to n - 1 do
      Check(i32[i - 1] <= i32[i]);
    n := n * 10;
  until n > length(i32);
  SetLength(i32, 1);
  i32[0] := 1;
  CheckEqual(length(i32), 1);
  CheckEqual(i32[0], 1);
  AddSortedInteger(i32, 2);
  CheckEqual(length(i32), 2);
  CheckEqual(i32[0], 1);
  CheckEqual(i32[1], 2);
end;

function TestAddFloatStr(const str: RawUtf8): RawUtf8;
var
  tmp: TTextWriterStackBuffer;
begin
  with TJsonWriter.CreateOwnedStream(tmp) do
  try
    AddFloatStr(pointer(str));
    SetText(result);
  finally
    Free;
  end;
end;

function GetExtendedHook(P: PUtf8Char; out err: integer): TSynExtended;
begin
  result := GetExtended(P, err); // resolve the proper GetExtended() overload
end;

procedure TTestCoreBase.NumericalConversionsSlow(Sender: TObject);
var
  HasFP80: boolean;

  procedure CheckGetExtendedBits(const text: RawUtf8; expected: QWord);
  var
    d: double;
    err: integer;
  begin
    d := GetExtended(pointer(text), err);
    CheckEqual(err, 0, text);
    CheckUtf8(PQWord(@d)^ = expected, text);
  end;

  procedure CheckDoubleToShort(v: double; const expected: ShortString);
  var
    a: ShortString;
    d: double;
    err: integer;
  begin
    ExtendedToShort(@a, v, DOUBLE_PRECISION); // = 15
    if expected = '1E-19' then // may return '9.9999999999999998E-20' as double
      Check(a <> '0', '1E-19') // just validate that it is not trimmed to '0'
    else
      CheckEqualShort(a, expected, 'ExtendedToShort');
    DoubleToShort(@a, v);
    if expected = '1E-19' then
      Check(a <> '0', '1E-19')
    else
      CheckEqualShort(a, expected, 'DoubleToShort');
    a[ord(a[0]) + 1] := #0;
    d := GetExtended(@a[1], err);
    CheckEqual(err, 0);
    CheckSame(v, d);
  end;

  procedure CheckDoubleToShortBits(bits: QWord; const expected: ShortString);
  var
    d: double;
  begin
    PUInt64(@d)^ := bits;
    CheckDoubleToShort(d, expected);
  end;

  procedure CheckDoubleToShortSame(v: double);
  var
    s: string;
    u: RawUtf8;
    err: integer;
    d: double;
    vv: variant;
    p: PUtf8Char;
  begin
    s := DoubleToString(v);
    val(s, d, err);
    CheckEqual(err, 0);
    CheckSame(d, v);
    StringToUtf8(s, u);
    d := GetExtended(pointer(u), err);
    CheckEqual(err, 0);
    CheckSame(d, v);
    p := GetNumericVariantFromJson(pointer(u), TVarData(vv), true);
    CheckUtf8(p = PUtf8Char(pointer(u)) + length(u), u);
    CheckSame(double(vv), v);
  end;

  {$ifdef CPU64}
  procedure CheckIntegerValue(const text: RawUtf8; expected: Int64);
  var
    err: integer;
    value: Int64;
  begin
    value := GetInt64(pointer(text), err);
    CheckEqual(err, 0, text);
    CheckEqual(value, expected, text);
  end;
  {$endif CPU64}

  procedure CheckJsonValue(const text: RawUtf8; kind: integer; expected: double;
    expectedText: RawUtf8 = '');
  var
    v: variant;
    p: PUtf8Char;
  begin
    p := GetNumericVariantFromJson(pointer(text), TVarData(v), true);
    CheckUtf8(p = PUtf8Char(pointer(text)) + length(text), text);
    CheckEqual(TVarData(v).VType, kind, text);
    CheckSame(double(v), expected, 0, 'CheckJsonValue');
    if expectedText = '' then
      expectedText := Text
    else if SizeOf(TSynExtended) <> SizeOf(double) then
      exit; // extended=FP80 on Delphi Win32
    CheckEqual(DoubleToStr(double(v)), expectedText);
  end;

  procedure CheckJsonExact(const text: RawUtf8; kind: integer; expected: Int64);
  var
    v: variant;
    p: PUtf8Char;
  begin
    TVarData(v).VType := varEmpty;
    p := GetNumericVariantFromJson(pointer(text), TVarData(v), false);
    CheckUtf8(p = PUtf8Char(pointer(text)) + length(text), text);
    CheckEqual(TVarData(v).VType, kind, text);
    if kind = varInteger then
      CheckEqual(TVarData(v).VInteger, expected, text)
    else
      CheckEqual(TVarData(v).VInt64, expected, text);
  end;

  procedure CheckJsonDoubleBits(const text: RawUtf8; expected: QWord);
  var
    v: variant;
  begin
    CheckUtf8(GetNumericVariantFromJson(pointer(text), TVarData(v), true) <> nil, text);
    CheckEqual(TVarData(v).VType, varDouble, text);
    CheckUtf8(PQWord(@TVarData(v).VDouble)^ = expected,
      'CheckJsonDoubleBits %=%', [PQWord(@TVarData(v).VDouble)^, expected]);
  end;

  procedure BenchmarkNumbers;
  var
    i, l: PtrUInt;
    c, hash: cardinal;
    err: integer;
    p, max: PUtf8Char;
    lens: TBytes;
    ref: TInt64DynArray;
    gen: TLecuyer;
    d, d0: double;
    data: RawUtf8;
    tmp: TShort23;

    procedure DoTest(GetExt: TGetExtended; GetNum: TGetNumericVariantFromJson);
    var
      i: PtrUInt;
      p, p2: PUtf8Char;
      d: double;
      d64: Int64;
      setref: boolean;
      err: integer;
      vd: TVarData;
      Timer: TPrecisionTimer;
    begin
      check(Assigned(GetExt));
      check(Assigned(GetNum));
      setref := ref = nil;
      if setref then
        SetLength(ref, length(lens));
      d64 := 0;
      Timer.Start;
      p := pointer(data);
      for i := 0 to high(lens) do
      begin
        d := GetExt(p, err);
        CheckEqual(err, 0, 'p');
        Check((lens[i] <= 3) or (PInt64(@d)^ <> d64), 'd64');
        d64 := PInt64(@d)^; // never twice the same number (if big enough)
        if setref then
          ref[i] := d64
        else
          Check(ref[i] = d64, 'ref');
        inc(p, lens[i] + 1);
      end;
      NotifyTestSpeed('GetExtended%', [tmp], length(lens), length(data), @Timer);
      // GetExtended() on Core i5 13500: SSSE3 is around 30-35% faster
      Timer.Start;
      p := pointer(data);
      for i := 0 to high(lens) do
      begin
        PCardinal(@vd.VType)^ := varEmpty;
        p2 := GetNum(p, vd, {double=}true);
        Check(p2 - p = lens[i]);
        Check(vd.VType >= varInteger);
        if not HasFP80 then
          if vd.VType = varDouble then
            Check(ref[i] = vd.VInt64, 'refvd1')
          else if Check(VariantToDouble(variant(vd), PDouble(@d64)^)) then
            Check(ref[i] = d64, 'refvd2')
        else if Check(VariantToDouble(variant(vd), d)) then
          CheckSame(d, PDouble(@ref[i])^, DOUBLE_SAME, 'refvd3');
        p := p2 + 1;
      end;
      NotifyTestSpeed('GetNumericVariant%', [tmp], length(lens), length(data), @Timer);
      // GetNumericVariantFromJson() on Core i5 13500:
      // - FPC: about 2.7 ms Pascal versus about 2.0 ms SSSE3 with checks
      // - Delphi: about 2.9 ms Pascal versus about 2.0 ms SSSE3
      // after removing Check() overhead: 2.46 ms Pascal versus 1.85 ms SSSE3
    end;

  begin
    // pre-compute all number values as #0-separated huge string
    SetLength(lens, 200000);
    gen.SeedGenerator(200000); // up to 16GB of deterministic distribution
    SetLength(data, 1758350);  // generate 1.7MB of contiguous numbers
    p := pointer(data);
    max := p + length(data);
    hash := 0;
    for i := 0 to high(lens) do
    begin
      c := gen.Next;
      hash := crc32cBy4(hash, c);
      tmp[0] := #0;
      if c and $70000 > $50000 then
        PWord(@tmp)^ := 1 + ord('-') shl 8 // a few negative values
      else
        tmp[0] := #0;
      case i and 15 of // fixed order/layout of field types (like real data)
        0, 8, 12, 15: // "and 31" below is mandatory on arm32
          AppendShortCardinal(c shr ((32 - (c and 15)) and 31), tmp);
        1, 9, 13:
          AppendShortQWord(QWord(c) * i, tmp);
        2, 10, 14:
          AppendShortCardinal(c shr 24, tmp);
        3:
          tmp[0] := AnsiChar(Curr64ToPChar(c, @tmp[1]));
        4, 11:
          AppendShortVar(tmp, [c and 15, '.', c shr 20]);
        5:
          AppendShortVar(tmp, [c shr 20, 'E', c and 127]);
        6:
          AppendShortVar(tmp, [c shr 20, '.', (c shr 10) and 31, 'e', c and 63]);
        7:
          AppendShortVar(tmp, ['0.000000000000000',c shr 28 + 1]);
      end;
      //ConsoleWrite(tmp);
      l := ord(tmp[0]);
      if not Check(p + l < max, 'gen.Next overflow') then
        exit;
      MoveFast(tmp[1], p^, l);
      lens[i] := l;
      p[l] := #0; // all with a trailing #0
      inc(p, l + 1);
    end;
    CheckEqual(hash, 152899875, 'TLecuyer.Next');
    CheckEqual(p - pointer(data), length(data));
    hash := Hash32(data);
    CheckHash(data, $D2D00549);
    // 'x.y' and 'x.y0' are the same number, so should return the same double
    p := pointer(data);
    for i := 0 to high(lens) do
    begin
      if i and 15 = 3 then // Curr64ToPChar e.g. 225140.5360 49537.6115
      begin
        d := GetExtended(p, err); // makes also a non sequential L1 cache access
        CheckEqual(err, 0, 'd');
        Check(PInt64(@d)^ <> 0);
        l := lens[i];
        tmp[l + 1] := '0';
        tmp[l + 2] := #0;
        MoveFast(p^, tmp[1], l);
        d0 := GetExtended(@tmp[1], err); // parse '0' appended value
        CheckEqual(err, 0, 'd0');
        CheckEqual(PInt64(@d0)^, PInt64(@d)^, 'frac0'); // same binary64
      end;
      inc(p, lens[i] + 1);
    end;
    // benchmark GetExtended() and GetNumericVariantFromJson()
    for i := 1 to 1 do
    begin
      {$ifdef ASMX64NOTPIC} { SIMD/SSE3 x64 asm in mormot.core.base.asmx64.inc }
      tmp := 'Pas';
      DoTest(@GetExtendedPas, @GetNumericVariantPas);
      tmp := 'Ssse3';
      if cfSSE3 in CpuFeatures then
        DoTest(@GetExtendedSsse3, @GetNumericVariantSsse3);
      {$else}
      tmp[0] := #0;
      {$ifdef WIN32DELPHI} // x87 asm of GetExtended
      DoTest(@mormot.core.base.GetExtended, @GetNumericVariantFromJson);
      {$else}
      DoTest(@GetExtendedHook, @GetNumericVariantFromJson); // purepascal
      {$endif WIN32DELPHI}
      {$endif ASMX64NOTPIC}
    end;
    CheckEqual(Hash32(data), hash, 'untouched 1');
    CheckHash(data, $D2D00549, 'untouched 2');
  end;

  procedure CheckInvalidNumber(const text: RawUtf8; extendedToo: boolean = true);
  var
    v: variant;
    d: double;
    err: integer;
  begin
    CheckUtf8(GetNumericVariantFromJson(pointer(text), TVarData(v), true) = nil, text);
    if HasFP80 or not extendedToo then
      exit;
    d := GetExtended(pointer(text), err);
    CheckNotEqual(err, 0, text);
    CheckUtf8(not IsInfinite(d) and not IsNan(d), text);
  end;

var
  i, j, b, err: integer;
  juint: cardinal absolute j;
  k, l: Int64;
  q: QWord;
  s, s2: RawUtf8;
  d, e: double;
  f: extended;
  sd, se: single;
  c: currency;
  ident: TRawUtf8DynArray;
  vj, vs: variant;
  a, a2: ShortString;
  u: string;
  varint: TByteToByte;
  st: TFastReader;
  PB, PC: PByte;
  P: PUtf8Char;
  crc, u32, n: cardinal;
  Timer: TPrecisionTimer;
begin
  HasFP80 := SizeOf(TSynExtended) <> SizeOf(double); // FP80 has full precision
  a := '';
  AppendShortCardinal(0, a);
  check(a = '0');
  for i := 1 to 10 do
    AppendShortCardinal(i, a);
  check(a = '012345678910');
  for i := 11 to 120 do
    AppendShortCardinal(i, a);
  CheckEqual(length(a), 253);
  CheckHash(@a[1], ord(a[0]), $1CDCEE09, 'AppendShortCardinal');
  a := '';
  AppendShortByte(0, @a);
  check(a = '0');
  for i := 1 to 10 do
    AppendShortByte(i, @a);
  check(a = '012345678910');
  for i := 11 to 120 do
    AppendShortByte(i, @a);
  CheckEqual(length(a), 253);
  CheckHash(@a[1], ord(a[0]), $1CDCEE09, 'AppendShortByte');
  CheckEqualShort(TwoDigits(0), '0');
  CheckEqualShort(TwoDigits(1), '1');
  CheckEqualShort(TwoDigits(10), '10');
  CheckEqualShort(TwoDigits(100), '100');
  CheckEqualShort(TwoDigits(1000), '1000');
  CheckEqualShort(TwoDigits(0.1), '0.10');
  CheckEqualShort(TwoDigits(0.12), '0.12');
  CheckEqualShort(TwoDigits(0.123), '0.12');
  CheckEqualShort(TwoDigits(0.124), '0.12');
  CheckEqualShort(TwoDigits(0.125), '0.12');
  CheckEqualShort(TwoDigits(0.1252), '0.13');
  CheckEqualShort(TwoDigits(0.126), '0.13');
  CheckEqualShort(TwoDigits(0.129), '0.13');
  CheckEqualShort(TwoDigits(70.131), '70.13');
  CheckEqualShort(TwoDigits(70.135), '70.13');
  CheckEqualShort(TwoDigits(70.1352), '70.14');
  CheckEqualShort(TwoDigits(0.01), '0.01');
  CheckEqualShort(TwoDigits(0.05), '0.05');
  CheckEqualShort(TwoDigits(0.051), '0.05');
  CheckEqualShort(TwoDigits(0.055), '0.05');
  CheckEqualShort(TwoDigits(0.0551), '0.06');
  CheckEqualShort(TwoDigits(0.0015), '0');
  CheckEqualShort(TwoDigits(0.0055), '0.01');
  UInt32DigitsToUtf8(94287082, 10, s);
  CheckEqual(s, '0094287082');
  UInt32DigitsToUtf8(94287082, 8, s);
  CheckEqual(s, '94287082');
  UInt32DigitsToUtf8(94287082, 6, s);
  CheckEqual(s, '287082');
  UInt32DigitsToUtf8(94287082, 4, s);
  CheckEqual(s, '7082');
  for i := 0 to 8 do
  begin
    UInt32DigitsToUtf8(i, 0, s);
    CheckEqual(s, '');
    UInt32DigitsToUtf8(111111111, i, s);
    CheckEqual(length(s), i);
    for j := 1 to i do
      Check(s[i] = '1');
    UInt32DigitsToUtf8(7, i, s);
    CheckEqual(length(s), i);
    if i = 0 then
      continue;
    for j := 1 to i - 1 do
      Check(s[j] = '0');
    Check(s[i] = '7');
  end;
  UInt32DigitsToUtf8(7, 20, s);
  CheckEqual(s, '00000000000000000007');
  UInt32DigitsToUtf8(7, 23, s);
  CheckEqual(s, '00000000000000000000007');
  UInt32DigitsToUtf8(7, 24, s);
  CheckEqual(s, '00000000000000000000007');
  UInt32DigitsToUtf8(7, 25, s);
  CheckEqual(s, '00000000000000000000007');
  n := 100000;
  Timer.Start;
  crc := 0;
  d := 3.141592653 / 1.0573623912;
  for i := 1 to n do
  begin
    f := d;
    {$ifdef FPC}
    j := FloatToText(PChar(@varint), f, ffGeneral, DOUBLE_PRECISION, 0);
    {$else}
    j := FloatToText(PChar(@varint), f, fvExtended, ffGeneral, DOUBLE_PRECISION, 0);
    {$endif FPC}
    PChar(@varint)[j] := #0;
    inc(crc, j);
    d := d * 1.0038265263;
  end;
  NotifyTestSpeed('FloatToText ', [PChar(@varint)], n, crc, @Timer);
  Timer.Start;
  crc := 0;
  d := 3.141592653 / 1.0573623912;
  for i := 1 to n do
  begin
    str(d, a);
    inc(crc, ord(a[0]));
    d := d * 1.0038265263;
  end;
  NotifyTestSpeed('str ', [{%H-}a], n, crc, @Timer);
  //  a[ord(a[0])+1] := #0; Check(SameValue(GetExtended(pointer(@a[1])),d,0));
  Timer.Start;
  crc := 0;
  d := 3.141592653 / 1.0573623912;
  for i := 1 to n do
  begin
    DoubleToShort(@a, d);
    inc(crc, ord(a[0]));
    d := d * 1.0038265263;
  end;
  NotifyTestSpeed('DoubleToShort ', [a], n, crc, @Timer);
  a[ord(a[0]) + 1] := #0;
  //  a[ord(a[0])+1] := #0; Check(SameValue(GetExtended(pointer(@a[1])),d,0));
  {$ifdef DOUBLETOSHORT_USEGRISU}
  Timer.Start;
  crc := 0;
  d := 3.141592653 / 1.0573623912;
  for i := 1 to n do
  begin
    DoubleToAscii(C_NO_MIN_WIDTH, -1, d, @a);
    inc(crc, ord(a[0]));
    d := d * 1.0038265263;
  end;
  NotifyTestSpeed('DoubleToAscii ', [a], n, crc, @Timer);
  //  a[ord(a[0])+1] := #0; Check(SameValue(GetExtended(pointer(@a[1])),d,0));
  d := 0;
  DoubleToAscii(C_NO_MIN_WIDTH, -1, d, @a);
  Check(a = '0');
  DoubleToAscii(0, DOUBLE_PRECISION, d, @a);
  Check(a = '0');
  {$endif DOUBLETOSHORT_USEGRISU}
  CheckEqual(TestAddFloatStr(''), '0');
  CheckEqual(TestAddFloatStr(' 123'), '123');
  CheckEqual(TestAddFloatStr(' 1a23'), '1');
  CheckEqual(TestAddFloatStr(' 123z'), '123');
  CheckEqual(TestAddFloatStr(' 12.3'), '12.3');
  CheckEqual(TestAddFloatStr('12.'), '12.');
  CheckEqual(TestAddFloatStr(' +12.3'), '+12.3');
  CheckEqual(TestAddFloatStr(' -12.3'), '-12.3');
  CheckEqual(TestAddFloatStr('12.3e230'), '12.3e230');
  CheckEqual(TestAddFloatStr('12.3E230'), '12.3E230');
  CheckEqual(TestAddFloatStr('12.3e-230'), '12.3e-230');
  CheckEqual(TestAddFloatStr('12.3E-230'), '12.3E-230');
  CheckEqual(TestAddFloatStr('12.3e 230'), '12.3e');
  CheckEqual(TestAddFloatStr('12.3f230'), '12.3');
  CheckEqual(TestAddFloatStr('12.3E23.0'), '12.3E23');
  CheckEqual(TestAddFloatStr('-.01'), '-0.01'); // ODBC numeric output
  CheckEqual(TestAddFloatStr('.0002'), '0.0002'); // ODBC numeric output
  CheckEqual(OctToBin(''), '');
  CheckEqual(OctToBin('123'), '123');
  CheckEqual(OctToBin('\\123'), '\123');
  CheckEqual(OctToBin('12\\3'), '12\3');
  CheckEqual(OctToBin('123\\'), '123\');
  CheckEqual(OctToBin('123\'), '123');
  CheckEqual(OctToBin('\041'), '!');
  CheckEqual(OctToBin('a\041'), 'a!');
  CheckEqual(OctToBin('\041b'), '!b');
  CheckEqual(OctToBin('a\041b'), 'a!b');
  CheckEqual(OctToBin('a\101b\102'), 'aAbB');
  CheckEqual(OctToBin('a\101\102b'), 'aABb');
  CheckEqual(OctToBin('a\101\\\102b'), 'aA\Bb');
  CheckEqual(OctToBin('a\401b\102'), 'a');
  CheckEqual(OctToBin('a\181b\102'), 'a');
  CheckEqual(OctToBin('a\10ab\102'), 'a');
  CheckEqual(OctToBin('a\1'), 'a');
  CheckEqual(OctToBin('a\10'), 'a');
  Check(Plural('row', 0) = '0 row');
  Check(Plural('row', 1) = '1 row');
  Check(Plural('row', 2) = '2 rows');
  Check(Plural('row', 20) = '20 rows');
  Check(Plural('row', 200000) = '200000 rows');
  Check(not SameValue(386.0, 386.1));
  Check(not SameValue(386.0, 700, 2));
  Check(IntToThousandString(0) = '0');
  Check(IntToThousandString(1) = '1');
  Check(IntToThousandString(9) = '9');
  Check(IntToThousandString(10) = '10');
  Check(IntToThousandString(100) = '100');
  Check(IntToThousandString(999) = '999');
  Check(IntToThousandString(1000) = '1,000');
  Check(IntToThousandString(10000) = '10,000');
  Check(IntToThousandString(100000) = '100,000');
  Check(IntToThousandString(1000000) = '1,000,000');
  Check(IntToThousandString(10000000) = '10,000,000');
  Check(IntToThousandString(-1) = '-1');
  Check(IntToThousandString(-9) = '-9');
  Check(IntToThousandString(-10) = '-10');
  Check(IntToThousandString(-100) = '-100');
  Check(IntToThousandString(-999) = '-999');
  Check(IntToThousandString(-1000) = '-1,000');
  Check(IntToThousandString(-10000) = '-10,000');
  Check(IntToThousandString(-100000) = '-100,000');
  Check(IntToThousandString(-1000000) = '-1,000,000');
  Check(UInt3DigitsToUtf8(1) = '001');
  Check(UInt3DigitsToUtf8(12) = '012');
  Check(UInt3DigitsToUtf8(123) = '123');
  Check(UInt4DigitsToUtf8(1) = '0001');
  Check(UInt4DigitsToUtf8(12) = '0012');
  Check(UInt4DigitsToUtf8(123) = '0123');
  Check(UInt4DigitsToUtf8(1234) = '1234');
  CheckEqualShort(MicroSecToString(0) , '0us');
  CheckEqualShort(MicroSecToString(QWord(-10)) , '0us');
  CheckEqualShort(MicroSecToString(10) , '10us');
  CheckEqualShort(MicroSecToString(999) , '999us');
  CheckEqualShort(MicroSecToString(1000) , '1ms');
  CheckEqualShort(MicroSecToString(1001) , '1ms');
  CheckEqualShort(MicroSecToString(1010) , '1.01ms');
  CheckEqualShort(MicroSecToString(1100) , '1.10ms');
  CheckEqualShort(MicroSecToString(999999) , '999.99ms');
  CheckEqualShort(MicroSecToString(1000000) , '1s');
  CheckEqualShort(MicroSecToString(1000001) , '1s');
  CheckEqualShort(MicroSecToString(2030001) , '2.03s');
  CheckEqualShort(MicroSecToString(200000070001) , '2d');
  Check(KbNoSpace(0)            = '0B' , 'kb0');
  Check(KbNoSpace(99)           = '99B', 'kb99');
  Check(KbNoSpace(1 shl 10 - 1) = '1KB', 'kb1');
  Check(KbNoSpace(1 shl 10)     = '1KB', 'kb2');
  Check(KbNoSpace(1 shl 10 + 1) = '1KB', 'kb3');
  Check(KbNoSpace(1 shl 20 - 1) = '1MB', 'kb4');
  Check(KbNoSpace(1 shl 20)     = '1MB', 'kb5');
  Check(KbNoSpace(1 shl 20 + 1) = '1MB', 'kb6');
  Check(KbNoSpace(1 shl 30 - 1) = '1GB', 'kb7');
  Check(KbNoSpace(1 shl 30)     = '1GB', 'kb8');
  Check(KbNoSpace(1 shl 30 + 1) = '1GB', 'kb9');
  Check(KB(-123) = '');
  Check(KB(0) = '0 B');
  Check(KB(123) = '123 B');
  Check(KB(1023) = '1 KB');
  Check(KB(1024) = '1 KB');
  Check(KB(1025) = '1 KB');
  Check(KB(16383) = '16 KB');
  Check(KB(16384) = '16 KB');
  Check(KB(16385) = '16 KB');
  Check(KB(3 * 1024 * 1024 - 800 * 1024) = '2.2 MB');
  Check(KB(3 * 1024 * 1024) = '3 MB');
  Check(KB(3 * 1024 * 1024 + 511 * 1024) = '3.5 MB');
  Check(KB(3 * 1024 * 1024 + 512 * 1024) = '3.5 MB');
  Check(KB(3 * 1024 * 1024 + 1024) = '3 MB');
  Check(KB(maxInt) = '2 GB');
  Check(KB(3294963200) = '3 GB');
  Check(KB(4294963200) = '4 GB');
  Check(Int64ToUtf8(-maxInt) = '-2147483647');
  Check(Int64ToUtf8(-1) = '-1');
  Check(Int64ToUtf8(-MAX_INT64) = '-9223372036854775807');
  Int64ToUtf8(-maxInt, s);
  Check(s = '-2147483647');
  Int64ToUtf8(-1, s);
  Check(s = '-1');
  Int64ToUtf8(100, s);
  Check(s = '100');
  Int64ToUtf8(-MAX_INT64, s);
  Check(s = '-9223372036854775807');
  {$ifdef HASINLINE} // bug with MinInt64 with older versions of Delphi
  CheckEqual(Int64ToUtf8(-9223372036854775808), '-9223372036854775808');
  Int64ToUtf8(-9223372036854775808, s);
  CheckEqual(s, '-9223372036854775808');
  {$endif HASINLINE}
  CheckEqual(Int64ToUtf8(2119852951849248647), '2119852951849248647');
  CheckEqual(FormatUtf8(' % ', [2119852951849248647]), ' 2119852951849248647 ');
  s := '1234';
  d := GetExtended(pointer(s));
  CheckSame(d, 1234);
  s := '1234.1';
  d := GetExtended(pointer(s));
  CheckSame(d, 1234.1);
  s := '12345678901234567890';
  d := GetExtended(pointer(s));
  CheckSame(d, 12345678901234567890.0, 0);
  s := '1234.1234567890123456789';
  d := GetExtended(pointer(s));
  CheckSame(d, 1234.1234567890123456789);
  s := '.1234';
  d := GetExtended(pointer(s));
  CheckSame(d, 0.1234);
  s := '.1234e';
  d := GetExtended(pointer(s), err);
  Check(err <> 0);
  s := '.1234e4';
  d := GetExtended(pointer(s), err);
  Check(err = 0);
  CheckSame(d, 1234);
  s := '0.0';
  d := GetExtended(pointer(s));
  CheckSame(d, 0);
  u := DoubleToString(40640.5028819444);
  Check(u = '40640.5028819444', u);
  s := '40640.5028a819444';
  GetExtended(pointer(s), err);
  Check(err > 0);
  s := '40640.5028819444';
  d := GetExtended(pointer(s), err);
  Check(err = 0);
  u := DoubleToString(d);
  Check(u = '40640.5028819444', u);
  e := 40640.5028819444;
  CheckSame(d, e, 1e-11);
  if not HasFP80 then // FP80 would convert it
  begin
    s := '40640e400';
    d := GetExtended(pointer(s), err);
    CheckSame(d, 40640.0, DOUBLE_SAME, 'e400=e0');
    Check(err > 0, 'e400');
  end;
  s := 'Nan';
  d := GetExtended(pointer(s), err);
  CheckEqual(err, 0, s);
  Check(IsNan(d));
  DoubleToShort(@a, d);
  Check(IdemPropName(a, 'Nan'));
  Check(ShortToFloatNan(a) = fnNan);
  Check(FloatToJsonNan(@a)^ = JSON_NAN[fnNan]);
  s := 'INF';
  d := GetExtended(pointer(s), err);
  CheckEqual(err, 0, s);
  Check(IsInfinite(d));
  DoubleToShort(@a, d);
  Check((a = '+Inf') or (a = 'INF'));
  Check(ShortToFloatNan(a) = fnInf);
  Check(FloatToJsonNan(@a)^ = JSON_NAN[fnInf]);
  s := '-INfinity';
  d := GetExtended(pointer(s), err);
  CheckEqual(err, 0, s);
  Check(IsInfinite(d));
  DoubleToShort(@a, d);
  Check(IdemPropName(a, '-Inf'));
  Check(ShortToFloatNan(a) = fnNegInf);
  Check(FloatToJsonNan(@a)^ = JSON_NAN[fnNegInf]);
  Check(IsAnsiCompatible('t'));
  Check(IsAnsiCompatible('te'));
  Check(IsAnsiCompatible('tes'));
  Check(IsAnsiCompatible('test'));
  Check(IsAnsiCompatible('teste'));
  CheckDoubleToShort(0, '0');
  CheckDoubleToShort(1, '1');
  CheckDoubleToShort(10, '10');
  CheckDoubleToShort(101, '101');
  CheckDoubleToShort(-1, '-1');
  CheckDoubleToShort(0.1, '0.1');
  CheckDoubleToShort(0.01, '0.01');
  CheckDoubleToShort(0.001, '0.001');
  CheckDoubleToShort(0.0001, '0.0001');
  CheckDoubleToShort(0.0000000000000000001, '1E-19'); // double <> extended
  CheckDoubleToShort(0.0000000000000000002, '2E-19'); // would exactly convert
  CheckDoubleToShort(-0.0000000000000000002, '-2E-19');
  CheckDoubleToShort(0.00000000000000000015, '1.5E-19');
  CheckDoubleToShort(-0.00000000000000000015, '-1.5E-19');
  CheckDoubleToShort(0.0000000000000002, '2E-16');
  CheckDoubleToShort(-0.0000000000000002, '-2E-16');
  CheckDoubleToShort(0.000000000002, '2E-12');
  CheckDoubleToShort(-0.000000000002, '-2E-12');
  CheckDoubleToShort(2e19, '2E19');
  CheckDoubleToShort(-2e19, '-2E19');
  CheckDoubleToShort(1.5e19, '1.5E19');
  CheckDoubleToShort(-1.5e19, '-1.5E19');
  CheckDoubleToShort(-0.1, '-0.1');
  CheckDoubleToShort(-0.01, '-0.01');
  CheckDoubleToShort(-0.001, '-0.001');
  CheckDoubleToShort(-0.0001, '-0.0001');
  CheckDoubleToShort(1.1, '1.1');
  CheckDoubleToShort(1.01, '1.01');
  CheckDoubleToShort(1.001, '1.001');
  CheckDoubleToShort(1.0001, '1.0001');
  CheckDoubleToShort(1.00001, '1.00001');
  CheckDoubleToShort(-1.1, '-1.1');
  CheckDoubleToShort(-1.01, '-1.01');
  CheckDoubleToShort(-1.001, '-1.001');
  CheckDoubleToShort(-1.0001, '-1.0001');
  CheckDoubleToShort(-1.00001, '-1.00001');
  CheckDoubleToShort(7, '7');
  CheckDoubleToShort(-7, '-7');
  CheckDoubleToShort(0.7, '0.7');
  CheckDoubleToShort(0.07, '0.07');
  CheckDoubleToShort(0.007, '0.007');
  CheckDoubleToShort(0.0007, '0.0007');
  CheckDoubleToShort(-0.7, '-0.7');
  CheckDoubleToShort(-0.07, '-0.07');
  CheckDoubleToShort(-0.007, '-0.007');
  CheckDoubleToShort(-0.0007, '-0.0007');
  CheckDoubleToShort(7.7, '7.7');
  CheckDoubleToShort(7.07, '7.07');
  CheckDoubleToShort(7.007, '7.007');
  CheckDoubleToShort(7.0007, '7.0007');
  CheckDoubleToShort(7.00007, '7.00007');
  CheckDoubleToShort(-7.7, '-7.7');
  CheckDoubleToShort(-7.07, '-7.07');
  CheckDoubleToShort(-7.007, '-7.007');
  CheckDoubleToShort(-7.0007, '-7.0007');
  CheckDoubleToShort(-7.00007, '-7.00007');
  {$ifdef FPC}
  CheckDoubleToShort(0.00001, '0.00001');
  CheckDoubleToShort(-0.00001, '-0.00001');
  CheckDoubleToShort(0.00007, '0.00007');
  CheckDoubleToShort(-0.00007, '-0.00007');
  {$endif FPC}
  CheckDoubleToShort(11111.1, '11111.1');
  CheckDoubleToShort(11111.01, '11111.01');
  CheckDoubleToShort(11111.001, '11111.001');
  CheckDoubleToShort(11111.0001, '11111.0001');
  CheckDoubleToShort(11111.00001, '11111.00001');
  CheckDoubleToShort(-11111.1, '-11111.1');
  CheckDoubleToShort(-11111.01, '-11111.01');
  CheckDoubleToShort(-11111.001, '-11111.001');
  CheckDoubleToShort(-11111.0001, '-11111.0001');
  CheckDoubleToShort(-11111.00001, '-11111.00001');
  CheckDoubleToShort(0.9999999999999997, '1');
  CheckDoubleToShort(-0.9999999999999997, '-1');
  CheckDoubleToShort(9.999999999999997, '10');
  CheckDoubleToShort(-9.999999999999997, '-10');
  CheckDoubleToShort(999.9999999999997, '1000');
  CheckDoubleToShort(-999.9999999999997, '-1000');
  CheckDoubleToShort(22.99999999999997, '23');
  CheckDoubleToShort(-22.99999999999997, '-23');
  CheckDoubleToShort(999.9999999999933, '999.999999999993');
  CheckDoubleToShort(-999.9999999999933, '-999.999999999993');
  CheckDoubleToShortSame(3.3495117168);
  CheckDoubleToShortSame(-3.3495117168);
  CheckDoubleToShortSame(-3.3495117168e-1);
  CheckDoubleToShortSame(3.3495117168e-1);
  CheckDoubleToShortSame(-3.3495117168e-5);
  CheckDoubleToShortSame(3.3495117168e-5);
  CheckDoubleToShortSame(-3.3495117168e-10);
  CheckDoubleToShortSame(3.3495117168e-10);
  CheckDoubleToShortSame(-3.9999617168e-14);
  CheckDoubleToShortSame(3.9999617168e-14);
  CheckDoubleToShortSame(-3.9999617168e-15);
  CheckDoubleToShortSame(3.9999617168e-15);
  CheckDoubleToShortSame(12.345678901234);
  CheckDoubleToShortSame(123.45678901234);
  CheckDoubleToShortSame(1234.5678901234);
  if not HasFP80 then // FP80 has more precision
  begin
    CheckDoubleToShort(0.00123456789012345, '0.00123456789012');
    CheckDoubleToShort(-0.00123456789012345, '-0.00123456789012');
    CheckDoubleToShort(0.000123456789012345, '0.00012345678901');
    CheckDoubleToShort(-0.000123456789012345, '-0.00012345678901');
    s := '0e400';
    d := GetExtended(pointer(s), err);
    CheckEqual(err, 0);
    Check(d = 0);
    s := '0e-400';
    d := GetExtended(pointer(s), err);
    CheckEqual(err, 0);
    Check(d = 0);
    s := '-0e400';
    d := GetExtended(pointer(s), err);
    CheckEqual(err, 0);
    Check(d = 0); // '-0' -> 0 with ECMAScript's number-to-string rules
    CheckGetExtendedBits('4.9406564584124654E-324', $0000000000000001);
    CheckGetExtendedBits('2.2250738585072009E-308', $000FFFFFFFFFFFFF);
    CheckGetExtendedBits('2.2250738585072014E-308', $0010000000000000);
    CheckGetExtendedBits('1.7976931348623157E308', $7FEFFFFFFFFFFFFF);
    CheckGetExtendedBits('1E308', $7FE1CCF385EBC8A0);
    CheckGetExtendedBits('0.5000000000000000000', $3FE0000000000000);
    CheckGetExtendedBits('0.50000000000000000000', $3FE0000000000000);
    CheckGetExtendedBits('0.50000000000000000008', $3FE0000000000000);
    CheckGetExtendedBits('0.9223372036854775807', $3FED83C94FB6D2AC);
    CheckGetExtendedBits('0.123456789012345678', $3FBF9ADD3746F660);
    CheckGetExtendedBits('0.9223372036854775808', $3FED83C94FB6D2AD);
    CheckGetExtendedBits('0.9223372036854775809', $3FED83C94FB6D2AD);
    CheckDoubleToShortBits($4D6E62C4E38FF876, '1.0000000000000005E65');
    CheckDoubleToShortBits(QWord($CD6E62C4E38FF876), '-1.0000000000000005E65');
    CheckDoubleToShortBits($0000000000000001, '4.9406564584124654E-324');
    CheckDoubleToShortBits($000FFFFFFFFFFFFF, '2.2250738585072009E-308');
    CheckDoubleToShortBits($0010000000000000, '2.2250738585072014E-308');
    CheckDoubleToShortBits($7FEFFFFFFFFFFFFF, '1.7976931348623157E308');
  end;
  CheckEqual(TextToVariantNumberType('1'), varInt64);
  CheckEqual(TextToVariantNumberType('10'), varInt64);
  CheckEqual(TextToVariantNumberType('01'), varString);
  CheckEqual(TextToVariantNumberType(' 1'), varString);
  CheckEqual(TextToVariantNumberType('1.'), varString);
  CheckEqual(TextToVariantNumberType('1.1'), varCurrency);
  CheckEqual(TextToVariantNumberType('1.1234'), varCurrency);
  CheckEqual(TextToVariantNumberType('1234.1234'), varCurrency);
  CheckEqual(TextToVariantNumberType('1234.1234'), varCurrency);
  CheckEqual(TextToVariantNumberType('1234.12345'), varDouble);
  CheckEqual(TextToVariantNumberType('1234e+45'), varDouble);
  CheckEqual(TextToVariantNumberTypeNoDouble('1'), varInt64);
  CheckEqual(TextToVariantNumberTypeNoDouble('10'), varInt64);
  CheckEqual(TextToVariantNumberTypeNoDouble('01'), varString);
  CheckEqual(TextToVariantNumberTypeNoDouble(' 1'), varString);
  CheckEqual(TextToVariantNumberTypeNoDouble('1.'), varString);
  CheckEqual(TextToVariantNumberTypeNoDouble('1.1'), varCurrency);
  CheckEqual(TextToVariantNumberTypeNoDouble('1.1234'), varCurrency);
  CheckEqual(TextToVariantNumberTypeNoDouble('1234.1234'), varCurrency);
  CheckEqual(TextToVariantNumberTypeNoDouble('1234.1234'), varCurrency);
  CheckEqual(TextToVariantNumberTypeNoDouble('1234.12345'), varString);
  CheckEqual(TextToVariantNumberTypeNoDouble('1234e+45'), varString);
  CheckEqual(Int32ToUtf8(1599638299), '1599638299');
  CheckEqual(UInt32ToUtf8(1599638299), '1599638299');
  CheckEqual(Int32ToUtf8(-1599638299), '-1599638299');
  CheckEqual(Int64ToUtf8(-1271083787498396012), '-1271083787498396012');
  CheckEqual(Int64ToUtf8(242161819595454762), '242161819595454762');
  // detect 64-bit integer overflow in GetExtended()
  CheckDoubleToShort(95.0290695380, '95.029069538');
  Check(ToDouble('95.0290695380', d), '95.02');
  CheckSame(d, 95.029069538);
  Check(ToDouble('95.02906953800000000000', d), '95.x');
  CheckSame(d, 95.029069538);
  Check(ToDouble('184467440737095514', d), '184467440737095514');
  CheckSame(d, 184467440737095514);
  Check(ToDouble('1844674407370955148', d), '1844674407370955148');
  CheckSame(d, 1844674407370955148);
  //  SQLite text-to-float converter routine failed with this number
  Check(ToDouble('18446744073709551488', d), '18446744073709551488');
  CheckSame(d, 1.8446744074e+19, 1e+10);
  {$ifdef FPC} // Delphi doesn't handle consistently such huge constants
  CheckDoubleToShort(d, '1.8446744073709552E19');
  CheckDoubleToShortSame(d);
  CheckDoubleToShort(1234567890123456789, '1.2345678901234568E18');
  CheckDoubleToShortSame(1234567890123456789);
  CheckDoubleToShortSame(18446744073709551);
  CheckDoubleToShortSame(184467440737095514);
  CheckDoubleToShortSame(1844674407370955148);
  {$endif FPC}
  // signed numeric boundaries and JSON grammar
  {$ifdef CPU64}
  CheckIntegerValue('9223372036854775807', High(Int64));
  CheckIntegerValue('-9223372036854775808', Low(Int64));
  CheckIntegerValue('  -  000000000000000000000000000000000000000000123', -123);
  CheckIntegerValue('+0000', 0);
  for i := 0 to 3 do
  begin
    s := GetCsvItem('9223372036854775808,-9223372036854775809,' +
      '18446744073709551616,99999999999999999999', i);
    GetInt64(pointer(s), err);
    CheckNotEqual(err, 0, s);
  end;
  {$endif CPU64}
  CheckJsonExact('0', varInteger, 0);
  CheckJsonExact('0.0', varInteger, 0);
  CheckJsonExact('0.000000000', varInteger, 0);
  CheckJsonExact('1', varInteger, 1);
  CheckJsonExact('-1', varInteger, -1);
  CheckJsonExact('12', varInteger, 12);
  CheckJsonExact('-12', varInteger, -12);
  CheckJsonExact('123', varInteger, 123);
  CheckJsonExact('-123', varInteger, -123);
  CheckJsonExact('1.23', varCurrency, 12300);
  CheckJsonExact('-1.23', varCurrency, -12300);
  CheckJsonExact('1234', varInteger, 1234);
  CheckJsonExact('12345', varInteger, 12345);
  CheckJsonExact('123456', varInteger, 123456);
  CheckJsonExact('1234567', varInteger, 1234567);
  CheckJsonExact('12345678', varInteger, 12345678);
  CheckJsonExact('123456789', varInteger, 123456789);
  CheckJsonExact('1234567890', varInt64, 1234567890);
  CheckJsonExact('9223372036854775807',   varInt64,    High(Int64));
  CheckJsonExact('-9223372036854775808',  varInt64,    Low(Int64));
  CheckJsonExact('922337203685477.5807',  varCurrency, High(Int64));
  CheckJsonExact('-922337203685477.5808', varCurrency, Low(Int64));
  CheckJsonExact('922337203685477.58',    varCurrency, High(Int64) - 7);
  CheckJsonExact('-922337203685477.58',   varCurrency, Low(Int64) + 8);
  CheckJsonValue('9223372036854775808',   varDouble, 9223372036854775808.0,
    '9.2233720368547758E18');
  CheckJsonValue('-9223372036854775809',  varDouble, -9223372036854775809.0,
    '-9.2233720368547758E18');
  CheckJsonValue('9999999999999999999',   varDouble, 9999999999999999999.0,
    '1E19');
  CheckJsonValue('-9999999999999999999',  varDouble, -9999999999999999999.0,
    '-1E19');
  CheckJsonValue('922337203685477.5808',  varDouble, 922337203685477.5808,
    '9.2233720368547762E14');
  CheckJsonValue('-922337203685477.5809', varDouble, -922337203685477.5809,
    '-9.2233720368547762E14');
  CheckJsonValue('9223372036854775.8',    varDouble, 9223372036854775.8,
    '9.223372036854776E15');
  CheckJsonValue('0.0000000000000000001', varDouble, 1E-19,
    '9.9999999999999998E-20');
  CheckJsonValue('1E0', varInteger, 1 ,'1');
  CheckJsonValue('1E1', varDouble, 10, '10');
  CheckJsonValue('1E2', varDouble, 100, '100');
  CheckJsonValue('10E1', varDouble, 100, '100');
  CheckJsonValue('10E2', varDouble, 1000, '1000');
  CheckJsonValue('10E12', varDouble, 1E13,
    {$ifdef WIN32DELPHI} '1000000000000' {$else} '1E13' {$endif} );
  CheckJsonValue('2E101', varDouble, 2E101);
  CheckJsonValue('-1E0', varInteger, -1 ,'-1');
  CheckJsonValue('-1E1', varDouble, -10, '-10');
  CheckJsonValue('-1E2', varDouble, -100, '-100');
  CheckJsonValue('-1E12', varDouble, -1E12
    {$ifdef WIN32DELPHI}, '-1000000000000' {$endif} );
  CheckJsonValue('-2E101', varDouble, -2E101);
  s := '9223372036854775808';
  Check(GetNumericVariantFromJson(pointer(s), TVarData(vj), false) = nil);
  s := '9223372036854775.8';
  Check(GetNumericVariantFromJson(pointer(s), TVarData(vj), false) = nil);
  CheckInvalidNumber('');
  CheckInvalidNumber(' ');
  CheckInvalidNumber('+');
  CheckInvalidNumber('-');
  CheckInvalidNumber('  +');
  CheckInvalidNumber('  -');
  {$ifndef WIN32DELPHI}
  d := mormot.core.text.NaN;
  CheckGetExtendedBits('-nAn', PQWord(@d)^);
  CheckGetExtendedBits('  +NaNtail', PQWord(@d)^);
  CheckGetExtendedBits('  -NaN', PQWord(@d)^);
  CheckGetExtendedBits('+iNf', $7FF0000000000000);
  CheckGetExtendedBits('  -INfinity', QWord($FFF0000000000000));
  CheckInvalidNumber('N');
  CheckInvalidNumber('Na');
  CheckInvalidNumber('I');
  CheckInvalidNumber('In');
  CheckInvalidNumber('- NaN');
  CheckGetExtendedBits('0.00000000000000000770000', $3C61C14719F3FABC);
  CheckGetExtendedBits('0.000000007832000000000000', $3E40D1B00240A588);
  CheckGetExtendedBits('228518839.2', $41AB3DD76E666666);
  CheckGetExtendedBits('228518839.20000000', $41AB3DD76E666666);
  CheckGetExtendedBits('-228518839.20000000', QWord($C1AB3DD76E666666));
  {$endif WIN32DELPHI}
  CheckJsonDoubleBits('0.00000000000000000770000', $3C61C14719F3FABC);
  CheckJsonDoubleBits('0.000000007832000000000000', $3E40D1B00240A588);
  CheckJsonDoubleBits('228518839.20000000', $41AB3DD76E666666);
  CheckJsonDoubleBits('-228518839.20000000', QWord($C1AB3DD76E666666));
  // The dot/first fractional digit can straddle the 16-byte SIMD window.
  CheckJsonExact('100000000000000.000', varCurrency, 1000000000000000000);
  CheckJsonExact('100000000000000.0001', varCurrency, 1000000000000000001);
  CheckJsonExact('1234567890123456', varInt64, 1234567890123456);
  CheckJsonDoubleBits('1.25e0004', $40C86A0000000000);
  {$ifndef WIN32DELPHI}
  CheckGetExtendedBits('100000000000000.000', $42D6BCC41E900000);
  CheckGetExtendedBits('1234567890123456', $43118B54F22AEB00);
  CheckGetExtendedBits('1.25e0004', $40C86A0000000000);
  s := '228518839.20000000' + '","next":1';
  d := GetExtended(pointer(s), err);
  CheckEqual(err, 1);
  CheckUtf8(PQWord(@d)^ = $41AB3DD76E666666, s);
  {$endif WIN32DELPHI}
  s := '100000000000000.0001,"next":1';
  P := GetNumericVariantFromJson(pointer(s), TVarData(vj), false);
  Check(P = PUtf8Char(pointer(s)) + 20);
  CheckEqual(TVarData(vj).VType, varCurrency);
  CheckEqual(TVarData(vj).VInt64, 1000000000000000001);
  CheckJsonDoubleBits('-922337203685477580.8', QWord($C3A999999999999A));
  CheckJsonDoubleBits('-92233720368547758.08', QWord($C3747AE147AE147B));
  CheckJsonDoubleBits('-9223372036854775.808', QWord($C340624DD2F1A9FC));
  CheckJsonDoubleBits('-9223372036854775808.0', QWord($C3E0000000000000));
  s := '0.' + RawUtf8(StringOfChar('0', 324));
  Check(GetNumericVariantFromJson(pointer(s), TVarData(vj), false) = PUtf8Char(pointer(s)) + length(s));
  CheckEqual(TVarData(vj).VType, varInteger);
  CheckEqual(TVarData(vj).VInteger, 0);
  s := '-0e-400';
  Check(GetNumericVariantFromJson(pointer(s), TVarData(vj), false) = PUtf8Char(pointer(s)) + length(s));
  CheckEqual(TVarData(vj).VType, varInteger);
  CheckEqual(TVarData(vj).VInteger, 0);
  CheckInvalidNumber('1.2.3');
  CheckInvalidNumber('0..1');
  CheckInvalidNumber('toto');
  CheckInvalidNumber('e1');
  CheckInvalidNumber('-e1');
  CheckInvalidNumber('.e2');
  CheckInvalidNumber('-.e2');
  CheckInvalidNumber('1e');
  CheckInvalidNumber('1e+');
  CheckInvalidNumber('.5', false); // GetExtended intentionally also accepts Pascal syntax
  CheckInvalidNumber('1.', false);
  CheckInvalidNumber('1.e2', false);
  CheckInvalidNumber('01', false);
  CheckInvalidNumber('+1', false);
  CheckInvalidNumber('1e400');
  CheckInvalidNumber('1e-400');
  // decimal text should be parsed as the nearest IEEE double: digits*POW10[-n]
  // was not, since 1E-1..1E-22 are inexact - e.g. '1.2' = 1.2000000000000002
  CheckGetExtendedBits('1.2', $3FF3333333333333);
  CheckGetExtendedBits('-1.2', QWord($BFF3333333333333));
  CheckGetExtendedBits('12e-1', $3FF3333333333333);
  CheckGetExtendedBits('0.1', $3FB999999999999A);
  CheckGetExtendedBits('0.3', $3FD3333333333333);
  CheckGetExtendedBits('0.7', $3FE6666666666666);
  CheckGetExtendedBits('1.15', $3FF2666666666666);
  CheckGetExtendedBits('39.9', $4043F33333333333);
  CheckGetExtendedBits('100.1', $4059066666666666);
  CheckGetExtendedBits('0.35', $3FD6666666666666);
  CheckGetExtendedBits('4.52', $4012147AE147AE14);
  CheckGetExtendedBits('452E-2', $4012147AE147AE14);
  CheckGetExtendedBits('2.675', $4005666666666666);
  CheckGetExtendedBits('0.009', $3F826E978D4FDF3B);
  CheckGetExtendedBits('10000.05', $40C3880666666666);
  CheckGetExtendedBits('0.0003', $3F33A92A30553261);
  CheckGetExtendedBits('0.00003', $3EFF75104D551D69);
  s := '0.0000000000000000001';
  d := GetExtended(pointer(s), err);
  CheckEqual(err, 0);
  CheckSame(d, 1E-19, 0);
  s := '9223372036854775808';
  d := GetExtended(pointer(s), err);
  CheckEqual(err, 0);
  CheckSame(d, 9223372036854775808.0, 0);
  s := '1.7976931348623157e308';
  d := GetExtended(pointer(s), err);
  CheckEqual(err, 0);
  Check(not IsInfinite(d) and (d > 1.79e308));
  if not HasFP80 then // FP80 has more precision
  begin
    s := '99e307';
    d := GetExtended(pointer(s), err);
    Check(err <> 0);
    Check(not IsInfinite(d));
  end;
  // GetNumericVariantFromJson() had the same issue for varDouble values
  // (with both SSE2 and x87 FPU, since its local d variable is a double)
  CheckJsonDoubleBits('0.00003', $3EFF75104D551D69);
  CheckJsonDoubleBits('0.00006', $3F0F75104D551D69);
  CheckJsonDoubleBits('-0.00007', QWord($BF12599ED7C6FBD2));
  CheckJsonDoubleBits('0.00012', $3F1F75104D551D69);
  BenchmarkNumbers;
  // validate ScanUtf8()
  Check(ScanUtf8('1 2 3', '  %', [@i, @j, @d]) = 0);
  Check(ScanUtf8('', '%d%d%f', [@i, @j, @d]) = 0);
  Check(ScanUtf8('1 2 7', '%d%d%f', [@i, @j, @d]) = 3);
  Check(i = 1);
  Check(j = 2);
  Check(d = 7);
  Check(ScanUtf8('2/3/8.1', '%d/%d/%f', [@i, @j, @d]) = 3);
  Check(i = 2);
  Check(j = 3);
  CheckSame(d, 8.1);
  Check(ScanUtf8('5 / 6/3', '%d/%d / %f', [@i, @j, @d]) = 3);
  Check(i = 5);
  Check(j = 6);
  Check(d = 3);
  Check(ScanUtf8('15 25 35', '%d%D', [@i, @k, @d]) = 2);
  Check(i = 15);
  Check(k = 25);
  Check(d = 3);
  Check(ScanUtf8('1 21 35', '%d%d%f', [@i, @j]) = 2);
  Check(i = 1);
  Check(j = 21);
  Check(d = 3);
  Check(ScanUtf8(' 10  20  abc  ', '%d%d%s', [@i, @j, @a]) = 3);
  Check(i = 10);
  Check(j = 20);
  Check(a = 'abc');
  Check(ScanUtf8('1 00000002 3.01234 ', '%dtoto %x%Ftiti', [@i, @j, @c]) = 3);
  Check(i = 1);
  Check(j = 2);
  Check(c = 3.0123);
  Check(ScanUtf8('10 0000000a 77.77 7', '%dtoto %x%Ftiti%Uboat', [@i, @j, @c, @crc],
    @ident) = 4);
  Check(i = 10);
  Check(j = 10);
  Check(c = 77.77);
  Check(crc = 7);
  Check(Length(ident) = 4);
  Check(ident[0] = 'dtoto');
  Check(ident[1] = 'x');
  Check(ident[2] = 'Ftiti');
  Check(ident[3] = 'Uboat');
  Check(xxHash32(0, 'A', 1) = 275094093);
  Check(xxHash32(0, 'ABACK', 5) = 314231639);
  Check(xxHash32(0, 'ABBREVIATIONS', 13) = 3058487595);
  Check(xxHash32(0, 'LORD', 4) = 3395586315);
  Check(xxHash32(0, 'MICROINSTRUCTION''S', 18) = 1576115228);
  a[0] := #0;
  AppendShortIntHex(0, a);
  Check(a = '00');
  AppendShortIntHex(1, a);
  Check(a = '0001');
  AppendShortIntHex(255, a);
  Check(a = '0001ff');
  AppendShortIntHex($12345, a);
  Check(a = '0001ff012345');
  a[0] := #0;
  AppendShortIntHex(Int64(-1), a);
  CheckEqual(length(a), SizeOf(Int64) * 2);
  for i := 1 to length(a) do
    Check(a[1] = 'f');
  CheckEqual(ParseHex0x('0x3f',   {no0x=}false), $3f, '3f');
  CheckEqual(ParseHex0x('0x3ff',  {no0x=}false), $3ff, '3ff');
  CheckEqual(ParseHex0x(' 0x3ff', {no0x=}false), $3ff, '3ff2');
  CheckEqual(ParseHex0x('0x3ff ', {no0x=}false), $3ff, '3ff3');
  CheckEqual(ParseHex0x('0x3ff'#13#10,  {no0x=}false), $3ff, '3ff4');
  CheckEqual(ParseHex0x(' 0x3ff'#13#10, {no0x=}false), $3ff, '3ff4');
  for i := -10000 to 10000 do
    Check(GetInteger(Pointer(Int32ToUtf8(i))) = i);
  for i := 0 to 10000 do
  begin
    j := i shr 6; // circumvent weird FPC code generation bug in -O2 mode
    rnd.FillAscii(j, s);
    CheckHash(s, Hash32Reference(pointer(s), length(s)));
    Check(kr32(0, pointer(s), length(s)) = kr32reference(pointer(s), length(s)));
    Check(fnv32(0, pointer(s), length(s)) = fnv32reference(0, pointer(s), length(s)));
    crc := crc32creference(0, pointer(s), length(s));
    Check(crc32cfast(0, pointer(s), length(s)) = crc);
    Check(crc32c(0, pointer(s), length(s)) = crc);
    if s <> '' then
      Check(xxhash32(0, pointer(s), length(s)) = xxHash32reference(pointer(s),
        length(s)));
    if i <> 0 then
      j := rnd.Next; // always validate j=0 value
    str(j, a);
    s := RawUtf8(a);
    u := string(a);
    CheckEqual(OctToBin(s), s);
    CheckEqual(TestAddFloatStr(s), s);
    Check(SysUtils.IntToStr(j) = u);
    s2 := Int32ToUtf8(j);
    Check(TextToVariantNumberType(pointer(s2)) = varInt64);
    Check(TextToVariantNumberTypeNoDouble(pointer(s2)) = varInt64);
    CheckEqual(s2, s);
    Check(format('%d', [j]) = u);
    Check(GetInteger(pointer(s)) = j);
    CheckEqual(FormatUtf8('%', [j]), s);
    CheckEqual(FormatSql('?', [], [j]), ':(' + s + '):');
    CheckEqual(FormatUtf8('%?', [j]), s + '?');
    CheckEqual(FormatUtf8('?%', [j]), '?' + s);
    CheckEqual(FormatUtf8('?%?', [j]), '?' + s + '?');
    CheckEqual(FormatUtf8('?%%?', [j]), '?' + s + '?');
    CheckEqual(FormatUtf8('?%?%  ', [j]), '?' + s + '?  ');
    CheckEqual(FormatSql('?%', [], [j]), ':(' + s + '):');
    CheckEqual(FormatSql('%?', [j], [j]), s + ':(' + s + '):');
    CheckEqual(FormatSql('%?', [s], [s]), s + ':(''' + s + '''):');
    CheckEqual(FormatUtf8('% ', [j]), s + ' ');
    CheckEqual(FormatSql('? ', [], [j]), ':(' + s + '): ');
    CheckEqual(FormatUtf8('% %', [j]), s + ' ');
    CheckEqual(FormatUtf8(' % %', [j]), ' ' + s + ' ');
    CheckEqual(FormatSql(' ?? ', [], [j]), ' :(' + s + '): ');
    CheckEqual(FormatJson('?', [], [j]), s);
    CheckEqual(FormatJson('?%', [], [j]), s);
    CheckEqual(FormatJson('? ', [], [j]), s + ' ');
    CheckEqual(FormatJson(' ?? ', [], [j]), ' ' + s + ' ');
    CheckEqual(FormatJson('?%', [], [s]), '"' + s + '"');
    CheckEqual(FormatJson(' ?? ', [], [s]), ' "' + s + '" ');
    CheckEqual(FormatJson('? %', [s], [s]), '"' + s + '" ' + s);
    vj := variant(j);
    RawUtf8ToVariant(s, vs);
    CheckEqual(FormatJson(' ?? ', [], [vj]), ' ' + s + ' ');
    CheckEqual(FormatSql(' ?? ', [], [vj]), ' :(' + s + '): ');
    CheckEqual(FormatSql('% ?', [vj], [vj]), s + ' :(' + s + '):');
    CheckEqual(FormatSql(' ?? ', [], [vs]), ' :(''' + s + '''): ');
    CheckEqual(FormatSql('% ?', [vj], [vj]), s + ' :(' + s + '):');
    CheckEqual(FormatJson('? %', [vj], [vj]), s + ' ' + s);
    CheckEqual(FormatJson(' ?? ', [], [vs]), ' "' + s + '" ');
    CheckEqual(FormatJson('? %', [vs], [vj]), s + ' ' + s);
    k := Int64(j) * rnd.Next(MaxInt);
    b := rnd.Next(64);
    s := GetBitCsv(k, b);
    l := 0;
    P := pointer(s);
    SetBitCsv(l, b, P);
    Check(P = nil);
    while b > 0 do
    begin
      dec(b);
      Check(GetBit(l, b) = GetBit(k, b));
    end;
    str(k, a);
    s := RawUtf8(a);
    u := string(a);
    CheckEqual(TestAddFloatStr(s), s);
    Check(SysUtils.IntToStr(k) = u);
    Check(IsAnsiCompatible(s));
    Check(Int64ToUtf8(k) = s);
    Check(IntToString(k) = u);
    Check(format('%d', [k]) = u);
    Check(FormatUtf8('%', [k]) = s);
    Check(FormatSql('?', [], [k]) = ':(' + s + '):');
    err := 1;
    l := GetInt64(pointer(s), err);
    Check(l = k);
    Check(err = 0);
    dec(l);
    SetInt64(pointer(s), l);
    Check(l = k);
    if k >= 0 then
    begin
      l := GetQWord(pointer(s), err);
      Check(l = k);
      Check(err = 0);
      dec(l);
      SetQword(pointer(s), QWord(l));
      Check(l = k);
    end;
    s := s + 'z';
    l := GetInt64(pointer(s), err);
    Check(err <> 0);
    case i of // validate some explicit ToVarUInt32/64 boundaries
      8999:
        j := $0000000f;
      9990:
        j := $000000ff;
      9991:
        j := $00003fff;
      9992:
        j := $00004000;
      9993:
        j := $00004001;
      9994:
        j := $001fffff;
      9995:
        j := $00200000;
      9996:
        j := $00200001;
      9997:
        j := $0fffffff;
      9998:
        j := $10000000;
      9999:
        j := $10000001;
    end;
    str(j, a);
    Check(SysUtils.IntToStr(j) = string(a));
    Check(format('%d', [j]) = string(a));
    Check(format('%.8x', [j]) = IntToHex(j, 8));
    if j >= 0 then
    begin
      a[0] := #0;
      AppendShortIntHex(j, a); // with DisplayMinChars() trimming
      CheckUtf8(PointerToHexShort(pointer(PtrInt(j))) = a, 'p2hex %=%', [j, a]);
      CheckUtf8(IdemPropName(a, ToHexShort(@j, 4)), '2hex %=%', [j, a]);
      CheckUtf8(IdemPropNameU(Int64ToHexLower(j), @a[1], ord(a[0])), 'i2hex %', [a]);
      a[ord(a[0]) + 1] := #0; // make valid PAnsiChar
      CheckEqual(ParseHex0x(@a[1], {no0x=}true), j, '8-bit hex');
      if a[1] = '0' then
        CheckEqual(ParseHex0x(@a[2], {no0x=}true), j, '4-bit hex');
      CheckEqual(ParseHex0x(@a[1], {no0x=}false), 0, '0x');
    end;
    case i of
      9990:
        d := 1E110;
      9991:
        d := 1E-110;
      9992:
        d := 1E210;
      9993:
        d := 1E-210;
    else
      d := rnd.NextDouble * 1E-17 - rnd.NextDouble * 1E-19;
    end;
    str(d, a);
    s := RawUtf8(a);
    e := GetExtended(Pointer(s), err);
    Check(err = 0, 'GetExt1');
    Check(SameValue(e, d, 0)); // validate str()
    s := ExtendedToStr(d, DOUBLE_PRECISION);
    e := GetExtended(Pointer(s), err);
    Check(err = 0, 'GetExt2');
    Check(SameValue(e, d, 0));
    err := TextToVariantNumberType(pointer(s));
    if CheckFailed(err in [varDouble, varCurrency], 'TextToVariantNumberType') then
      NotifyProgress(['TextToVariantNumberType(', s, ')=', err], ccLightRed);
    Check(TextToVariantNumberTypeNoDouble(pointer(s)) = varString);
    e := d;
    if (i < 9000) or
       (i > 9999) then
    begin
      a[0] := AnsiChar(ExtendedToShort(@a, d, DOUBLE_PRECISION));
      a2[0] := AnsiChar(DoubleToShort(@a2, d));
      Check(a = a2);
      a[0] := AnsiChar(ExtendedToShortNoExp(@a, d, DOUBLE_PRECISION));
      a2[0] := AnsiChar(DoubleToShortNoExp(@a2, d));
      Check(a = a2);
      CheckEqual(TestAddFloatStr(s), s);
      Check(not SameValue(e + 1, d));
      sd := d;
      Check(d = e);
      Check(SortDynArrayDouble(d, d) = 0);
      Check(SortDynArrayDouble(d, e) = 0);
      se := sd;
      Check(SortDynArraySingle(sd, sd) = 0);
      Check(SortDynArraySingle(sd, se) = 0);
    end;
    if d < 0 then
      e := e * 0.9
    else
      e := e * 1.1;
    check(d < e);
    Check(SortDynArrayDouble(d, e) = -1);
    Check(SortDynArrayDouble(e, d) = 1);
    if (i < 9000) or
       (i > 9999) then
    begin
      se := e;
      Check(SortDynArraySingle(sd{%H-}, se) = -1);
      Check(SortDynArraySingle(se, sd) = 1);
    end;
    PC := ToVarUInt32(juint, @varint);
    Check(PC <> nil);
    Check(PtrUInt(PC) - PtrUInt(@varint) = ToVarUInt32Length(juint));
    PB := @varint;
    Check(PtrUInt(FromVarUint32(PB)) = juint);
    Check(PB = PC);
    PC := ToVarUInt32(i, @varint);
    Check(PC <> nil);
    PB := @varint;
    Check(PtrUInt(FromVarUint32(PB)) = PtrUInt(i));
    Check(PB = PC);
    PB := FromVarUInt32Safe(@varint, PC, u32);
    Check(PtrUInt(u32) = PtrUInt(i));
    Check(PB = PC);
    PC := ToVarInt32(j, @varint);
    Check(PC <> nil);
    PB := @varint;
    CheckEqual(FromVarInt32(PB), j);
    Check(PB = PC);
    PC := ToVarInt32(i - 1, @varint);
    Check(PC <> nil);
    PB := @varint;
    Check(FromVarInt32(PB) = i - 1);
    Check(PB = PC);
    PC := ToVarUInt64(juint, @varint);
    Check(PC <> nil);
    Check(PtrUInt(PC) - PtrUInt(@varint) = ToVarUInt32Length(juint));
    PB := @varint;
    Check(PtrUInt(FromVarUint64(PB)) = juint);
    Check(PB = PC);
    PB := FromVarUInt64Safe(@varint, PC, q);
    Check(q = juint);
    Check(PB = PC);
    PC := ToVarInt64(k, @varint);
    Check(PC <> nil);
    PB := @varint;
    CheckEqual(FromVarInt64(PB), k);
    Check(PB = PC);
    CheckEqual(FromVarInt64Value(@varint), k);
    PC := ToVarInt64(i, @varint);
    Check(PC <> nil);
    PB := @varint;
    Check(FromVarInt64(PB) = i);
    Check(PB = PC);
    if k < 0 then
      k := -k;
    PC := ToVarUInt64(k, @varint);
    Check(PC <> nil);
    PB := @varint;
    Check(FromVarUint64(PB) = k);
    Check(PB = PC);
    PC := ToVarUInt64(i, @varint);
    Check(PC <> nil);
    PB := @varint;
    Check(FromVarUint64(PB) = i);
    Check(PB = PC);
    PC := @varint;
    for n := 0 to 49 do
      PC := ToVarUInt32(juint + n, PC);
    check(PC <> nil);
    {%H-}st.Init(@varint, PAnsiChar(PC) - PAnsiChar(@varint));
    check(not st.EOF);
    for n := 0 to 48 do
      check(st.VarUInt32 = cardinal(juint + n));
    check(not st.EOF);
    check(st.VarUInt32 = cardinal(juint + 49));
    check(pointer(st.P) = pointer(PC));
    check(st.EOF);
    st.Init(@varint, PAnsiChar(PC) - PAnsiChar(@varint));
    check(not st.EOF);
    for n := 0 to 49 do
      check(st.VarUInt64 = cardinal(juint + n));
    check(pointer(st.P) = pointer(PC));
    check(st.EOF);
    st.Init(@varint, PAnsiChar(PC) - PAnsiChar(@varint));
    for n := 0 to 48 do
      st.VarNextInt;
    check(not st.EOF);
    check(st.VarUInt32 = cardinal(juint + 49));
    check(pointer(st.P) = pointer(PC));
    check(st.EOF);
    st.Init(@varint, PAnsiChar(PC) - PAnsiChar(@varint));
    st.VarNextInt(49);
    check(not st.EOF);
    check(st.VarUInt32 = cardinal(juint + 49));
    check(pointer(st.P) = pointer(PC));
    check(st.EOF);
  end;
  exit; // code below is speed informative only, without any test
  Timer.Start;
  for i := 0 to 99999 do
    SysUtils.IntToStr(Int64(7777) * rnd.Next);
  NotifyTestSpeed('SysUtils.IntToStr', 100000, 0, @Timer);
  Timer.Start;
  for i := 0 to 99999 do
    StrInt64(@varint[31], Int64(7777) * rnd.Next);
  NotifyTestSpeed('StrInt64', 100000, 0, @Timer);
end;

function LowerCaseAscii7(const S: RawByteString): RawUtf8;
var
  Ch: AnsiChar;
  L: Integer;
  Source, Dest: PAnsiChar;
begin
  L := Length(S);
  Dest := FastSetString(result, L);
  Source := Pointer(S);
  while L <> 0 do
  begin
    Ch := Source^;
    if (Ch >= 'A') and
       (Ch <= 'Z') then
      Inc(Ch, 32);
    Dest^ := Ch;
    Inc(Source);
    Inc(Dest);
    Dec(L);
  end;
end;

procedure TTestCoreBase.BaudotCode;
var
  u: RawUtf8;
  b: RawByteString;
  i, j, k: integer;
  P: PAnsiChar absolute u;
const
  CHR: array[0..82] of AnsiChar =
    'abcdefghijklm nopqrstuvwx yzabcdefghijklm nopqrstuvwx yz012345 6789-''3,!:(+)$?@./; ';
begin
  b := AsciiToBaudot('');
  check(b = '');
  b := AsciiToBaudot('abc');
  u := BaudotToAscii(b);
  check(u = 'abc');
  b := AsciiToBaudot('mORMot.net');
  check(BaudotToAscii(b) = 'mormot.net');
  EnsureRawUtf8(b);
  b := b + #0#0#0;
  u := BaudotToAscii(b);
  check(u = 'mormot.net');
  b := AsciiToBaudot('https://synopse.info');
  u := BaudotToAscii(b);
  check(u = 'https://synopse.info');
  b := AsciiToBaudot('abcdef 1234 5678'#13#10'ABCD;/23u'#13#10'op @toto.#com');
  check(b <> '');
  u := BaudotToAscii(b);
  check(u = 'abcdef 1234 5678'#13#10'abcd;/23u'#13#10'op @toto.com');
  for i := 1 to 200 do
  begin
    SetLength(u, i);
    for k := 1 to 50 do
    begin
      for j := 0 to i - 1 do
        P[j] := CHR[rnd.Next(83)];
      b := AsciiToBaudot(u);
      check(BaudotToAscii(b) = u);
    end;
  end;
end;

function ARawSetString: RawByteString;
var
  S: RawByteString;
begin
  S := '123456';
  SetString(result, PAnsiChar(pointer(S)), Length(S));
end;

function ARawFastSetString: RawByteString;
var
  S: RawByteString;
begin
  S := '123456';
  FastSetRawByteString(result, pointer(S), Length(S));
end;

procedure TTestCoreBase.Utf8Slow(Context: TObject);

  procedure CaseFoldingTest;
  const
    _CASEFOLDINGTESTS: array[0..23] of word =
      ($61, $41, $62, $42, $e0, $c0, $fd, $dd, $14b, $14a, $371, $370,
       $3F3, $37F, $451, $401, $435, $415, $442, $422, $4e1, $4e0, $2d00, $10a0);
  var
    i, j: PtrInt;
    up, lo, up2: array[0..10] of AnsiChar;
    src, dst: TByteToAnsiChar;
  begin
    CheckEqual('A', UpperCaseReference('a'));
    CheckEqual('ABC', UpperCaseReference('aBc'));
    CheckEqual('ABCDEF', UpperCaseReference('aBcdEf'));
    CheckEqual('ABCDEFGH', UpperCaseReference('aBcdEfgh'));
    for i := 0 to 11 do
    begin
      lo[Ucs4ToUtf8(_CASEFOLDINGTESTS[i * 2], @lo)] := #0;
      up[Ucs4ToUtf8(_CASEFOLDINGTESTS[i * 2 + 1], @up)] := #0;
      PInt64(@up2)^ := 0;
      Utf8UpperReference(@lo, @up2);
      Check(StrComp(@up, @up2) = 0, 'CaseFolding');
      PInt64(@up2)^ := 0;
      Utf8UpperReference(@lo, @up2, StrLen(@lo));
      Check(StrComp(@up, @up2) = 0, 'CaseFolding');
      CheckEqual(Utf8ICompReference(@lo, @up), 0, 'CaseFoldingComp');
      CheckEqual(Utf8ILCompReference(@lo, @up, StrLen(@lo), StrLen(@up)), 0,
        'CaseFoldingLComp');
    end;
    FillCharFast(src, SizeOf(src), ord('a'));
    for i := 0 to 200 do
    begin
      FillCharFast(dst, SizeOf(dst), 10);
      UpperCopy255Buf(@dst, @src, i)^ := #0;
      Check(StrLen(@dst) = i);
      Check(StrLenSafe(@dst) = i);
      Check(ByteScanIndex(@dst, SizeOf(dst), 0) = i);
      if i = 0 then
        continue;
      Check(ByteScanIndex(@dst, i, 0) < 0);
      for j := 0 to i - 1 do
        Check(dst[j] = 'A');
    end;
  end;

  procedure Test(CP: cardinal; const W: WinAnsiString);
  var
    C: TSynAnsiConvert;
    A: RawByteString;
    U: RawUtf8;
  begin
    C := TSynAnsiConvert.Engine(CP);
    CheckEqual(C.CodePage, CP, 'cpa');
    C.AnsiToUtf8(W, U);
    A := C.Utf8ToAnsi(U);
    if W = '' then
      exit;
    {$ifdef HASCODEPAGE}
    CP := StringCodePage(A);
    CheckEqual(CP, C.CodePage, 'cpb');
    CheckEqual(CP, GetCodePage(A), 'cpc');
    {$endif HASCODEPAGE}
    CheckEqual(length(W), length(A));
    CheckUtf8(EqualBuf(W, A), 'CP%', [CP]);
  end;

  procedure CheckTrimCopy(const S: RawUtf8; start, count: PtrInt);
  var
    t, c, u: RawUtf8;
  begin
    c := copy(S, start, count);
    TrimCopy(S, start, count, t);
    CheckEqual(t, TrimU(c));
    TrimU(c, u);
    CheckEqual(t, u);
    TrimLeftCopy(S, start, count, t);
    CheckEqual(t, TrimLeft(c));
    TrimRightCopy(S, start, count, t);
    CheckEqual(t, TrimRight(c));
  end;

  procedure CheckCleanThreadName(s, exp: RawUtf8);
  begin
    CleanThreadName(s);
    CheckEqual(s, exp);
  end;

var
  i, j, k, len, len120, lenup100, CP, L, lcid: integer;
  bak, bakj: AnsiChar;
  W, W2: WinAnsiString;
  WS: WideString;
  SU, SU2: SynUnicode;
  WU: array[0..3] of WideChar;
  WU2: array[0..15] of WideChar;
  str: string;
  ss: ShortString;
  fn: TFileName;
  up4: RawUcs4;
  U, U1, U2, res, Up, Up2, json, json1, json2, s1, s2, s3: RawUtf8;
  arr, arr2: TRawUtf8DynArray;
  P: PUtf8Char;
  PB: PByte;
  PW: PWideChar;
  q: RawUtf8;
  Unic: RawByteString;
  Ucs4: RawUcs4;
  WA: Boolean;
  lng: TLanguage;
  rb1, rb2, rb3: RawByteString;
  eng: TSynAnsiConvert;
const
  ROWIDS: array[0..17] of PUtf8Char = ('id', 'ID', 'iD', 'rowid', 'ROWid',
    'ROWID', 'rowiD', 'ROWId', // ok
    'id2', 'id ', 'idd', 'i', 'rowi', 'row', 'ROWI', 'ROW', 'ROWIDD', 'ROWID ');
  IDPU: array[0..15] of PUtf8Char = ('anything', 't', '1', 'te', 'tE', 'TE',
    'tes', 'test', 'TeSt', 'teS', 'tesT', 'testE', 'T', 'T', '1', 'teste');
  IDPA: array[0..15] of PAnsiChar = (nil, 'T', '1', 'TE', 'TE', 'TE', 'TES',
    'TEST', 'TEST', 'TES', 'TEST', 'TESTE', 't', 'U', '2', 'TESTe');
  CHINESE_TEXT: array[0..8] of byte = (
    $e4, $b8, $ad, $e6, $96, $87, $61, $62, $63);
  UTF8_UCS4: array[0..11] of cardinal = ($01, $81, $801, $fff, $ffff, $10000,
    UNICODE_MAX, UNICODE_MAX + 1, $1000000, $2000000, $10000000, $7f000000);
begin
  // Trim*() functions
  CheckEqual(TrimU(''), '');
  CheckEqual(TrimU('a'), 'a');
  CheckEqual(TrimU(' a'), 'a');
  CheckEqual(TrimU('a '), 'a');
  CheckEqual(TrimU(' a '), 'a');
  CheckEqual(TrimU('ab'), 'ab');
  CheckEqual(TrimU(' ab'), 'ab');
  CheckEqual(TrimU('ab '), 'ab');
  CheckEqual(TrimU(' ab '), 'ab');
  CheckEqual(TrimU(' a b '), 'a b');
  CheckEqual(TrimLeft(''), '');
  CheckEqual(TrimLeft('a'), 'a');
  CheckEqual(TrimLeft(' a'), 'a');
  CheckEqual(TrimLeft('a '), 'a ');
  CheckEqual(TrimLeft(' a '), 'a ');
  CheckEqual(TrimLeft('ab'), 'ab');
  CheckEqual(TrimLeft(' ab'), 'ab');
  CheckEqual(TrimLeft('ab '), 'ab ');
  CheckEqual(TrimLeft(' ab '), 'ab ');
  CheckEqual(TrimLeft(' a b '), 'a b ');
  CheckEqual(TrimRight(''), '');
  CheckEqual(TrimRight('a'), 'a');
  CheckEqual(TrimRight(' a'), ' a');
  CheckEqual(TrimRight('a '), 'a');
  CheckEqual(TrimRight(' a '), ' a');
  CheckEqual(TrimRight('ab'), 'ab');
  CheckEqual(TrimRight(' ab'), ' ab');
  CheckEqual(TrimRight('ab '), 'ab');
  CheckEqual(TrimRight(' ab '), ' ab');
  CheckEqual(TrimRight(' a b '), ' a b');
  CheckEqual(TrimChar('abcd', []), 'abcd');
  CheckEqual(TrimChar('abcd', ['e']), 'abcd');
  CheckEqual(TrimChar('abcd', ['a']), 'bcd');
  CheckEqual(TrimChar('abcdabcd', ['b']), 'acdacd');
  CheckEqual(TrimChar('abcdabcd', ['a']), 'bcdbcd');
  CheckEqual(TrimChar('abcd', ['b']), 'acd');
  CheckEqual(TrimChar('abcd', ['d', 'e']), 'abc');
  CheckEqual(TrimChar('abcd', ['a', 'b']), 'cd');
  CheckEqual(TrimChar('abcd', ['a', 'b', 'c', 'd']), '');
  CheckEqual(TrimChar('aaaa', ['a']), '');
  CheckEqual(TrimChar('aaaab', ['a', 'z']), 'b');
  CheckEqual(TrimChar('baaaa', ['a', 'c']), 'b');
  CheckEqual(OnlyChar('abcd', ['a', 'b', 'c', 'd', 'e']), 'abcd');
  CheckEqual(OnlyChar('abcd', ['a', 'b', 'd', 'e']), 'abd');
  CheckEqual(OnlyChar('abcdabcd', ['a', 'b', 'd', 'e']), 'abdabd');
  CheckEqual(OnlyChar('abcd', []), '');
  CheckEqual(OnlyChar('abcd', ['e']), '');
  CheckEqual(OnlyChar('abcd', ['a']), 'a');
  CheckEqual(OnlyChar('abcd', ['b']), 'b');
  CheckEqual(OnlyChar('abcd', ['d']), 'd');
  CheckEqual(OnlyChar('abcdz', ['d', 'z']), 'dz');
  CheckEqual(OnlyChar('abzcd', ['z']), 'z');
  CheckEqual(OnlyChar('zabzcdz', ['z']), 'zzz');
  CheckEqual(TrimOneChar('abcda', 'a'), 'bcd');
  CheckEqual(TrimOneChar('abcda', 'b'), 'acda');
  CheckEqual(TrimOneChar('abcda', 'd'), 'abca');
  CheckEqual(TrimOneChar('', 'a'), '');
  CheckEqual(TrimOneChar('a', 'a'), '');
  CheckEqual(TrimOneChar('aa', 'a'), '');
  CheckEqual(TrimOneChar('aaa', 'a'), '');
  CheckEqual(TrimOneChar('baaa', 'a'), 'b');
  CheckEqual(TrimOneChar('aaab', 'a'), 'b');
  CheckEqual(TrimOneChar('aaaba', 'a'), 'b');
  CheckEqual(TrimOneChar('aaabaa', 'a'), 'b');
  CheckEqual(TrimOneChar('a'#13#10'b'#13#10, #13), 'a'#10'b'#10);
  // + on RawByteString seems buggy on FPC - at least inconsistent with Delphi
  rb2 := ARawSetString;
  rb1 := rb2 + RawByteString('test');
  CheckEqual(rb1, '123456test', 'ARawSetString1');
  Append(rb2, 'test');
  CheckEqual(rb2, '123456test', 'ARawSetString2');
  rb2 := ARawFastSetString;
  rb3 := 'test';
  {$ifdef FPC} // circumvent FPC RTL oddity on Win32 :(
  SetCodePage(rb3, CP_RAWBYTESTRING, false);
  {$endif FPC}
  rb1 := rb2 + rb3;
  CheckEqual(rb1, '123456test', 'ARawFastSetString1');
  rb1 := ARawFastSetString;
  Append(rb1, 'test');
  CheckEqual(rb1, '123456test', 'ARawFastSetString2');
  CheckEqual(PCardinal(BOM_UTF8_CHARS)^, BOM_UTF8, 'BOM_UTF8_CHARS');
  U := '1234' + BOM_UTF8_CHARS + '5678';
  CheckEqual(PCardinalArray(U)[1] and $ffffff, BOM_UTF8, 'BOM_UTF8');
  CheckHash(U, $2F8C2556, 'BOM concat');
  CheckHash('1234' + BOM_UTF8_CHARS + '5678', $2F8C2556, 'xpacket ui.pdf');
  // raw filenames functions
  Check(SafeFileName(''));
  Check(SafePathName(''));
  Check(SafeFileName('toto'));
  Check(SafeFileName('toto.jpg'));
  Check(SafeFileName('path/toto'));
  Check(SafeFileName('path\toto.jpg'));
  Check(SafeFileName('path../toto'));
  Check(SafeFileName('path..\toto.jpg'));
  Check(SafeFileName('..path/toto'));
  Check(SafeFileName('..path\toto.jpg'));
  Check(not SafeFileName('../toto'));
  Check(not SafeFileName('..\toto.jpg'));
  Check(not SafeFileName('/toto.jpg'));
  Check(not SafeFileName('\toto.jpg'));
  Check(SafePathName('one/two'));
  Check(SafePathName('one\two'));
  Check(SafePathName('one../two'));
  Check(SafePathName('one..\two'));
  Check(SafePathName('..one/two'));
  Check(SafePathName('..one\two'));
  Check(SafePathName('one/..two'));
  Check(SafePathName('one\..two'));
  Check(SafePathName('one/two..'));
  Check(SafePathName('one\two..'));
  Check(not SafePathName('one/../two'));
  Check(not SafePathName('one\..\two'));
  Check(not SafePathName('one/..'));
  Check(not SafePathName('one\..'));
  Check(not SafePathName('../two'));
  Check(not SafePathName('..\two'));
  Check(not SafePathName('/../two'));
  Check(not SafePathName('\..\two'));
  Check(not SafePathName('/toto'));
  Check(not SafePathName('\toto'));
  Check(SafeFileNameU(''));
  Check(SafePathNameU(''));
  Check(SafeFileNameU('toto'));
  Check(SafeFileNameU('toto.jpg'));
  Check(SafeFileNameU('path/toto'));
  Check(SafeFileNameU('path\toto.jpg'));
  Check(SafeFileNameU('path../toto'));
  Check(SafeFileNameU('path..\toto.jpg'));
  Check(SafeFileNameU('..path/toto'));
  Check(SafeFileNameU('..path\toto.jpg'));
  Check(not SafeFileNameU('../toto'));
  Check(not SafeFileNameU('..\toto.jpg'));
  Check(not SafeFileNameU('/toto.jpg'));
  Check(not SafeFileNameU('\toto.jpg'));
  Check(SafePathNameU('one/two'));
  Check(SafePathNameU('one\two'));
  Check(SafePathNameU('one../two'));
  Check(SafePathNameU('one..\two'));
  Check(SafePathNameU('..one/two'));
  Check(SafePathNameU('..one\two'));
  Check(SafePathNameU('one/..two'));
  Check(SafePathNameU('one\..two'));
  Check(SafePathNameU('one/two..'));
  Check(SafePathNameU('one\two..'));
  Check(not SafePathNameU('one/../two'));
  Check(not SafePathNameU('one\..\two'));
  Check(not SafePathNameU('one/..'));
  Check(not SafePathNameU('one\..'));
  Check(not SafePathNameU('../two'));
  Check(not SafePathNameU('..\two'));
  Check(not SafePathNameU('/../two'));
  Check(not SafePathNameU('\..\two'));
  Check(not SafePathNameU('/toto'));
  Check(not SafePathNameU('\toto'));
  Check(ExtractPath('/var/toto.ext') = '/var/');
  Check(ExtractPath('c:\var\toto.ext') = 'c:\var\');
  Check(ExtractPath('toto.ext') = '');
  Check(ExtractPath('/toto.ext') = '/');
  Check(ExtractPath('c:toto.ext') = 'c:');
  CheckEqual(ExtractPathU('/var/toto.ext'), '/var/');
  CheckEqual(ExtractPathU('c:\var\toto.ext'), 'c:\var\');
  CheckEqual(ExtractPathU('toto.ext'), '');
  CheckEqual(ExtractPathU('/toto.ext'), '/');
  CheckEqual(ExtractPathU('c:toto.ext'), 'c:');
  Check(ExtractName('/var/toto.ext') = 'toto.ext');
  Check(ExtractName('c:\var\toto.ext') = 'toto.ext');
  Check(ExtractName('toto.ext') = 'toto.ext');
  Check(ExtractName('toto') = 'toto');
  Check(ExtractName('/toto.ext') = 'toto.ext');
  Check(ExtractName('c:toto.ext') = 'toto.ext');
  CheckEqual(ExtractNameU('/var/toto.ext'), 'toto.ext');
  CheckEqual(ExtractNameU('c:\var\toto.ext'), 'toto.ext');
  CheckEqual(ExtractNameU('toto.ext'), 'toto.ext');
  CheckEqual(ExtractNameU('toto'), 'toto');
  CheckEqual(ExtractNameU('/toto.ext'), 'toto.ext');
  CheckEqual(ExtractNameU('c:toto.ext'), 'toto.ext');
  Check(GetFileNameWithoutExt('/var/toto.ext') = '/var/toto');
  Check(GetFileNameWithoutExt('c:\var\toto.ext') = 'c:\var\toto');
  Check(ExtractExt('toto.ext') = '.ext');
  Check(ExtractExt('toto.ext', true) = 'ext');
  Check(ExtractExt('name') = '');
  Check(ExtractExt('name.') = '.');
  Check(ExtractExt('.ext') = '');
  Check(ExtractExt('/var/toto.ext') = '.ext');
  Check(ExtractExt('/var/toto.ext', true) = 'ext');
  Check(ExtractExt('c:\var\toto.ext') = '.ext');
  Check(ExtractExt('c:\var\toto.ext', true) = 'ext');
  Check(ExtractExt('/var/toto/') = '');
  Check(ExtractExt('/var/toto') = '');
  CheckEqual(ExtractExtU('toto.ext'), '.ext');
  CheckEqual(ExtractExtU('toto.ext', true), 'ext');
  CheckEqual(ExtractExtU('name'), '');
  CheckEqual(ExtractExtU('name.'), '.');
  CheckEqual(ExtractExtU('.ext'), '');
  CheckEqual(ExtractExtU('/var/toto.ext'), '.ext');
  CheckEqual(ExtractExtU('/var/toto.ext', true), 'ext');
  CheckEqual(ExtractExtU('c:\var\toto.ext'), '.ext');
  CheckEqual(ExtractExtU('c:\var\toto.ext', true), 'ext');
  CheckEqual(ExtractExtU('/var/toto/'), '');
  CheckEqual(ExtractExtU('/var/toto'), '');
  Check(NormalizeFileName('') = '');
  Check(NormalizeFileName('toto.ext') = 'toto.ext');
  {$ifdef OSWINDOWS}
  Check(NormalizeFileName('var\toto.ext') = 'var\toto.ext');
  Check(NormalizeFileName('\var\toto.ext') = '\var\toto.ext');
  Check(NormalizeFileName('titi\var\toto.ext') = 'titi\var\toto.ext');
  Check(NormalizeFileName('\var\') = '\var\');
  Check(NormalizeFileName('var/toto.ext') = 'var\toto.ext');
  Check(NormalizeFileName('/var/toto.ext') = '\var\toto.ext');
  Check(NormalizeFileName('titi/var/toto.ext') = 'titi\var\toto.ext');
  Check(NormalizeFileName('/var/') = '\var\');
  Check(NormalizeFileName('\var/') = '\var\');
  Check(NormalizeFileName('/var\') = '\var\');
  U := '';
  NormalizeFileNameU(U);
  CheckEqual(U, '');
  U := '/var';
  NormalizeFileNameU(U);
  CheckEqual(U, '\var');
  U := '/var\';
  NormalizeFileNameU(U);
  CheckEqual(U, '\var\');
  {$else}
  Check(NormalizeFileName('var\toto.ext') = 'var/toto.ext');
  Check(NormalizeFileName('\var\toto.ext') = '/var/toto.ext');
  Check(NormalizeFileName('titi\var\toto.ext') = 'titi/var/toto.ext');
  Check(NormalizeFileName('\var\') = '/var/');
  Check(NormalizeFileName('var/toto.ext') = 'var/toto.ext');
  Check(NormalizeFileName('/var/toto.ext') = '/var/toto.ext');
  Check(NormalizeFileName('titi/var/toto.ext') = 'titi/var/toto.ext');
  Check(NormalizeFileName('/var/') = '/var/');
  Check(NormalizeFileName('\var/') = '/var/');
  Check(NormalizeFileName('/var\') = '/var/');
  U := '';
  NormalizeFileNameU(U);
  CheckEqual(U, '');
  U := '/var';
  NormalizeFileNameU(U);
  CheckEqual(U, '/var');
  U := '/var\';
  NormalizeFileNameU(U);
  CheckEqual(U, '/var/');
  {$endif OSWINDOWS}
  CaseFoldingTest;
  for i := 0 to high(ROWIDS) do
    Check(isRowID(ROWIDS[i]) = (i < 8));
  U := 'old1,old2,old3';
  Check(not RenameInCsv('old', 'new', U));
  Check(RenameInCsv('old1', 'n1', U));
  Check(U = 'n1,old2,old3');
  Check(RenameInCsv('old2', 'n2', U));
  Check(not RenameInCsv('old2', 'news2', U));
  Check(RenameInCsv('old3', 'news3', U));
  Check(U = 'n1,n2,news3');
  Check(RenameInCsv(U, '1-2-3', U, '!'));
  Check(U = '1-2-3');
  Check(RenameInCsv('2', 'bee', U, '-'));
  Check(RenameInCsv('1', 'ah', U, '-'));
  Check(RenameInCsv('3', 'see', U, '-'));
  Check(U = 'ah-bee-see');
  for i := 0 to High(IDPU) do
    Check(IdemPChar(IDPU[i], IDPA[i]) = (i < 12));
  res :=
    '{"result":[{"000001000013":{"00100000000016":[1534510257860,103100,2000,' +
    '103108,1004,104132],"00100000000026":[1534510257860,12412,2000,12420,1004,12420],' +
    '"00100000000036":[1534510257860,1378116,2000,1378112,1004,1378112],"00100000000056":' +
    '[1534510257860,479217551,2000,479217551],"00100000000076":[1534510257860,136079943,' +
    '2000,136079943,1004,136079944],"00100000000086":[1534510257860,1648800821,2000,' +
    '1648801020,1004,1648801119],"00100000000096":[1534510257860,87877677,2000,87877678,' +
    '1004,87877678],"001000000000ec":[1534510257860,1.64,2000,1.64],"001000000000fc":[' +
    '1534510257860,1.72,2000,1.72],"0010000000010c":[1534510257860,1.64,2000,1.64],"' +
    '00100000000196":[1534510257860,0,2000,0]}}]}';
  i := StrLenSafe(@res[1]);
  check(mormot.core.base.StrLen(@res[1]) = i);
  res := 'one,two,three';
  Check(IdemPCharArrayBy2(nil, 'ONTWTH') < 0);
  CheckEqual(IdemPCharArrayBy2(pointer(res), 'OFTWTH'), -1);
  CheckEqual(IdemPCharArrayBy2(pointer(res), 'ONTWTH'), 0);
  CheckEqual(IdemPCharArrayBy2(pointer(res), 'TWONTW'), 1);
  CheckEqual(IdemPCharArrayBy2(pointer(res), 'TWTHON'), 2);
  CheckEqual(IdemPCharSep('one','one|two|three'), -1);
  CheckEqual(IdemPCharSep('one','ONE|TWO|THREE|'), 0);
  CheckEqual(IdemPCharSep('one','ZERO|ONE|TWO|THREE|'), 1);
  CheckEqual(IdemPCharSep('One','ONE|'), 0);
  CheckEqual(IdemPCharSep('OnE','ONE|'), 0);
  CheckEqual(IdemPCharSep('ONE','ONE|'), 0);
  CheckEqual(IdemPCharSep('oN','ONE|ON|'), 1);
  CheckEqual(IdemPCharSep('ONE?','ONE|'), 0);
  CheckEqual(IdemPCharSep('0ne','ONE|'), -1);
  CheckEqual(IdemPCharSep('one','ZERO|ONE|'), 1);
  CheckEqual(IdemPCharSep('tWo','ZERO|ONE|TWO|THREE|'), 2);
  CheckEqual(IdemPCharSep('threE','ZERO|ONE|TWO|THREE|'), 3);
  CheckEqual(IdemPCharSep('threEf','ZERO|ONE|TWO|THREE|'), 3);
  CheckEqual(IdemPCharSep('thre0','ZERO|ONE|TWO|THREE|'), -1);
  Check(StartWith('three', 'THREE'));
  for i := 1 to length(res) do
    Check(StartWith(res, UpperCase(copy(res, 1, i))));
  Check(EndWith('three', 'THREE'));
  Check(EndWith(res, 'E'));
  Check(EndWith(res, 'THREE'));
  Check(EndWith(res, ',THREE'));
  for i := 1 to length(res) do
    Check(EndWith(res, UpperCase(copy(res, i, 100))));
  Check(not EndWith(res, ',THREe'));
  Check(not EndWith(res, res));
  Check(not EndWith('t', ',THREe'));
  Check(not EndWith('thre', ',THREe'));
  Check(EndWithArray(res, []) < 0);
  Check(EndWithArray(res, ['E', 'F']) = 0);
  Check(EndWithArray(res, ['ONE', 'THREE']) = 1);
  Check(EndWithArray(res, ['ONE', 'three', 'THREE']) = 2);
  Check(EndWithArray(res, ['ONE', '', 'THREE']) = 1);
  Check(EndWithArray(res, ['ONE', 'three', 'THREe']) < 0);
  CheckEqual(TrimControlChars(''), '');
  CheckEqual(TrimControlChars(' '), '');
  CheckEqual(TrimControlChars('    '), '');
  CheckEqual(TrimControlChars('a'), 'a');
  CheckEqual(TrimControlChars('a '), 'a');
  CheckEqual(TrimControlChars(' a '), 'a');
  CheckEqual(TrimControlChars('a '), 'a');
  CheckEqual(TrimControlChars('a  '), 'a');
  CheckEqual(TrimControlChars(' a  '), 'a');
  CheckEqual(TrimControlChars('  a  '), 'a');
  CheckEqual(TrimControlChars('a  '), 'a');
  CheckEqual(TrimControlChars('a  b'), 'ab');
  CheckEqual(TrimControlChars('synopse.info, www.synopse.info'), 'synopse.info,www.synopse.info');
  CheckEqual(Split(res, ','), 'one', 'sp1');
  CheckEqual(Split(res, ',', s1), 'two,three', 'sp2');
  CheckEqual(s1, 'one');
  CheckEqual(Split(res, ',', s1, {toupper=}true), 'TWO,THREE');
  CheckEqual(s1, 'ONE');
  Check(Split(res, '*') = res);
  Check(Split(res, ',', 5) = 'two');
  Check(Split(res, '*', 6) = 'wo,three');
  CheckEqual(Split('titi-tata-toto', ['-'], [@s1, @s2, @s3]), 3, 'split3');
  CheckEqual(s1, 'titi', 'split3a');
  CheckEqual(s2, 'tata', 'split3b');
  CheckEqual(s3, 'toto', 'split3c');
  CheckEqual(Split('--', ['-'], [@s1, @s2, @s3]), 3, 'split0');
  CheckEqual(s1, '', 'split0a');
  CheckEqual(s2, '', 'split0b');
  CheckEqual(s3, '', 'split0c');
  CheckEqual(Split('a-b-c', ['-'], [@s1, @s2, @s3]), 3, 'split1');
  CheckEqual(s1, 'a', 'split1a');
  CheckEqual(s2, 'b', 'split1b');
  CheckEqual(s3, 'c', 'split1c');
  CheckEqual(Split('-b-c', ['-'], [@s1, @s2, @s3]), 3, 'split2');
  CheckEqual(s1, '', 'split2a');
  CheckEqual(s2, 'b', 'split2b');
  CheckEqual(s3, 'c', 'split2c');
  CheckEqual(Split('a-b-', ['-'], [@s1, @s2, @s3]), 3, 'split4');
  CheckEqual(s1, 'a', 'split4a');
  CheckEqual(s2, 'b', 'split4b');
  CheckEqual(s3, '', 'split4c');
  CheckEqual(SplitRight(res, ','), 'three');
  CheckEqual(SplitRight(res, 'r'), 'ee');
  CheckEqual(SplitRights(res, ','), 'three');
  CheckEqual(SplitRights(res, '!,'), 'three');
  CheckEqual(SplitRights(res, ',!'), 'three');
  CheckEqual(SplitRights(res, '!thr'), 'ee');
  Check(mormot.core.base.StrLen(nil) = 0);
  for i := length(res) + 1 downto 1 do
    Check(mormot.core.base.StrLen(Pointer(@res[i])) = length(res) - i + 1);
  Check(StrLenSafe(nil) = 0);
  for i := length(res) + 1 downto 1 do
    Check(StrLenSafe(Pointer(@res[i])) = length(res) - i + 1);
  CsvToRawUtf8DynArray(pointer(res), arr);
  CheckEqual(length(arr), 3);
  Check(arr[0] = 'one');
  Check(arr[1] = 'two');
  Check(arr[2] = 'three');
  arr2 := arr; // pointer
  Check(RawUtf8DynArrayEquals(arr, arr2), 'RawUtf8DynArrayEquals');
  Check(RawUtf8DynArrayContains(arr, arr2), 'RawUtf8DynArrayContains');
  Check(RawUtf8DynArraySame(arr, arr2), 'RawUtf8DynArraySame1');
  Check(RawUtf8DynArraySame(arr, arr2, {insens=}false), 'RawUtf8DynArraySame1i');
  arr2 := copy(arr);
  CheckEqual(length(arr2), 3);
  Check(RawUtf8DynArrayEquals(arr, arr2), 'RawUtf8DynArrayEquals2');
  Check(RawUtf8DynArrayContains(arr, arr2), 'RawUtf8DynArrayContains2');
  Check(RawUtf8DynArraySame(arr, arr2), 'RawUtf8DynArraySame2');
  Check(RawUtf8DynArraySame(arr, arr2, true), 'RawUtf8DynArraySame2i');
  SetLength(arr, 2);
  Check(not RawUtf8DynArrayEquals(arr, arr2), 'RawUtf8DynArrayEquals3');
  Check(RawUtf8DynArrayContains(arr, arr2), 'RawUtf8DynArrayContains3a');
  Check(not RawUtf8DynArrayContains(arr2, arr), 'RawUtf8DynArrayContains3b');
  Check(not RawUtf8DynArraySame(arr, arr2), 'RawUtf8DynArraySame3');
  Check(not RawUtf8DynArraySame(arr, arr2, true), 'RawUtf8DynArraySame3i');
  arr := CsvToRawUtf8DynArray('two,three,one');
  Check(not RawUtf8DynArrayEquals(arr, arr2), 'RawUtf8DynArrayEquals4');
  Check(RawUtf8DynArrayContains(arr, arr2), 'RawUtf8DynArrayContains4');
  Check(RawUtf8DynArraySame(arr, arr2), 'RawUtf8DynArraySame4');
  Check(RawUtf8DynArraySame(arr, arr2, true), 'RawUtf8DynArraySame4i');
  arr := CsvToRawUtf8DynArray('two,ONE,three');
  Check(not RawUtf8DynArrayEquals(arr, arr2), 'RawUtf8DynArrayEquals4');
  Check(not RawUtf8DynArrayContains(arr, arr2), 'RawUtf8DynArrayContains4');
  Check(RawUtf8DynArrayContains(arr, arr2, {insens=}true), 'RawUtf8DynArrayContains4i');
  Check(not RawUtf8DynArraySame(arr, arr2), 'RawUtf8DynArraySame4');
  Check(RawUtf8DynArraySame(arr, arr2, true), 'RawUtf8DynArraySame4i');
  arr := CsvToRawUtf8DynArray('two,one,one');
  CheckEqual(RawUtf8ArrayToCsv(arr), 'two,one,one');
  CheckEqual(RawUtf8ArrayToCsv(arr, ''), 'twooneone');
  CheckEqual(RawUtf8ArrayToCsv(arr, '/', {rev=}true), 'one/one/two');
  Check(not RawUtf8DynArrayEquals(arr, arr2), 'RawUtf8DynArrayEquals5');
  Check(RawUtf8DynArrayContains(arr, arr2), 'RawUtf8DynArrayContains5');
  Check(RawUtf8DynArrayContains(arr, arr2, {insens=}true), 'RawUtf8DynArrayContains5i');
  Check(not RawUtf8DynArraySame(arr, arr2), 'RawUtf8DynArraySame5');
  Check(not RawUtf8DynArraySame(arr, arr2, true), 'RawUtf8DynArraySame5i');
  LinesToRawUtf8DynArray('', arr);
  CheckEqual(length(arr), 0);
  LinesToRawUtf8DynArray('one', arr);
  CheckEqual(length(arr), 1);
  CheckEqual(RawUtf8ArrayToCsv(arr), 'one');
  LinesToRawUtf8DynArray('first'#13#10#13#10'one', arr);
  CheckEqual(length(arr), 2);
  CheckEqual(RawUtf8ArrayToCsv(arr), 'first,one');
  LinesToRawUtf8DynArray('first'#13#10#13#10'one'#10'two'#10#13#10, arr);
  CheckEqual(length(arr), 3);
  CheckEqual(RawUtf8ArrayToCsv(arr), 'first,one,two');
  LinesToRawUtf8DynArray(#13#10'one'#13#10, arr);
  CheckEqual(length(arr), 1);
  CheckEqual(RawUtf8ArrayToCsv(arr), 'one');
  CheckEqual(Join([]), '');
  CheckEqual(Join(['one']), 'one');
  CheckEqual(Join(['one', 'two']), 'onetwo');
  CheckEqual(Join(['', 'one', 'two']), 'onetwo');
  CheckEqual(Join(['one', 'two', ' three ']), 'onetwo three ');
  CheckEqual(Join(['one', 'two', '', 'three']), 'onetwothree');
  CheckEqual(JoinCsv('', []), '');
  CheckEqual(JoinCsv('', ['one']), 'one');
  CheckEqual(JoinCsv('', ['one', 'two']), 'onetwo');
  CheckEqual(JoinCsv('', ['', 'one', 'two']), 'onetwo');
  CheckEqual(JoinCsv('', ['one', 'two', ' three ']), 'onetwo three ');
  CheckEqual(JoinCsv('', ['one', 'two', '', 'three']), 'onetwothree');
  CheckEqual(JoinCsv(',', []), '');
  CheckEqual(JoinCsv(',', ['', '']), ',');
  CheckEqual(JoinCsv(',', ['one']), 'one');
  CheckEqual(JoinCsv(',', ['one', 'two']), 'one,two');
  CheckEqual(JoinCsv(',', ['one', 'two', ' three ']), 'one,two, three ');
  CheckEqual(JoinCsv(',', ['one', 'two', '', 'three']), 'one,two,,three');
  CheckEqual(JoinCsv('//', ['one'], true), 'one');
  CheckEqual(JoinCsv('//', ['one', 'two'], true), 'two//one');
  CheckEqual(JoinCsv('//', ['1', '2', '3'], true), '3//2//1');
  CheckEqual(JoinCsv(',', ['one', 'two'], {reverse=}true), 'two,one');
  CheckEqual(JoinCsv(',', ['one', 'two', 'three '], true), 'three ,two,one');
  CheckEqual(JoinCsv(',', ['one', 'two', ''], true), ',two,one');
  CheckEqual(JoinCsv(',', ['one'], true), 'one');
  CheckEqual(JoinCsv(',', ['', ''], true), ',');
  Finalize(arr);
  CsvToRawUtf8DynArray(res, ',', '', arr);
  CheckEqual(length(arr), 3);
  Check(arr[0] = 'one');
  Check(arr[1] = 'two');
  Check(arr[2] = 'three');
  Finalize(arr);
  CsvToRawUtf8DynArray('one=?,two=?,three=?', '=?,', '=?', arr);
  CheckEqual(length(arr), 3);
  Check(arr[0] = 'one');
  Check(arr[1] = 'two');
  Check(arr[2] = 'three');
  Finalize(arr);
  res := '-1,25,0';
  CsvToRawUtf8DynArray(pointer(res), arr);
  CheckEqual(length(arr), 3);
  Check(arr[0] = '-1');
  Check(arr[1] = '25');
  Check(arr[2] = '0');
  Finalize(arr);
  CsvToRawUtf8DynArray('AA,BB,CC,DD', ',', ',', arr);
  CheckEqual(length(arr), 4);
  Check(arr[0] = 'AA');
  Check(arr[1] = 'BB');
  Check(arr[2] = 'CC');
  Check(arr[3] = 'DD');
  Finalize(arr);
  CsvToRawUtf8DynArray('A,B,C,D', ',', ',', arr);
  CheckEqual(length(arr), 4);
  Check(arr[0]='A');
  Check(arr[1]='B');
  Check(arr[2]='C');
  Check(arr[3]='D');
  Finalize(arr);
  CsvToRawUtf8DynArray('item1   item2    item3', arr, {sep=}' ',
    {TrimItems=}true , {AddVoidItems=}false);
  CheckEqual(length(arr), 3);
  CheckEqual(arr[0], 'item1');
  CheckEqual(arr[1], 'item2');
  CheckEqual(arr[2], 'item3');
  CheckEqual(AddPrefixToCsv('One,Two,Three', 'Pre'), 'PreOne,PreTwo,PreThree');
  CheckEqual(CsvOfValue('?', 3), '?,?,?');
  CheckEqual(GetUnQuoteCsvItem('"""one,""","two "', 1, ',', '"'), 'two ');
  CheckEqual(GetUnQuoteCsvItem('''''''one,''''''', 0), '''one,''');
  CheckEqual(GetUnQuoteCsvItem('"""one,', 0, ',', '"'), '');
  Check(not CsvContains('', 'b'));
  Check(not CsvContains('a', ''));
  Check(CsvContains('a', 'a'));
  Check(CsvContains('ab', 'ab'));
  Check(not CsvContains('a', 'b'));
  Check(not CsvContains('a', 'ab'));
  Check(not CsvContains('ab', 'a'));
  Check(CsvContains('a,b,c', 'a'));
  Check(CsvContains('a,b,c', 'b'));
  Check(CsvContains('a,b,c', 'c'));
  Check(not CsvContains('a,b,c', 'A'));
  Check(not CsvContains('a,b,c', ''));
  Check(CsvContains('aa,bb,cc', 'aa'));
  Check(CsvContains('aa,bb,cc', 'bb'));
  Check(CsvContains('aa,bb,cc', 'cc'));
  Check(not CsvContains('aa,bb,cc', 'cb'));
  Check(not CsvContains('aa,bb,cc', 'a'));
  Check(not CsvContains('', 'b', ',', false));
  Check(not CsvContains('a', '', ',', false));
  Check(CsvContains('a', 'a', ',', false));
  Check(CsvContains('ab', 'ab', ',', false));
  Check(CsvContains('a', 'A', ',', false));
  Check(CsvContains('ab', 'Ab', ',', false));
  Check(CsvContains('ab', 'AB', ',', false));
  Check(CsvContains('ab', 'aB', ',', false));
  Check(not CsvContains('a', 'b', ',', false));
  Check(not CsvContains('a', 'ab', ',', false));
  Check(not CsvContains('ab', 'a', ',', false));
  Check(CsvContains('a,b,c', 'a', ',', false));
  Check(CsvContains('a,b,c', 'b', ',', false));
  Check(CsvContains('a,b,c', 'c', ',', false));
  Check(CsvContains('a,b,c', 'A', ',', false));
  Check(CsvContains('a,b,c', 'B', ',', false));
  Check(CsvContains('a,b,c', 'C', ',', false));
  Check(not CsvContains('a,b,c', '', ',', false));
  Check(CsvContains('aa,bb,cc', 'aa', ',', false));
  Check(CsvContains('aa,bb,cc', 'bb', ',', false));
  Check(CsvContains('aa,bb,cc', 'cc', ',', false));
  Check(CsvContains('aa,bb,cc', 'AA', ',', false));
  Check(CsvContains('aa,bb,cc', 'Bb', ',', false));
  Check(CsvContains('aa,bb,cc', 'cC', ',', false));
  Check(not CsvContains('aa,bb,cc', 'cb', ',', false));
  Check(not CsvContains('aa,bb,cc', 'a', ',', false));
  Check(CsvContains('"3a8-64cf88076aae1", "a828414ff6"',
    '"3a8-64cf88076aae1"', 19, ',', {casesens=}true, {trim=}true));
  Check(CsvContains('"3a8-64cf88076aae1", "a828414ff6"',
    '"a828414ff6"', 12, ',', true, true));
  Check(CsvContains(' "3a8-64cf88076aae1" , "a828414ff6" ',
    '"3a8-64cf88076aae1"', 19, ',', true, true));
  Check(CsvContains(' "3a8-64cf88076aae1" , "a828414ff6" ',
    '"a828414ff6"', 12, ',', true, true));
  Check(CsvContains('"3a8-64cf88076aae1","a828414ff6" ',
    '"a828414ff6"', 12, ',', true, true));
  Check(CsvContains('"3a8-64cf88076aae1", "a828414ff6"',
    '"3a8-64cf88076aae1"', 34, 19, ',', {casesens=}true, {trim=}true));
  Check(CsvContains('"3a8-64cf88076aae1", "a828414ff6"',
    '"a828414ff6"', 34, 12, ',', true, true));
  U1 := ' "3a8-64cf88076aae1" , "a828414ff6" ds46';
  L := length(U1) - 4; // should stop at ds46 ending chars
  Check(CsvContains(pointer(U1), '"3a8-64cf88076aae1"645', L, 19, ',', true, true));
  Check(CsvContains(pointer(U1), '"a828414ff6"275', L, 12, ',', true, true));
  Check(CsvContains('"3a8-64cf88076aae1","a828414ff6"  321',
    '"a828414ff6"46', 34, 12, ',', true, true));
  CheckEqual(GetFirstCsvItem(''), '');
  CheckEqual(GetFirstCsvItem('a'), 'a');
  CheckEqual(GetFirstCsvItem('ab'), 'ab');
  CheckEqual(GetFirstCsvItem('ab,'), 'ab');
  CheckEqual(GetFirstCsvItem('ab,c'), 'ab');
  CheckEqual(GetFirstCsvItem('ab,c,de,fg'), 'ab');
  CheckEqual(GetFirstCsvItem(','), '');
  CheckEqual(GetFirstCsvItem(',a'), '');
  Check(FormatSql('abcd', [U], [{%H-}WS]) = 'abcd');
  Check(MakePath([]) = '');
  Check(MakePath([], true) = '');
  Check(MakePath([1], false, '/') = '1');
  Check(MakePath([1], true, '/') = '1/');
  Check(MakePath([1, 2, '3'], false, '/') = '1/2/3');
  Check(MakePath([1, '2/', 3], false, '/') = '1/2/3');
  Check(MakePath(['1/', 2, 3], false, '/') = '1/2/3');
  Check(MakePath([1, 2, '3/'], false, '/') = '1/2/3/');
  Check(MakePath([1, '', 2, '3/'], false, '/') = '1/2/3/');
  Check(MakePath([1, 2, 3], true, '/') = '1/2/3/');
  Check(MakePath([1, 2, '3'], true, '/') = '1/2/3/');
  Check(MakePath([1, '2/', 3], true, '/') = '1/2/3/');
  Check(MakePath(['1/', 2, 3], true, '/') = '1/2/3/');
  Check(MakePath([1, 2, '3/'], true, '/') = '1/2/3/');
  Check(MakePath([1, '', 2, '3/'], true, '/') = '1/2/3/');
  MakePath([1, 2, '3'], fn, false, '/');
  Check(fn = '1/2/3');
  MakePath(['1', 2, 3], fn, true, '/');
  Check(fn = '1/2/3/');
  Check(MakeFileName([]) = '');
  Check(MakeFileName(['toto', 'doc']) = 'toto.doc');
  {$ifdef OSWINDOWS}
  Check(MakeFileName([1, 2, 'doc'], false) = '1\2\doc');
  Check(MakeFileName([1, 2, 'doc'], true) = '1\2.doc');
  Check(MakeFileName([1, '', 2, '.doc'], true) = '1\2.doc');
  {$else}
  Check(MakeFileName([1, 2, 'doc'], false) = '1/2/doc');
  Check(MakeFileName([1, 2, 'doc'], true) = '1/2.doc');
  Check(MakeFileName([1, '', 2, '.doc'], true) = '1/2.doc');
  {$endif OSWINDOWS}
  CheckEqual(MakeCsv([]), '');
  CheckEqual(MakeCsv([], true), '');
  CheckEqual(MakeCsv([1]), '1');
  CheckEqual(MakeCsv([1], true, '+'), '1+');
  CheckEqual(MakeCsv([1, 2, 3]), '1,2,3');
  CheckEqual(MakeCsv([1, '2', 3], true), '1,2,3,');
  CheckEqual(MakeCsv([1, '2,', 3]), '1,2,3');
  CheckEqual(MakeCsv([1, '2,', 3], true), '1,2,3,');
  CheckEqual(MakeCsv([1, '2 ,', 3]), '1,2 ,3');
  CheckEqual(Make([]), '');
  CheckEqual(Make([1]), '1');
  CheckEqual(Make([1, 2, 3]), '123');
  CheckEqual(Make([1, '', 2, 3]), '123');
  CheckEqual(Make([1, '2', 3]), '123');
  CheckEqual(Make([1, '2 ,', 3]), '12 ,3');
  Check(MakeString([]) = '');
  Check(MakeString([1]) = '1');
  Check(MakeString([1, 2, 3]) = '123');
  Check(MakeString([1, '2', 3]) = '123');
  Check(MakeString([1, '2 ,', 3]) = '12 ,3');
  U := '';
  Append(U, []);
  CheckEqual(U, '');
  Append(U, [1]);
  CheckEqual(U, '1');
  Append(U, [2, '34', 5]);
  CheckEqual(U, '12345');
  Append(U, []);
  CheckEqual(U, '12345');
  Append(U, [6]);
  CheckEqual(U, '123456');
  U := '';
  Prepend(U, []);
  CheckEqual(U, '');
  Prepend(U, [1]);
  CheckEqual(U, '1');
  Prepend(U, [2, '34', 5]);
  CheckEqual(U, '23451');
  Prepend(U, []);
  CheckEqual(U, '23451');
  Prepend(U, [6]);
  CheckEqual(U, '623451');
  U := '';
  AppendLine(U, []);
  CheckEqual(U, '');
  AppendLine(U, ['a', 1]);
  CheckEqual(U, 'a1');
  AppendLine(U, [2, 3, 4, 5]);
  CheckEqual(U, 'a1'#13#10'2345');
  AppendLine(U, ['bcdef']);
  CheckEqual(U, 'a1'#13#10'2345'#13#10'bcdef');
  Append(U, #13#10);
  CheckEqual(U, 'a1'#13#10'2345'#13#10'bcdef'#13#10);
  AppendLine(U, ['ghij']);
  CheckEqual(U, 'a1'#13#10'2345'#13#10'bcdef'#13#10'ghij');
  U := QuotedStr('', '"');
  CheckEqual(U, '""');
  U := QuotedStr('abc', '"');
  CheckEqual(U, '"abc"');
  U := QuotedStr('a"c', '"');
  CheckEqual(U, '"a""c"');
  U := QuotedStr('abcd"efg', '"');
  CheckEqual(U, '"abcd""efg"');
  U := QuotedStr('abcd""efg', '"');
  CheckEqual(U, '"abcd""""efg"');
  U := QuotedStr('abcd"e"fg"', '"');
  CheckEqual(U, '"abcd""e""fg"""');
  U := QuotedStr('"abcd"efg', '"');
  CheckEqual(U, '"""abcd""efg"');
  U := QuotedStr('', '#'); // also test for custom quote
  CheckEqual(U, '##');
  U := QuotedStr('abc', '#');
  CheckEqual(U, '#abc#');
  U := QuotedStr('a#c', '#');
  CheckEqual(U, '#a##c#');
  U := QuotedStr('abcd#efg', '#');
  CheckEqual(U, '#abcd##efg#');
  U := QuotedStr('abcd##efg', '#');
  CheckEqual(U, '#abcd####efg#');
  U := QuotedStr('abcd#e#fg#', '#');
  CheckEqual(U, '#abcd##e##fg###');
  U := QuotedStr('#abcd#efg', '#');
  CheckEqual(U, '###abcd##efg#');
  Utf8ToSynUnicode('123456789abcdefghijkl', su);
  PW := pointer(su);
  len := length(su);
  for i := 1 to len do
    Check(SU[i] <> #0);
  repeat
    CheckEqual(StrLenW(PW), len);
    CheckEqual(WordScanIndex(pointer(PW), len + 10, 0), len);
    PW^ := #0; // force some #0 within the SSE2 16 bytes alignment
    inc(PW);
    dec(len);
  until len < 0;
  for i := 1 to length(su) do
    Check(SU[i] = #0);
  fn := 'test.htdigest';
  Check(PosExtString(pointer(fn))^ = 'h');
  fn := PathDelim + 'test.htdigest';
  Check(PosExtString(pointer(fn))^ = 'h');
  fn := '.htdigest';
  Check(PosExtString(pointer(fn)) = nil);
  fn := PathDelim + '.htdigest';
  Check(PosExtString(pointer(fn)) = nil);
  fn := 'htdigest';
  Check(PosExtString(pointer(fn)) = nil);
  fn := PathDelim + 'htdigest';
  Check(PosExtString(pointer(fn)) = nil);
  for i := 0 to 1000 do
  begin
    len := i * 5;
    // test encodings on ASCII 7-bit content
    W := RandomAnsi7(len, CP_WINANSI);
    CheckEqual(length(W), len);
    lenup100 := len;
    if lenup100 > 100 then
      lenup100 := 100;
    str := Ansi7ToString(W); // should be fine on any code page
    if len > 0 then
    begin
      CheckEqual(length(str), len);
      CheckEqual(PosExString(str[1], str), 1);
      if str[1] <> str[2] then
      begin
        CheckEqual(PosExString(str[2], str), 2);
        if (str[1] <> str[2]) and
           (str[2] <> str[3]) and
           (str[1] <> str[3]) then
          CheckEqual(PosExString(str[3], str), 3);
      end;
      fn := str;
      Check(pointer(fn) = pointer(str));
      check(EqualFileNameNotNull(fn, str));
      check(SortDynArrayFileName(fn, str) = 0);
      UniqueString(string(fn));
      Check(pointer(fn) <> pointer(str));
      check(EqualFileNameNotNull(fn, str));
      check(SortDynArrayFileName(fn, str) = 0);
      for j := 1 to lenup100 do
      begin
        CheckEqual(PosExString(#13, str, j), 0);
        CheckEqual(PosExString(str[j], str, j), j);
        if (j > 1) and
           (str[j - 1] <> str[j]) then
          CheckEqual(PosExString(str[j], str, j - 1), j);
        k := PosExString(str[j], str);
        check((k > 0) and
             (str[k] = str[j]));
        inc(fn[j]);
        check(not EqualFileNameNotNull(fn, str));
        check(SortDynArrayFileName(fn, str) <> 0);
        {$ifdef UNICODE}
        Check(StrCompW(pointer(fn), pointer(str)) <> 0);
        {$else}
        Check(StrComp(pointer(fn), pointer(str)) <> 0);
        {$endif UNICODE}
        dec(fn[j]);
      end;
    end
    else
      check(PosExString(#0, str) = 0);
    for CP := 1250 to 1258 do
      Test(CP, W);
    Test(932, W);
    Test(949, W);
    Test(874, W);
    Test(CP_UTF8, W); // note: CP_UTF16 is not a true ANSI charset for Test()
    // test WinAnsi/CP1252 encoding with proper accents support
    W := RandomWinAnsi(len);
    if CheckEqual(length(W), len, 'len') then
      for j := 1 to len do
        Check(W[j] >= ' ', '#32');
    U := WinAnsiToUtf8(W);  // ConsoleWrite(U);
    Check(length(U) >= len);
    check(IsValidUtf8(U), 'IsValidUtf8');
    P := UniqueRawUtf8(U);
    check(IsValidUtf8Ptr(P), 'IsValidUtf8Ptr');
    check(PosChar(P, #10) = nil);
    if len > 0 then
    begin
      CheckEqual(PosEx(U[1], U), 1);
      CheckEqual(PosExChar(U[1], U), 1);
      check(PosChar(P, P[0]) = @P[0], 'PosChar0');
      if (len > 1) and
         (U[1] <> U[2]) then
      begin
        CheckEqual(PosEx(U[2], U), 2);
        CheckEqual(PosExChar(U[2], U), 2);
        check(PosChar(P, P[1]) = @P[1], 'PosChar1');
        if (len > 2) and
           (U[1] <> U[2]) and
           (U[2] <> U[3]) and
           (U[1] <> U[3]) then
        begin
          CheckEqual(PosEx(U[3], U), 3);
          CheckEqual(PosExChar(U[3], U), 3);
          check(PosChar(P, P[2]) = @P[2], 'PosChar2');
        end;
      end;
    end;
    if length(U) > 120 then
      len120 := Utf8TruncatedLength(U, 120)
    else
      len120 := 0;
    Check(IsValidUtf8Buffer(P, len120), 'IsValidUtf8Buffer truncated');
    if HasValidUtf8Avx2 then
    begin
      check(IsValidUtf8Small(U), 'IsValidUtf8Pas');
      Check(IsValidUtf8Pas(P, len120), 'IsValidUtf8Pas120');
    end;
    for j := 1 to lenup100 do
    begin
      check(PosChar(P, U[j])^ = U[j], 'PosCharj');
      // validates with offset parameter
      CheckEqual(PosEx(#13, U, j), 0);
      CheckEqual(PosEx(U[j], U, j), j);
      if (j > 1) and
         (U[j - 1] <> U[j]) then
        CheckEqual(PosEx(U[j], U, j - 1), j);
      k := PosEx(U[j], U);
      check((k > 0) and
            (U[k] = U[j]));
      CheckEqual(PosExChar(U[j], U), k);
      if len120 <> 0 then
      begin
        bak := P[len120];
        P[len120] := #0; // no need to go any further
        bakj := P[j - 1];
        P[j - 1] := AnsiChar(ord(P[j - 1]) xor 128); // invalidate the UTF-8 content
        check(not IsValidUtf8Buffer(P, len120), 'IsValidUtf8 up100');
        if HasValidUtf8Avx2 then
          check(not IsValidUtf8Pas(P, len120), 'IsValidUtf8Pas up100');
        P[j - 1] := bakj;
        check(IsValidUtf8Buffer(P, len120), 'IsValidUtf8 restored');
        if HasValidUtf8Avx2 then
          check(IsValidUtf8Pas(P, len120), 'IsValidUtf8Pas restored');
        P[j - 1] := #0;
        check(not IsValidUtf8NotVoid(P, len120), 'IsValidUtf8 0');
        if HasValidUtf8Avx2 then
          check(not IsValidUtf8Pas(P, len120), 'IsValidUtf8Pas 0');
        P[j - 1] := bakj;
        check(IsValidUtf8Buffer(P, len120), 'IsValidUtf8 final');
        P[len120] := bak;
      end;
    end;
    json := FormatJson('{"a":?,"b":%}', [i], [U]);
    Check(IsValidJson(json, {strict=}true));
    json1 := JsonReformat(json, jsonEscapeUnicode);
    Check(IsValidJson(json1, true));
    Check(IsAnsiCompatible(U) or (PosEx('\u', json1) > 0));
    json2 := JsonReformat(json1, jsonNoEscapeUnicode);
    CheckEqual(json2, json, 'jeu2');
    Unic := Utf8DecodeToUnicodeRawByteString(U);
    CheckEqual(Utf8ToWinAnsi(U), W, 'ua');
    WinAnsiConvert.AnsiToUtf8(W, U1);
    CheckEqual(WinAnsiConvert.Utf8ToAnsi(U), W, 'uw');
    SU := WinAnsiConvert.AnsiToUnicodeString(W);
    CheckEqual(StrLenWSafe(pointer(SU)), length(SU));
    CheckEqual(StrLenW(pointer(SU)), length(SU));
    if SU <> '' then
      Check(WordScanIndex(pointer(SU), length(SU) + 10, 0) = length(SU));
    W2 := WinAnsiConvert.UnicodeStringToAnsi(SU);
    //ConsoleWrite(['SU len=', length(SU), ' =', SU]); ConsoleWrite(['W2 len=', length(W2), ' =', W2]); readln;
    CheckEqual(W2, W, 'A2U(U2A)');
    if CurrentAnsiConvert.InheritsFrom(TSynAnsiFixedWidth) then
    begin
      CurrentAnsiConvert.AnsiToUtf8(W, U1);
      W2 := CurrentAnsiConvert.Utf8ToAnsi(U1);
      CheckEqual(W2, W, 'u2a(a2u)');
      SU := CurrentAnsiConvert.AnsiToUnicodeString(W);
      CheckEqual(CurrentAnsiConvert.UnicodeStringToAnsi(SU), W, 'U2A(A2U)');
    end;
    res := RawUnicodeToUtf8(pointer(Unic), length(Unic) shr 1);
    CheckEqual(res, U);
    WinAnsiConvert.UnicodeBufferToAnsiVar(pointer(Unic), length(Unic) shr 1, rb1);
    CheckEqual(rb1, W);
    WS := Utf8ToWideString(U);
    CheckEqual(length(WS), length(Unic) shr 1);
    if WS <> '' then
      Check(CompareMem(pointer(WS), pointer(Unic), length(WS) * SizeOf(WideChar)));
    CheckEqual(integer(Utf8ToUnicodeLength(Pointer(U))), length(WS));
    SU := Utf8ToSynUnicode(U);
    CheckEqual(length(SU), length(Unic) shr 1);
    CheckEqual(StrLenW(pointer(SU)), length(SU));
    if SU <> '' then
      Check(CompareMem(pointer(SU), pointer(Unic), length(Unic)), 'Utf8ToSU');
    WA := IsWinAnsi(pointer(Unic));
    Check(IsWinAnsi(pointer(Unic), length(Unic) shr 1) = WA);
    Check(IsWinAnsiU(pointer(U)) = WA);
    Up := mormot.core.unicode.UpperCase(U);
    Check(IsUpper(Up));
    CheckEqual(mormot.core.unicode.UpperCase(mormot.core.unicode.LowerCase(U)), Up);
    CheckEqual(Utf8IComp(pointer(U), pointer(U)), 0);
    CheckEqual(Utf8IComp(pointer(U), pointer(Up)), 0);
    CheckEqual(Utf8ILComp(pointer(U), pointer(U), length(U), length(U)), 0);
    CheckEqual(Utf8ILComp(pointer(U), pointer(Up), length(U), length(Up)), 0);
    CheckEqual(Utf8ICompReference(pointer(U), pointer(U)), 0);
    CheckEqual(Utf8ILCompReference(pointer(U), pointer(U), length(U), length(U)), 0);
    CheckEqual(Utf8CompareOS(pointer(U), pointer(U)), 0);
    CheckEqual(CompareInteger(Utf8CompareOS(pointer(U), pointer(Up)), 0),
              -CompareInteger(Utf8CompareOS(pointer(Up), pointer(U)), 0));
    CheckEqual(CompareInteger(Utf8CompareIOS(pointer(U), pointer(Up)), 0),
              -CompareInteger(Utf8CompareIOS(pointer(Up), pointer(U)), 0));
    CheckEqual(Utf8CompareIOS(pointer(U), pointer(U)), 0);
    if Unicode_CodePage = CP_WINANSI then
      CheckEqual(Utf8CompareIOS(pointer(U), pointer(Up)), 0);
    //for j := 1 to 5000 do
    try
      //W := RandomWinAnsi(len);
      //U := WinAnsiToUtf8(W);
      //check(IsValidUtf8(U), 'IsValidUtf8U');
      //Up := mormot.core.unicode.UpperCase(U);
      up4 := Utf8ToRawUcs4(U);
      CheckEqual(RawUcs4ToUtf8(up4), U);
      Up2 := UpperCaseReference(U);
      up4 := UpperCaseUcs4Reference(U);
      CheckEqual(RawUcs4ToUtf8(up4), Up2);
      CheckEqual(Ucs4Compare(Utf8ToRawUcs4(Up2), up4), 0);
      CheckEqual(StrPosIReference(pointer(U), up4), pointer(U));
      if U <> '' then
      begin
        Up2 := 'abcDE G' + U;
        CheckEqual(StrPosIReference(pointer(Up2), Up4) - pointer(Up2),  7);
        SetLength(Up2, length(Up2) - 1);
        Check(StrPosIReference(pointer(Up2), Up4) = nil);
        Up2 := 'abcDEF' + U + 'PZE';
        CheckEqual(StrPosIReference(pointer(Up2), Up4) - pointer(Up2),  6);
      end;
      if WA then
      begin
        CheckEqual(Utf8ICompReference(pointer(U), pointer(Up)), 0, 'Utf8ICompReference');
        CheckEqual(Utf8ILCompReference(pointer(U), pointer(Up), length(U), length(Up)),
          0, 'Utf8ILCompReference');
      end;
    except
      on E: Exception do
        CheckUtf8(false, '% for %[%]%',
          [E, length(U), EscapeToShort(U), length(up4)]);
    end;
    U2 := LowerCase(U);
    Check(IsLower(U2));
    CheckEqual(U2, LowerCaseAscii7(U));
    L := Length(U);
    SetString(Up, nil, L);
    SetString(Up2, PAnsiChar(pointer(U)), L);
    L := Utf8UpperCopy(pointer(Up), pointer(U), L) - pointer(Up);
    Check(L <= length(U));
    CheckEqual(ConvertCaseUtf8(pointer(U), pointer(Up2), NormToUpperByte), L);
    if Up <> '' then
      Check(CompareMem(pointer(Up), pointer(Up2), L));
    if CurrentAnsiConvert.CodePage = CODEPAGE_US then
       // initial text above is WinAnsiString (CP 1252)
      CheckEqual(StringToUtf8(Utf8ToString(U)), U, '1252');
    Up := UpperCaseUnicode(U);
    CheckEqual(Up, UpperCaseUnicode(LowerCaseUnicode(U)), 'upper/lower');
    {$ifdef OSPOSIX}
    if not Icu.IsAvailable then
      // fallback when only a..z chars are translated
      CheckEqual(UpperCaseReference(LowerCaseUnicode(U)), UpperCaseReference(U), 'UCR')
    else
    {$endif OSPOSIX}
    begin
      U2 := UpperCaseReference(U);
      CheckEqual(length(Up), length(U2));
      CheckEqual(Up, U2, 'UpperCaseReference');
    end;
    CheckEqual(kr32(0, pointer(U), length(U)), kr32reference(pointer(U), length(U)), 'kr32');
    U2 := U + #10;
    check(PosChar(pointer(U2), #0) = nil);
    check(PosChar(pointer(U2), #1) = nil);
    check(PosChar(pointer(U2), #10) = @U2[length(U2)]);
    check(PosCharU(U2, #0) = nil);
    check(PosCharU(U2, #1) = nil);
    check(PosCharU(U2, #10) = @U2[length(U2)]);
    if U = '' then
      continue;
    U2 := QuotedStr(U, '"');
    Check(UnQuoteSqlStringVar(pointer(U2), res) <> nil);
    Check(res = U);
    Check(not IsZero(pointer(W), length(W)));
    FillCharFast(pointer(W)^, length(W), 0);
    Check(IsZero(pointer(W), length(W)));
    CheckEqual(FormatUtf8(U, []), U);
    res := FormatSql(U, [], []); // Delphi 5 bug with high([])>0 :(
    CheckEqual(length(res), Length(U));
    CheckEqual(res, U);
    CheckEqual(FormatUtf8('%', [U]), U);
    CheckEqual(FormatSql('%', [U], []), U);
    q := ':(' + QuotedStr(U) + '):';
    CheckEqual(FormatSql('?', [], [U]), q);
    res := 'ab' + U;
    q := 'ab' + q;
    CheckEqual(FormatUtf8('ab%', [U]), res);
    CheckEqual(FormatUtf8('%%', ['ab', U]), res);
    CheckEqual(FormatSql('ab%', [U], []), res);
    CheckEqual(FormatSql('%%', ['ab', U], []), res);
    CheckEqual(FormatSql('ab?', [], [U]), q);
    CheckEqual(FormatSql('%?', ['ab'], [U]), q);
    res := res + 'cd';
    q := q + 'cd';
    CheckEqual(FormatUtf8('ab%cd', [U]), res);
    CheckEqual(FormatSql('ab%cd', [U], []), res);
    CheckEqual(FormatUtf8('a%%cd', ['b', U]), res);
    CheckEqual(FormatSql('a%%cd', ['b', U], []), res);
    CheckEqual(FormatUtf8('%%%', ['ab', U, 'cd']), res);
    CheckEqual(FormatSql('ab?cd', [], [U]), q);
    CheckEqual(FormatSql('%?cd', ['ab'], [U]), q);
    CheckEqual(FormatSql('%?%', ['ab', 'cd'], [U]), q);
    CheckEqual(FormatSql('%?c%', ['ab', 'd'], [U]), q);
    CheckEqual(FormatSql('a%?%d', ['b', 'c'], [U]), q);
  end;
  SetLength(U, 4);
  U[1] := #$F0;
  U[2] := #$A8;
  U[3] := #$B3;
  U[4] := #$92;
  Utf8ToSynUnicode(U, SU);
  if Check(length(SU) = 2) then
    Check(PCardinal(SU)^ = $DCD2D863);
  CheckEqual(StrLenW(pointer(SU)), length(SU));
  Check(Utf8ToUnicodeLength(Pointer(U)) = 2);
  Check(Utf8FirstLineToUtf16Length(Pointer(U)) = 2);
  PCardinal(@WU)^ := 0;
  if CheckEqual(Utf8ToWideChar(WU, pointer(U), length(WU), length(U), false), 4) then
    Check(PCardinal(@WU)^ = $DCD2D863);
  // ensure MaxDestChars is a WideChar count - not a byte count
  U := 'abcdefgh';
  FillCharFast(WU2, SizeOf(WU2), 0);
  CheckEqual(Utf8ToWideChar(@WU2, pointer(U), length(WU2), length(U), false), 16);
  CheckEqual(StrLenW(@WU2), 8);
  FillCharFast(WU2, SizeOf(WU2), 0);
  CheckEqual(Utf8ToWideChar(@WU2, pointer(U), 5, length(U), false), 10);
  CheckEqual(StrLenW(@WU2), 5);
  SU2 := 'abcde';
  Check(CompareMem(@WU2, pointer(SU2), 10), 'truncate at MaxDestChars');
  U := SynUnicodeToUtf8(SU);
  if Check(length(U) = 4) then
    Check(PCardinal(U)^ = $92b3a8f0);
  CheckEqual(StrLenW(pointer(SU)), length(SU));
  TSynAnsiConvert.Engine(CP_UTF8).UnicodeBufferToAnsiVar(
    pointer(SU), length(SU), RawByteString(U));
  Check(length(U) = 4);
  if Check(length(U) = 4) then
    Check(PCardinal(U)^ = $92b3a8f0);
  SetLength(res, 10);
  PB := pointer(res);
  PB := ToVarString(U, PB);
  check(PAnsiChar(PB) - pointer(res) = length(U) + 1);
  PB := pointer(res);
  U2 := FromVarString(PB);
  check(U2 = U);
  PB := pointer(res);
  FromVarString(PB, U2);
  check(U2 = U);
  U := HexTobin('2800541D251D541D2900'); // a nice Unicode mORMot glyph
  {$ifdef HASCODEPAGE}
  CheckEqual(GetCodePage(U), CP_RAWBYTESTRING);
  {$endif HASCODEPAGE}
  FastSynUnicode(SU, pointer(U), length(U) shr 1);
  U := HexToUtf8('28E1B594E1B4A5E1B59429');
  {$ifdef HASCODEPAGE}
  CheckEqual(GetCodePage(U), CP_UTF8);
  {$endif HASCODEPAGE}
  CheckEqual(SynUnicodeToUtf8(SU), U);
  Check(Utf8ToSynUnicode(U) = SU);
  for i := 0 to high(UTF8_UCS4) do
  begin
    RawUcs4ToUtf8(@UTF8_UCS4[i], 1, U);
    Check(U <> '');
    Ucs4 := Utf8ToRawUcs4(U);
    CheckEqual(length(Ucs4), 1);
    CheckEqual(Ucs4[0], UTF8_UCS4[i]);
  end;
  FastSetString(U, @CHINESE_TEXT, 9);
  CheckEqual(StrLen(pointer(U)), 9);
  SU := Utf8ToSynUnicode(U);
  CheckEqual(StrLenW(pointer(SU)), length(SU));
  eng := TSynAnsiConvert.Engine(936);
  Check(eng <> nil, 'Engine(936)');
  rb1 := eng.UnicodeStringToAnsi(SU); // GB2312
  CheckEqual(length(rb1), 7, 'cp936a');
  SU2 := eng.AnsiToUnicodeString(rb1);
  Check(SU = SU2);
  rb1 := '';
  rb1 := eng.Utf8ToAnsi(U);
  CheckEqual(length(rb1), 7);
  eng.AnsiToUtf8(rb1, U2);
  CheckEqual(U, U2);
  eng := TSynAnsiConvert.Engine(54936);
  Check(eng <> nil, 'Engine(54936)');
  rb1 := eng.UnicodeStringToAnsi(SU); // GB18030
  if rb1 <> '' then // some Windows versions won't support this code page
  begin
    CheckEqual(length(rb1), 7, 'cp54936a');
    SU2 := eng.AnsiToUnicodeString(rb1);
    Check(SU = SU2, 'cp54936b');
    rb1 := '';
    rb1 := eng.Utf8ToAnsi(U);
    CheckEqual(length(rb1), 7, 'cp54936c');
    eng.AnsiToUtf8(rb1, U2);
    CheckEqual(U, U2, 'cp54936d');
    {$ifdef HASCODEPAGE}
    rb2 := U;
    CheckEqual(length(rb2), 9);
    SetCodePage(rb2, 54936, {convert=}true);
    CheckEqual(length(u), 9);
    CheckEqual(length(rb1), 7);
    CheckEqual(length(rb2), 7);
    Check(rb1 = rb2, 'setcodepage');
    Check(SortDynArrayRawByteString(rb1, rb2) = 0);
    {$endif HASCODEPAGE}
    SetLength(U, 4);
    PCardinal(U)^ := $A59AAAF0; // valid in GB18030 only
    SU := Utf8ToSynUnicode(U);  // 69 D8 A5 DE , UTF16, Code Point: \uD869\uDEA5
    CheckEqual(PCardinal(SU)^, $DEA5D869);
    CheckEqual(StrLenW(pointer(SU)), length(SU));
    RB1 := eng.Utf8ToAnsi(U);
    if RB1 = '' then // not supported on this sytem
    begin
      Check((RB1 <> '') and (PCardinal(RB1)^ = $37EE3598), 'Utf8ToAnsi');
      RB2 := eng.UnicodeStringToAnsi(SU);
      Check(SortDynArrayRawByteString(rb1, rb2) = 0, 'UnicodeStringToAnsi');
      eng.AnsiToUtf8(RB1, U2);
      CheckEqual(U2, U, 'AnsiToUtf8');
    end;
  end;
  CheckEqual(CodePageToText(CP_UTF8), 'utf8');
  CheckEqual(CodePageToText(CP_UTF16), 'utf16le');
  CheckEqual(CodePageToText(CP_WINANSI), 'windows-1252');
  CheckEqual(CodePageToText(54936), 'gb18030');
  Check(LcidToLanguage(0) = lngUndefined);
  CheckEqual(LANG_LCID[lngUndefined], LANG_ENGLISH_US);
  CheckEqual(LANG_ISO[lngUndefined], '');
  CheckEqual(LANG_TXT[lngUndefined], 'Undefined');
  Check(LcidToLanguage(LANG_ENGLISH_US) = lngEnglish);
  CheckEqual(LANG_LCID[lngEnglish], LANG_ENGLISH_US);
  CheckEqual(LANG_TXT[lngEnglish], 'English');
  Check(LcidToLanguage(LANG_CHINESE_SIMPLIFIED) = lngChinese);
  CheckEqual(LANG_LCID[lngChinese], LANG_CHINESE_SIMPLIFIED);
  CheckEqual(LANG_TXT[lngChinese], 'Chinese');
  Check(LcidToLanguage(LANG_BOSNIAN_CYRILLIC) = lngBosnian);
  CheckEqual(LANG_LCID[lngBosnian], LANG_BOSNIAN_CYRILLIC);
  Check(LcidToLanguage(LANG_SERBIAN_NEUTRAL) = lngSerbian);
  CheckEqual(LANG_LCID[lngSerbian], LANG_SERBIAN_NEUTRAL);
  Check(LcidToLanguage(LANG_CROATIAN_NEUTRAL) = lngCroatian);
  CheckEqual(LANG_LCID[lngCroatian], LANG_CROATIAN_NEUTRAL);
  Check(IsoTextToLanguage('') = lngUndefined);
  Check(IsoTextToLanguage('f') = lngUndefined);
  Check(IsoTextToLanguage('fr') = lngFrench);
  Check(IsoTextToLanguage('fre') = lngUndefined);
  Check(IsoTextToLanguage(' fr') = lngUndefined);
  for lng := succ(low(lng)) to high(lng) do
  begin
    lcid := LANG_LCID[lng];
    Check(lcid <> 0);
    CheckEqual(ord(LcidToLanguage(lcid)), ord(lng), 'lcid');
    CheckEqual(ord(LcidToLanguage(lcid)), ord(lng), 'lcidcache');
    if not (lng in lngBCS) then
      CheckEqual(ord(LcidToLanguage(LANG_PRI[lng])), ord(lng), 'LANG_PRI');
    U := LcidToText(lcid);
    CheckUtf8(length(U) >= 3, U);
    CheckEqual(U, LANG_TXT[lng]);
    if lng <> high(lng) then
      CheckUtf8(SortDynArrayAnsiString(U, LANG_TXT[succ(lng)]) < 0, U);
    U := LANG_ISO[lng];
    Check(U <> '');
    Check(IdemPropNameU(U, @LANG_ISO_SHORT[lng], 2));
    CheckEqual(ord(IsoTextToLanguage(U)), ord(lng), 'iso');
    CheckEqual(ord(IsoTextToLanguage(U)), ord(lng), 'isocache');
    UpperCaseSelf(U);
    Check(IdemPropNameU(U, @LANG_ISO_SHORT[lng], 2));
    CheckEqual(ord(IsoTextToLanguage(U)), ord(lng), 'isocache2');
  end;
  Check(UnQuoteSqlStringVar('"one two"', U) <> nil);
  Check(U = 'one two');
  Check(UnQuoteSqlStringVar('one two', U) <> nil);
  Check(U = 'ne tw');
  Check(UnQuoteSqlStringVar('"one "" two"', U) <> nil);
  Check(U = 'one " two');
  Check(UnQuoteSqlStringVar('"one " two"', U) <> nil);
  Check(U = 'one ');
  Check(UnQuoteSqlStringVar('"one two', U) = nil);
  Check(UnQuoteSqlStringVar('"one "" two', U) = nil);
  Check(not IsValidEmail(''));
  Check(IsValidEmail('test@synopse.info'));
  Check(not IsValidEmail('test @synopse.info'));
  Check(not IsValidEmail('test@ synopse.info'));
  Check(not IsValidEmail('test@synopse'));
  Check(IsValidEmail('test_two@blog.synopse.info'));
  Check(IsValidEmail('test++two@blog.synopse.info'));
  Check(IsValidEmail('"test"@synopse.info'));
  Check(not IsValidEmail('"test"ed@synopse.info'));
  Check(not IsValidEmail('"test@synopse.info'));
  Check(IsValidEmail('John.Doe@synopse.info'));
  Check(not IsValidEmail('John..Doe@synopse.info'));
  Check(IsValidEmail('"John Doe"@synopse.info'));
  Check(IsValidEmail('"John  Doe"@synopse.info'));
  Check(IsValidEmail('"John.Doe"@synopse.info'));
  Check(IsValidEmail('"John..Doe"@synopse.info'));
  Check(IsValidIP4Address('192.168.1.1'));
  Check(IsValidIP4Address('192.168.001.001'));
  Check(not IsValidIP4Address('192.158.1. 1'));
  Check(not IsValidIP4Address('192.158.1.301'));
  Check(not IsValidIP4Address(' 12.158.1.01'));
  Check(not IsValidIP4Address('12.158.1.'));
  Check(not IsValidIP4Address('12.158.1'));
  {$ifdef OSWINDOWS}
  Check(FindUnicode('  ABCD DEFG', 'ABCD', 4));
  Check(FindUnicode('  ABCD DEFG', 'DEFG', 4));
  Check(FindUnicode('ABCD DEFG ', 'DEFG', 4));
  Check(FindUnicode('ABCD DEFG ', 'ABCD', 4));
  Check(FindUnicode('  abcd defg', 'ABCD', 4));
  Check(FindUnicode('  abcd defg', 'DEFG', 4));
  Check(FindUnicode('abcd defg ', 'DEFG', 4));
  Check(FindUnicode('abcd defg ', 'ABCD', 4));
  Check(FindUnicode('ABCD DEFG ', 'ABCD', 4));
  Check(FindUnicode('  abcde defg', 'ABCD', 4));
  Check(FindUnicode('  abcdf defg', 'DEFG', 4));
  Check(FindUnicode('abcdg defg ', 'DEFG', 4));
  Check(FindUnicode('abcdh defg ', 'ABCD', 4));
  Check(FindUnicode('  abcd defg', 'ABC', 3));
  Check(FindUnicode('  abcd defg', 'DEF', 3));
  Check(FindUnicode('abcd defg ', 'DEF', 3));
  Check(FindUnicode('abcd defg ', 'ABC', 3));
  Check(not FindUnicode('  abcd defg', 'ABC2', 4));
  Check(not FindUnicode('  abcd defg', 'DEF2', 4));
  Check(not FindUnicode('abcd defg ', 'DEF1', 4));
  Check(not FindUnicode('abcd defg ', 'ABC1', 4));
  Check(UpperCaseUnicode('abcdefABCD') = 'ABCDEFABCD');
  Check(LowerCaseUnicode('abcdefABCD') = 'abcdefabcd');
  {$endif OSWINDOWS}
  CheckEqual(StringReplaceAll('abcabcabc', 'toto', 'toto'), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'toto', 'titi'), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'ab', 'AB'), 'ABcABcABc');
  CheckEqual(StringReplaceAll('abcabcabc', 'AB', 'toto'), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'Bc', 'titi'), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'bc', ''), 'aaa');
  CheckEqual(StringReplaceAll('abcabcabc', 'bc', 'B'), 'aBaBaB');
  CheckEqual(StringReplaceAll('abcabcabc', 'bc', 'bcd'), 'abcdabcdabcd');
  CheckEqual(StringReplaceAll('abcabcabc', 'c', 'C'), 'abCabCabC');
  CheckEqual(StringReplaceAll('abcabcabc', []), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', ['c']), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', ['c', 'C']), 'abCabCabC');
  CheckEqual(StringReplaceAll('abcabcabc', ['c', 'C', 'a']), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc',
    ['c', 'C', 'toto', 'titi', 'ab', 'AB']), 'ABCABCABC');
  CheckEqual(StringReplaceAll('abcabcabc', 'toto', 'toto', false), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'toto', 'titi', false), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'ab', 'AB', false), 'ABcABcABc');
  CheckEqual(StringReplaceAll('abcabcabc', 'AB', 'toto', false), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'Bc', 'titi', false), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'bc', '', false), 'aaa');
  CheckEqual(StringReplaceAll('abcabcabc', 'bc', 'B', false), 'aBaBaB');
  CheckEqual(StringReplaceAll('abcabcabc', 'bc', 'bcd', false), 'abcdabcdabcd');
  CheckEqual(StringReplaceAll('abcabcabc', 'c', 'C', false), 'abCabCabC');
  CheckEqual(StringReplaceAll('abcabcabc', 'c', '', false), 'ababab');
  CheckEqual(StringReplaceAll('abcabcabc', 'C', '', false), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'toto', 'toto', true), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'toto', 'titi', true), 'abcabcabc');
  CheckEqual(StringReplaceAll('abcabcabc', 'ab', 'AB', true), 'ABcABcABc');
  CheckEqual(StringReplaceAll('abcabcabc', 'AB', 'toto', true), 'totoctotoctotoc');
  CheckEqual(StringReplaceAll('abcabcabc', 'Bc', 't', true), 'atatat');
  CheckEqual(StringReplaceAll('abcabcabc', 'bC', '', true), 'aaa');
  CheckEqual(StringReplaceAll('abcabcabc', 'bc', 'B', true), 'aBaBaB');
  CheckEqual(StringReplaceAll('abcabcabc', 'bc', 'bcd', true), 'abcdabcdabcd');
  CheckEqual(StringReplaceAll('abcabcabc', 'c', 'C', true), 'abCabCabC');
  CheckEqual(StringReplaceAll('abcabcabc', 'c', '', true), 'ababab');
  CheckEqual(StringReplaceAll('abcabcabc', 'C', '', true), 'ababab');
  CheckCleanThreadName('', '');
  CheckCleanThreadName('toto', 'toto');
  CheckCleanThreadName('TWebSockettotoTSqlRestServerTOrmRestmemory', 'WStotoSrvmem');
  CheckEqual(LogEscapeFull(''), '');
  CheckEqual(LogEscapeFull(' abc'), ' abc');
  CheckEqual(LogEscapeFull('abc'), 'abc');
  u := 'abc'#10;
  Check(ContentToShort(u) = 'abc'#10);
  CheckEqual(LogEscapeFull(u), 'abc$0a');
  u2 := RawUtf8OfChar('-', 10);
  CheckEqual(u2, '----------');
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 15)^ = #0);
  CheckEqual(u2, 'abc$0a'#0'---');
  u2 := RawUtf8OfChar('-', 10);
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 12)^ = #0);
  CheckEqual(u2, 'abc$0a'#0'---');
  u2 := RawUtf8OfChar('-', 10);
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 7)^ = #0);
  CheckEqual(u2, 'abc$0a'#0'---');
  u2 := RawUtf8OfChar('-', 10);
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 6)^ = #0);
  CheckEqual(u2, 'abc..'#0'----');
  u2 := RawUtf8OfChar('-', 10);
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 5)^ = #0);
  CheckEqual(u2, 'ab..'#0'-----');
  u := 'abcd'#10;
  u[4] := #129; // not valid UTF-8
  Check(ContentToShort(u) = 'abc$81$0a');
  u := '012345678';
  u2 := RawUtf8OfChar('-', 10);
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 10)^ = #0);
  CheckEqual(u2, '012345678'#$00);
  u2 := RawUtf8OfChar('-', 10);
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 9)^ = #0);
  CheckEqual(u2, '012345..'#0'-');
  u2 := RawUtf8OfChar('-', 10);
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 5)^ = #0);
  CheckEqual(u2, '01..'#0'-----');
  u2 := RawUtf8OfChar('-', 10);
  Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 4)^ = #0);
  CheckEqual(u2, '0..'#0'------');
  for i := 3 downto 0 do
  begin
    u2 := RawUtf8OfChar('-', 10);
    Check(EscapeBuffer(pointer(u), length(u), pointer(u2), 3)^ = #0);
    CheckEqual(u2, #0'---------');
  end;
  for i := -10 to 50 do
    for j := -10 to 50 do
    begin
      CheckTrimCopy('', i, j);
      CheckTrimCopy('1', i, j);
      CheckTrimCopy('1 ', i, j);
      CheckTrimCopy(' 1', i, j);
      CheckTrimCopy('   1', i, j);
      CheckTrimCopy('1   ', i, j);
      CheckTrimCopy('1', i, j);
      CheckTrimCopy('12', i, j);
      CheckTrimCopy('123', i, j);
      CheckTrimCopy(' 234', i, j);
      CheckTrimCopy(' 234 ', i, j);
      CheckTrimCopy(' 2 4', i, j);
      CheckTrimCopy(' 2 4 ', i, j);
      CheckTrimCopy('  3    ', i, j);
      CheckTrimCopy('  3   7  ', i, j);
      CheckTrimCopy(' 234 6', i, j);
      CheckTrimCopy('234 67 ', i, j);
      CheckTrimCopy(' 234 67 ', i, j);
      CheckTrimCopy(' 234 67 ', i, maxInt);
    end;
  u := RawUtf8OfChar('-', 300);
  for i := 250 to 260 do
  begin
    ss[0] := #0;
    ContentToShortAppend(pointer(u), i, ss);
    if i < 255 then
    begin
      CheckEqual(ord(ss[0]), i);
      for j := 1 to i do
        Check(ss[j] = '-')
    end
    else if i = 255 then
    begin
      CheckEqual(ord(ss[0]), 255);
      for j := 1 to 254 do
        Check(ss[j] = '-');
      Check(ss[255] = #0);
    end
    else
    begin
      CheckEqual(ord(ss[0]), 255);
      for j := 1 to 252 do
        Check(ss[j] = '-');
      Check(ss[253] = '.');
      Check(ss[254] = '.');
      Check(ss[255] = #0);
    end;
  end;
  P := 'toto';
  Check(GotoNextLine(P) = nil);
  P := 'to'#10'po';
  Check(GotoNextLine(P)^ = 'p');
  P := 'to'#13#10'po';
  Check(GotoNextLine(P)^ = 'p');
  P := 'to'#3#13#10'po';
  Check(GotoNextLine(P)^ = 'p');
  P := 'to'#10#10'po';
  Check(GotoNextLine(P)^ = #10);
  P := 'to'#13#10#13#10'po';
  Check(GotoNextLine(P)^ = #13);
  P := 'to'#3#1'po';
  Check(GotoNextLine(P) = nil);
  P := 'to'#3#0'po';
  Check(GotoNextLine(P) = nil);
end;

procedure TTestCoreBase.Charsets;

  procedure CheckCodePage(const name, utf, ref: RawUtf8; cp: cardinal);
  // see https://github.com/python/cpython/tree/main/Lib/test/cjkencodings
  var
    msg: string;
    su, su2: SynUnicode;
    ra, a, a2: RawByteString;
    ru, u, u2: RawUtf8;
    eng: TSynAnsiConvert;
    {$ifdef HASCODEPAGE}
    w: WideString;
    {$endif HASCODEPAGE}
  begin
    FormatString('% (cp=%)', [name, cp], msg);
    ru := Base64ToBin(utf);
    ra := Base64ToBin(ref);
    {
    u := StringFromFile('/home/ab/dev/lib2/backup/cjkencodings/' + name + '-utf8.txt');
    CheckEqual(u, ru, name);
    a := StringFromFile('/home/ab/dev/lib2/backup/cjkencodings/' + name + '.txt');
    CheckEqual(a, ra, name);
    }
    FakeCodePage(RawByteString(ru), CP_UTF8);
    FakeCodePage(ra, cp);
    if CheckFailed(ru <> '', msg) or
       CheckFailed(ra <> '', msg) then
      exit;
    Check(length(ru) > length(ra), 'utf8 oversize');
    // validate UTF-8 to/from UTF-16 conversion
    su := Utf8ToSynUnicode(ru);
    Check(su <> '', msg);
    CheckEqual(StrLenW(pointer(su)), length(su));
    CheckEqual(SynUnicodeToUtf8(su), ru, 'utf8');
    {$ifdef HASCODEPAGE} // old Delphi RTL does not decode UTF-16 surrogates
    w := UTF8Decode(ru);
    CheckEqual(length(w), length(su), 'rtl1');
    CheckEqual(StrLenW(pointer(w)), length(su));
    Check(CompareMem(pointer(w), pointer(su), length(w)), 'rtl2');
    {$endif HASCODEPAGE}
    {$ifdef OSWINDOWS}
    // skip old Windows (XP/Vista/Seven) which may miss some/most encodings
    if (OSVersion < wTen) or
       (wsWine in WindowsSpecs) then // Wine/ICU also behind
      exit; // seems not available without a specific language pack
    {$endif OSWINDOWS}
    // validate mORMot conversion
    eng := TSynAnsiConvert.Engine(cp);
    Check(eng <> nil, 'eng1');
    CheckEqual(eng.CodePage, cp, 'eng2');
    // with ASCII-7 chars
    su2 := eng.AnsiToUnicodeString('abcd efgh');
    CheckEqual(StrLenW(pointer(su2)), length(su2));
    Check(su2 = 'abcd efgh', msg);
    a := eng.UnicodeStringToAnsi(su2);
    {$ifdef OSPOSIX}
    if cp = 50225 then // iso2022_kr
      {$ifdef OSDARWIN}
      exit;  // MacOS ICU seems to be not as expected with escape chars
      {$else}
      if Check(a <> '', 'kr1') then
        if Check(PCardinal(a)^ = 1126769691, 'kr2') then
          delete(a, 1, 4); // delete IEC 2022 escape char
      {$endif OSDARWIN}
    {$endif OSPOSIX}
    CheckEqual(a, 'abcd efgh');
    // don't even try on unsupported charsets
    case cp of
      951, // big5hkscs seems unstandardized on Windows: no matching code page
      50220, 50222, 51949:
        // those codepages fail on both Windows and Debian ICU
        // -> some inacurracy in Unicode_CodePageName() ?
        exit;
      // mORMot is therefore currently validated against:
      // hz (cp=52936) gb18030 (cp=54936) big5 (cp=950) cp949 (cp=949)
      // euc_jp (cp=20932) gb2312 (cp=936) gbk (cp=936) iso2022_kr (cp=50225)
      // johab (cp=1361) shift_jis (cp=932)
      // -> we would need some input from native speakers of missing charsets
    end;
    {$ifdef OSPOSIX}
    {$ifdef ISDELPHI}
    if cp = 1361 then
      exit; // not worth investigating yet
    {$endif ISDELPHI}
    if (name = 'hz') and
       not icu.IsAvailable then // FPC RTL iconv is not enough about HZ-GB2312
      exit;
    {$endif OSPOSIX}
    // validate Unicode RTL conversion
    {$ifdef HASCODEPAGE}
    {$ifdef OSPOSIX}
    if name <> 'hz' then // HZ-GB2312 requires ICU - skip FPC RTL iconv
    {$endif OSPOSIX}
    begin
      CheckEqual(GetCodePage(ru), CP_UTF8);
      a := ru;
      SetCodePage(a, cp, {convert=}true);
      CheckEqual(a, ra, name);
    end;
    {$endif HASCODEPAGE}
    // with variable-length encoding
    a := eng.Utf8ToAnsi(ru);
    CheckEqual(a, ra, name);
    {$ifdef OSWINDOWS}
    if cp = 1361 then
      exit; // some casing issue to investigate on Windows (not with ICU)
    {$endif OSWINDOWS}
    su2 := eng.AnsiToUnicodeString(ra);
    CheckEqual(StrLenW(pointer(su2)), length(su));
    Check(su = su2, msg);
    eng := TSynAnsiConvert.Engine(cp); // validate "last" cache
    Check(eng <> nil, 'eng3');
    CheckEqual(eng.CodePage, cp, 'eng4');
    eng.AnsiToUtf8(a, u2);
    Check(u2 = ru, msg);
    a2 := eng.UnicodeStringToAnsi(su);
    CheckEqual(a2, a, name);
    eng.AnsiToUtf8(ra, u);
    CheckEqual(u, ru, name);
  end;

begin
  // from https://github.com/python/cpython/tree/main/Lib/test/cjkencodings
  // - base-64 encoded reference as 7-bit text to please all Delphi/FPC versions
  // - note that python code page naming may be inconsistent with ICU
  CheckCodePage('hz',
    'VGhpcyBzZW50ZW5jZSBpcyBpbiBBU0NJSS4KVGhlIG5leHQgc2VudGVuY2UgaXMg' +
    'aW4gR0Iu5bex5omA5LiN5qyy77yM5Yu/5pa95pa85Lq644CCQnllLgo=',
    'VGhpcyBzZW50ZW5jZSBpcyBpbiBBU0NJSS4KVGhlIG5leHQgc2VudGVuY2UgaXMg' +
    'aW4gR0Iufns8Okt5MjtTeyMsTnBKKWw2SEshI359QnllLgo=', 52936);
  CheckCodePage('gb18030',
    'UHl0aG9u77yI5rS+5qOu77yJ6K+t6KiA5piv5LiA56eN5Yqf6IO95by65aSn6ICM' +
    '5a6M5ZaE55qE6YCa55So5Z6L6K6h566X5py656iL5bqP6K6+6K6h6K+t6KiA77yM' +
    'CuW3sue7j+WFt+acieWNgeWkmuW5tOeahOWPkeWxleWOhuWPsu+8jOaIkOeGn+S4' +
    'lOeos+WumuOAgui/meenjeivreiogOWFt+aciemdnuW4uOeugOaNt+iAjOa4heaZ' +
    'sArnmoTor63ms5XnibnngrnvvIzpgILlkIjlrozmiJDlkITnp43pq5jlsYLku7vl' +
    'iqHvvIzlh6DkuY7lj6/ku6XlnKjmiYDmnInnmoTmk43kvZzns7vnu5/kuK0K6L+Q' +
    '6KGM44CC6L+Z56eN6K+t6KiA566A5Y2V6ICM5by65aSn77yM6YCC5ZCI5ZCE56eN' +
    '5Lq65aOr5a2m5Lmg5L2/55So44CC55uu5YmN77yM5Z+65LqO6L+ZCuenjeivreio' +
    'gOeahOebuOWFs+aKgOacr+ato+WcqOmjnumAn+eahOWPkeWxle+8jOeUqOaIt+aV' +
    'sOmHj+aApeWJp+aJqeWkp++8jOebuOWFs+eahOi1hOa6kOmdnuW4uOWkmuOAggrl' +
    'poLkvZXlnKggUHl0aG9uIOS4reS9v+eUqOaXouacieeahCBDIGxpYnJhcnk/CuOA' +
    'gOWcqOizh+ioiuenkeaKgOW/q+mAn+eZvOWxleeahOS7iuWkqSwg6ZaL55m85Y+K' +
    '5ris6Kmm6Luf6auU55qE6YCf5bqm5piv5LiN5a655b+96KaW55qECuiqsumhjC4g' +
    '54K65Yqg5b+r6ZaL55m85Y+K5ris6Kmm55qE6YCf5bqmLCDmiJHlgJHkvr/luLjl' +
    'uIzmnJvog73liKnnlKjkuIDkupvlt7Lplovnmbzlpb3nmoQKbGlicmFyeSwg5Lim' +
    '5pyJ5LiA5YCLIGZhc3QgcHJvdG90eXBpbmcg55qEIHByb2dyYW1taW5nIGxhbmd1' +
    'YWdlIOWPrwrkvpvkvb/nlKguIOebruWJjeacieioseioseWkmuWkmueahCBsaWJy' +
    'YXJ5IOaYr+S7pSBDIOWvq+aIkCwg6ICMIFB5dGhvbiDmmK/kuIDlgIsKZmFzdCBw' +
    'cm90b3R5cGluZyDnmoQgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2UuIOaVheaIkeWAkeW4' +
    'jOacm+iDveWwh+aXouacieeahApDIGxpYnJhcnkg5ou/5YiwIFB5dGhvbiDnmoTn' +
    'krDlooPkuK3muKzoqablj4rmlbTlkIguIOWFtuS4reacgOS4u+imgeS5n+aYr+aI' +
    'keWAkeaJgAropoHoqI7oq5bnmoTllY/poYzlsLHmmK86Cu2MjOydtOyNrOydgCDq' +
    'sJXroKXtlZwg6riw64ql7J2EIOyngOuLjCDrspTsmqkg7Lu07ZOo7YSwIO2UhOuh' +
    'nOq3uOuemOuwjSDslrjslrTri6QuCgo=',
    'UHl0aG9uo6jFycmto6nT79HUysfSu9bWuabE3Me/tPO2+M3qyca1xM2o08PQzbzG' +
    'y+O7+rPM0PLJ6LzG0+/R1KOsCtLRvq2+39PQyq624MTqtcS3otW5wPrKt6Oss8nK' +
    '7MfSzsi2qKGj1eLW1tPv0dS+39PQt8ezo7zyvd22+MflzvoKtcTT77eozNi146Os' +
    'ysq6z83qs8m499bWuN+y48jOzvGjrLy4uvW/ydLU1NrL+dPQtcSy2df3z7XNs9bQ' +
    'CtTL0NCho9Xi1tbT79HUvPK1pbb4x7+086Osysq6z7j31tbIy8q/0afPsMq508Oh' +
    'o8S/x7CjrLv509rV4grW1tPv0dS1xM/gudi8vMr11f3U2rfJy9m1xLei1bmjrNPD' +
    'u6fK/cG/vLG+58CptPOjrM/gudi1xNfK1LS3x7OjtuChowrI57rO1NogUHl0aG9u' +
    'INbQyrnTw7zI09C1xCBDIGxpYnJhcnk/CqGh1NrZWdONv8a8vL/sy9mwbNW5tcS9' +
    '8czsLCDpX7BsvLCcedSH3Jvzd7XEy9m2yMrHsrvI3br20pW1xArVbu59LiCe6bzT' +
    'v+zpX7BsvLCcedSHtcTL2bbILCDO0oKDseOzo8+jzfvE3MD708PSu9Cp0tHpX7Bs' +
    'usO1xApsaWJyYXJ5LCCBS9PQ0ruCgCBmYXN0IHByb3RvdHlwaW5nILXEIHByb2dy' +
    'YW1taW5nIGxhbmd1YWdlIL/JCrmpyrnTwy4gxL/HsNPQ1FPUU7bgtuC1xCBsaWJy' +
    'YXJ5IMrH0tQgQyCMkbPJLCC2+CBQeXRob24gysfSu4KACmZhc3QgcHJvdG90eXBp' +
    'bmcgtcQgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2UuILnKztKCg8+jzfvE3IyivMjT0LXE' +
    'CkMgbGlicmFyeSDEw7W9IFB5dGhvbiC1xK1ovrPW0Jx51Ie8sNX7us8uIMbk1tDX' +
    '7tb30qrSssrHztKCg8v5CtKq05HVk7XEhpbufb7Nysc6CoM1xzGDM5ozgzKxMYMz' +
    'lTEggjfRNoMwjDSDNoQzIII4iTWCOPs2gzOVNSCDM9UxgjmBNSCDMP05gzOGMCCD' +
    'NNwzgzX2N4M1lzUggzX5NYMwkTmCOIM5gjn8M4Mw8DQggzLrOYMy6zWCOYM5LgoK', 54936);
  CheckCodePage('big5',
    '5aaC5L2V5ZyoIFB5dGhvbiDkuK3kvb/nlKjml6LmnInnmoQgQyBsaWJyYXJ5Pwrj' +
    'gIDlnKjos4foqIrnp5HmioDlv6vpgJ/nmbzlsZXnmoTku4rlpKksIOmWi+eZvOWP' +
    'iua4rOippui7n+mrlOeahOmAn+W6puaYr+S4jeWuueW/veimlueahAroqrLpoYwu' +
    'IOeCuuWKoOW/q+mWi+eZvOWPiua4rOippueahOmAn+W6piwg5oiR5YCR5L6/5bi4' +
    '5biM5pyb6IO95Yip55So5LiA5Lqb5bey6ZaL55m85aW955qECmxpYnJhcnksIOS4' +
    'puacieS4gOWAiyBmYXN0IHByb3RvdHlwaW5nIOeahCBwcm9ncmFtbWluZyBsYW5n' +
    'dWFnZSDlj68K5L6b5L2/55SoLiDnm67liY3mnInoqLHoqLHlpJrlpJrnmoQgbGli' +
    'cmFyeSDmmK/ku6UgQyDlr6vmiJAsIOiAjCBQeXRob24g5piv5LiA5YCLCmZhc3Qg' +
    'cHJvdG90eXBpbmcg55qEIHByb2dyYW1taW5nIGxhbmd1YWdlLiDmlYXmiJHlgJHl' +
    'uIzmnJvog73lsIfml6LmnInnmoQKQyBsaWJyYXJ5IOaLv+WIsCBQeXRob24g55qE' +
    '55Kw5aKD5Lit5ris6Kmm5Y+K5pW05ZCILiDlhbbkuK3mnIDkuLvopoHkuZ/mmK/m' +
    'iJHlgJHmiYAK6KaB6KiO6KuW55qE5ZWP6aGM5bCx5pivOgoK',
    'pnCm86ZiIFB5dGhvbiCkpKjPpc6sSqazqrogQyBsaWJyYXJ5PwqhQKZiuOqwVKzs' +
    'p96n1rN0tW+uaaq6pLWk0Swgtn21b6TOtPq41bNuxemqurN0q9esT6SjrmWpv7X4' +
    'qroKvdLDRC4grLClW6fWtn21b6TOtPq41aq6s3Sr1ywgp9qtzKtLsWCnxrHmr+Cn' +
    'UaXOpECox6R3tn21b6ZuqroKbGlicmFyeSwgqMOms6RArdMgZmFzdCBwcm90b3R5' +
    'cGluZyCquiBwcm9ncmFtbWluZyBsYW5ndWFnZSClaQqo0ajPpc4uIKXYq2Wms7Nc' +
    's1ymaKZoqrogbGlicmFyeSCsT6VIIEMgvGemqCwgptMgUHl0aG9uIKxPpECt0wpm' +
    'YXN0IHByb3RvdHlwaW5nIKq6IHByb2dyYW1taW5nIGxhbmd1YWdlLiCsR6farcyn' +
    'xrHmr+CxTqxKprOqugpDIGxpYnJhcnkgrrOo7CBQeXRob24gqrrA9LnSpKS0+rjV' +
    'pM6+46ZYLiCo5KSks8ylRK1upF2sT6farcyp0gqtbrBRvdequrDdw0S0TqxPOgoK',  950);
  CheckCodePage('big5hkscs',
    '8KCEjMSa6bWu572T5rSGCsOKw4rMhMOqIMOqw6rMhAo=',
    'iEWIXIpzi9qN2AqIZohiiKcgiKeIowo=', 951);
  CheckCodePage('cp949', // with Python, this means
    '65ig67Cp6rCB7ZWYIO2OsuyLnOy9nOudvAoK44mv44mv64KpISEg5Zug5Lmd5pyI' +
    '7Yyo66+k66aU6raIIOKToeKTlu2bgMK/wr/CvyDquI3rkpkg4pOU646oIOOJry4g' +
    'Lgrkup7smIHik5TriqXtmrkgLiAuIC4gLiDshJzsmrjrpIQg646Q7ZWZ5LmZIOWu' +
    'tu2bgCAhICEgIeOFoC7jhaAK7Z2Q7Z2Q7Z2QIOOEseOEseOEseKYhuOFoF/jhaAg' +
    '7Ja066aoIO2DuOy9sOq4kCDrjozsnZEg7LmR5Lmd65Ok5LmZIOOJr+uTnOq4kArs' +
    'hKTrpowg5a627ZuAIC4gLiAuIC4g6rW07JWg7ImMIOKTlOq2iCDik6HrppjjibHq' +
    'uJAg5Zug5LuB5bed76aB5Lit6rmM7Ka8CuyZgOySgO2bgCAhICEg5Lqe7JiB4pOU' +
    'IOWutuuKpeq2iCDimIbkuIrqtIAg7JeG64ql6raI64qlIOS6nuuKpeuSiO2bgCDq' +
    'uIDslaDrk7QK4pOh66Ck65OA5LmdIOyLgO2SlOyItO2bgCDslrTrpqgg5Zug5LuB' +
    '5bed76aB5Lit7IuB4pGo65Ok7JWcISEg44mv44mv64Kp4pmhIOKMkuKMkioKCg==',
    'jGO55rCix88gvIS9w8TdtvMKCqjAqMCzsyEhIOzXzvrqxcbQkuaQcLHFIKjeqNPE' +
    'UqKvoq+iryCx4IqWIKjRtbMgqMAuIC4K5Ky/tajRtMnIwiAuIC4gLiAuILytv++3' +
    '7yC1r8fQ6+AgyqvEUiAhICEgIaTQLqTQCsjlyOXI5SCkoaShpKGh2aTQX6TQIL7u' +
    'kIogxcvE4oNPILWuwMAgr2jO+rXp6+AgqMC15YNPCryzkGogyqvEUiAuIC4gLiAu' +
    'ILG8vtaaZiCo0bHFIKjekHSowoNPIOzX7NL0ueX88emx7qOOCr/NvqzEUiAhICEg' +
    '5Ky/tajRIMqrtMmxxSCh2d++sPwgvvi0ybHFtMkg5Ky0ybXYxFIgsdu+1orbCqje' +
    't8G14M76IJrDx7S9pMRSIL7ukIog7Nfs0vS55fzx6ZrEqO+16Z3aISEgqMCowLOz' +
    'or0godKh0ioKCg==', 949);
  CheckCodePage('euc_jp',
    'UHl0aG9uIOOBrumWi+eZuuOBr+OAgTE5OTAg5bm044GU44KN44GL44KJ6ZaL5aeL' +
    '44GV44KM44Gm44GE44G+44GZ44CCCumWi+eZuuiAheOBriBHdWlkbyB2YW4gUm9z' +
    'c3VtIOOBr+aVmeiCsueUqOOBruODl+ODreOCsOODqeODn+ODs+OCsOiogOiqnuOA' +
    'jEFCQ+OAjeOBrumWi+eZuuOBq+WPguWKoOOBl+OBpuOBhOOBvuOBl+OBn+OBjOOA' +
    'gUFCQyDjga/lrp/nlKjkuIrjga7nm67nmoTjgavjga/jgYLjgb7jgorpganjgZfj' +
    'gabjgYTjgb7jgZvjgpPjgafjgZfjgZ/jgIIK44GT44Gu44Gf44KB44CBR3VpZG8g' +
    '44Gv44KI44KK5a6f55So55qE44Gq44OX44Ot44Kw44Op44Of44Oz44Kw6KiA6Kqe' +
    '44Gu6ZaL55m644KS6ZaL5aeL44GX44CB6Iux5Zu9IEJCUyDmlL7pgIHjga7jgrPj' +
    'g6Hjg4fjgqPnlarntYTjgIzjg6Ljg7Pjg4bjgqMg44OR44Kk44K944Oz44CN44Gu' +
    '44OV44Kh44Oz44Gn44GC44KLIEd1aWRvIOOBr+OBk+OBruiogOiqnuOCkuOAjFB5' +
    'dGhvbuOAjeOBqOWQjeOBpeOBkeOBvuOBl+OBn+OAggrjgZPjga7jgojjgYbjgaro' +
    'g4zmma/jgYvjgonnlJ/jgb7jgozjgZ8gUHl0aG9uIOOBruiogOiqnuioreioiOOB' +
    'r+OAgeOAjOOCt+ODs+ODl+ODq+OAjeOBp+OAjOe/kuW+l+OBjOWuueaYk+OAjeOB' +
    'qOOBhOOBhuebruaomeOBq+mHjeeCueOBjOe9ruOBi+OCjOOBpuOBhOOBvuOBmeOA' +
    'ggrlpJrjgY/jga7jgrnjgq/jg6rjg5fjg4jns7voqIDoqp7jgafjga/jg6bjg7zj' +
    'grbjga7nm67lhYjjga7liKnkvr/mgKfjgpLlhKrlhYjjgZfjgaboibLjgIXjgarm' +
    'qZ/og73jgpLoqIDoqp7opoHntKDjgajjgZfjgablj5bjgorlhaXjgozjgovloLTl' +
    'kIjjgYzlpJrjgYTjga7jgafjgZnjgYzjgIFQeXRob24g44Gn44Gv44Gd44GG44GE' +
    '44Gj44Gf5bCP57Sw5bel44GM6L+95Yqg44GV44KM44KL44GT44Go44Gv44GC44G+' +
    '44KK44GC44KK44G+44Gb44KT44CCCuiogOiqnuiHquS9k+OBruapn+iDveOBr+ac' +
    'gOWwj+mZkOOBq+aKvOOBleOBiOOAgeW/heimgeOBquapn+iDveOBr+aLoeW8teOD' +
    'ouOCuOODpeODvOODq+OBqOOBl+OBpui/veWKoOOBmeOCi+OAgeOBqOOBhOOBhuOB' +
    'ruOBjCBQeXRob24g44Gu44Od44Oq44K344O844Gn44GZ44CCCgo=',
    'UHl0aG9uIKTOs6vIr6TPoaIxOTkwIMevpLSk7aSrpOmzq7vPpLWk7KTGpKSk3qS5' +
    'oaMKs6vIr7zUpM4gR3VpZG8gdmFuIFJvc3N1bSCkz7a1sOnN0aTOpdel7aWwpeml' +
    '36XzpbC4wLjsodZBQkOh16TOs6vIr6TLu7Kyw6S3pMakpKTepLekv6SsoaJBQkMg' +
    'pM+8ws3RvuWkzszcxaqky6TPpKKk3qTqxaykt6TGpKSk3qS7pPOkx6S3pL+howqk' +
    's6TOpL+k4aGiR3VpZG8gpM+k6KTqvMLN0cWqpMql16XtpbCl6aXfpfOlsLjAuOyk' +
    'zrOryK+k8rOru8+kt6GisdG58SBCQlMgyvzB96TOpbOl4aXHpaPI1sHIodal4qXz' +
    'pcaloyCl0aWkpb2l86HXpM6l1aWhpfOkx6SipOsgR3VpZG8gpM+ks6TOuMC47KTy' +
    'odZQeXRob26h16TIzL6kxaSxpN6kt6S/oaMKpLOkzqTopKakysfYt8qkq6TpwLik' +
    '3qTspL8gUHl0aG9uIKTOuMC47MDft9ekz6Giodalt6Xzpdel66HXpMeh1r2sxsCk' +
    'rM3GsNeh16TIpKSkpszcybiky73FxcCkrMPWpKuk7KTGpKSk3qS5oaMKwr+kr6TO' +
    'pbmlr6XqpdelyLfPuMC47KTHpM+l5qG8pbakzszcwOikzs34ytjAraTyzaXA6KS3' +
    'pMa/p6G5pMq1oce9pPK4wLjszdfBx6TIpLekxrzopOrG/qTspOu+7LnnpKzCv6Sk' +
    'pM6kx6S5pKyholB5dGhvbiCkx6TPpL2kpqSkpMOkv76uutm5qaSsxMmyw6S1pOyk' +
    '66SzpMikz6SipN6k6qSipOqk3qS7pPOhowq4wLjsvKvCzqTOtaHHvaTPuse+rrjC' +
    'pMuyoaS1pKihosmszdekyrWhx72kz7PIxKWl4qW4peWhvKXrpMikt6TGxMmyw6S5' +
    'pOuhoqTIpKSkpqTOpKwgUHl0aG9uIKTOpd2l6qW3obykx6S5oaMKCg==', 20932);
  CheckCodePage('euc_jisx0213',
    'UHl0aG9uIOOBrumWi+eZuuOBr+OAgTE5OTAg5bm044GU44KN44GL44KJ6ZaL5aeL' +
    '44GV44KM44Gm44GE44G+44GZ44CCCumWi+eZuuiAheOBriBHdWlkbyB2YW4gUm9z' +
    'c3VtIOOBr+aVmeiCsueUqOOBruODl+ODreOCsOODqeODn+ODs+OCsOiogOiqnuOA' +
    'jEFCQ+OAjeOBrumWi+eZuuOBq+WPguWKoOOBl+OBpuOBhOOBvuOBl+OBn+OBjOOA' +
    'gUFCQyDjga/lrp/nlKjkuIrjga7nm67nmoTjgavjga/jgYLjgb7jgorpganjgZfj' +
    'gabjgYTjgb7jgZvjgpPjgafjgZfjgZ/jgIIK44GT44Gu44Gf44KB44CBR3VpZG8g' +
    '44Gv44KI44KK5a6f55So55qE44Gq44OX44Ot44Kw44Op44Of44Oz44Kw6KiA6Kqe' +
    '44Gu6ZaL55m644KS6ZaL5aeL44GX44CB6Iux5Zu9IEJCUyDmlL7pgIHjga7jgrPj' +
    'g6Hjg4fjgqPnlarntYTjgIzjg6Ljg7Pjg4bjgqMg44OR44Kk44K944Oz44CN44Gu' +
    '44OV44Kh44Oz44Gn44GC44KLIEd1aWRvIOOBr+OBk+OBruiogOiqnuOCkuOAjFB5' +
    'dGhvbuOAjeOBqOWQjeOBpeOBkeOBvuOBl+OBn+OAggrjgZPjga7jgojjgYbjgaro' +
    'g4zmma/jgYvjgonnlJ/jgb7jgozjgZ8gUHl0aG9uIOOBruiogOiqnuioreioiOOB' +
    'r+OAgeOAjOOCt+ODs+ODl+ODq+OAjeOBp+OAjOe/kuW+l+OBjOWuueaYk+OAjeOB' +
    'qOOBhOOBhuebruaomeOBq+mHjeeCueOBjOe9ruOBi+OCjOOBpuOBhOOBvuOBmeOA' +
    'ggrlpJrjgY/jga7jgrnjgq/jg6rjg5fjg4jns7voqIDoqp7jgafjga/jg6bjg7zj' +
    'grbjga7nm67lhYjjga7liKnkvr/mgKfjgpLlhKrlhYjjgZfjgaboibLjgIXjgarm' +
    'qZ/og73jgpLoqIDoqp7opoHntKDjgajjgZfjgablj5bjgorlhaXjgozjgovloLTl' +
    'kIjjgYzlpJrjgYTjga7jgafjgZnjgYzjgIFQeXRob24g44Gn44Gv44Gd44GG44GE' +
    '44Gj44Gf5bCP57Sw5bel44GM6L+95Yqg44GV44KM44KL44GT44Go44Gv44GC44G+' +
    '44KK44GC44KK44G+44Gb44KT44CCCuiogOiqnuiHquS9k+OBruapn+iDveOBr+ac' +
    'gOWwj+mZkOOBq+aKvOOBleOBiOOAgeW/heimgeOBquapn+iDveOBr+aLoeW8teOD' +
    'ouOCuOODpeODvOODq+OBqOOBl+OBpui/veWKoOOBmeOCi+OAgeOBqOOBhOOBhuOB' +
    'ruOBjCBQeXRob24g44Gu44Od44Oq44K344O844Gn44GZ44CCCgrjg47jgYvjgpog' +
    '44OI44KaIOODiOOCre+otu+ouSDwoZq08KqOjCDpuoDpvYHwqZuwCg==',
    'UHl0aG9uIKTOs6vIr6TPoaIxOTkwIMevpLSk7aSrpOmzq7vPpLWk7KTGpKSk3qS5' +
    'oaMKs6vIr7zUpM4gR3VpZG8gdmFuIFJvc3N1bSCkz7a1sOnN0aTOpdel7aWwpeml' +
    '36XzpbC4wLjsodZBQkOh16TOs6vIr6TLu7Kyw6S3pMakpKTepLekv6SsoaJBQkMg' +
    'pM+8ws3RvuWkzszcxaqky6TPpKKk3qTqxaykt6TGpKSk3qS7pPOkx6S3pL+howqk' +
    's6TOpL+k4aGiR3VpZG8gpM+k6KTqvMLN0cWqpMql16XtpbCl6aXfpfOlsLjAuOyk' +
    'zrOryK+k8rOru8+kt6GisdG58SBCQlMgyvzB96TOpbOl4aXHpaPI1sHIodal4qXz' +
    'pcaloyCl0aWkpb2l86HXpM6l1aWhpfOkx6SipOsgR3VpZG8gpM+ks6TOuMC47KTy' +
    'odZQeXRob26h16TIzL6kxaSxpN6kt6S/oaMKpLOkzqTopKakysfYt8qkq6TpwLik' +
    '3qTspL8gUHl0aG9uIKTOuMC47MDft9ekz6Giodalt6Xzpdel66HXpMeh1r2sxsCk' +
    'rM3GsNeh16TIpKSkpszcybiky73FxcCkrMPWpKuk7KTGpKSk3qS5oaMKwr+kr6TO' +
    'pbmlr6XqpdelyLfPuMC47KTHpM+l5qG8pbakzszcwOikzs34ytjAraTyzaXA6KS3' +
    'pMa/p6G5pMq1oce9pPK4wLjszdfBx6TIpLekxrzopOrG/qTspOu+7LnnpKzCv6Sk' +
    'pM6kx6S5pKyholB5dGhvbiCkx6TPpL2kpqSkpMOkv76uutm5qaSsxMmyw6S1pOyk' +
    '66SzpMikz6SipN6k6qSipOqk3qS7pPOhowq4wLjsvKvCzqTOtaHHvaTPuse+rrjC' +
    'pMuyoaS1pKihosmszdekyrWhx72kz7PIxKWl4qW4peWhvKXrpMikt6TGxMmyw6S5' +
    'pOuhoqTIpKSkpqTOpKwgUHl0aG9uIKTOpd2l6qW3obykx6S5oaMKCqXOpPcgpf4g' +
    'pcilra+sr9ogz+OP/tggj/7Uj/7oj/zWCg==', 50220);
  CheckCodePage('euc_kr',
    '4peOIO2MjOydtOyNrChQeXRob24p7J2AIOuwsOyasOq4sCDsib3qs6AsIOqwleug' +
    'pe2VnCDtlITroZzqt7jrnpjrsI0g7Ja47Ja07J6F64uI64ukLiDtjIzsnbTsjazs' +
    'nYAK7Zqo7Jyo7KCB7J24IOqzoOyImOykgCDrjbDsnbTthLAg6rWs7KGw7JmAIOqw' +
    'hOuLqO2VmOyngOunjCDtmqjsnKjsoIHsnbgg6rCd7LK07KeA7Zal7ZSE66Gc6re4' +
    '656Y67CN7J2ECuyngOybkO2VqeuLiOuLpC4g7YyM7J207I2s7J2YIOyasOyVhCjl' +
    'hKrpm4Up7ZWcIOusuOuyleqzvCDrj5nsoIEg7YOA7J207ZWRLCDqt7jrpqzqs6Ag' +
    '7J247YSw7ZSE66as7YyFCu2ZmOqyveydgCDtjIzsnbTsjazsnYQg7Iqk7YGs66a9' +
    '7YyF6rO8IOyXrOufrCDrtoTslbzsl5DshJzsmYAg64yA67aA67aE7J2YIO2UjOue' +
    'q+2PvOyXkOyEnOydmCDruaDrpbgK7JWg7ZSM66as7LyA7J207IWYIOqwnOuwnOyd' +
    'hCDtlaAg7IiYIOyeiOuKlCDsnbTsg4HsoIHsnbgg7Ja47Ja066GcIOunjOuTpOyW' +
    'tOykjeuLiOuLpC4KCuKYhuyyq+qwgOuBnTog64Kg7JWE6528IOyTlOyTlOyTqX4g' +
    '64uB7YG8ISDrnL3quIjsl4bsnbQg7KCE7Zml64uI64ukLiDrt4EuIOq3uOufsOqx' +
    'sCDsnY7ri6QuCg==',
    'od0gxsTAzL3jKFB5dGhvbinAuiC56L/sseIgvbGw7SwgsK23wsfRIMfBt86x17eh' +
    'udYgvvC+7sDUtM+02S4gxsTAzL3jwLoKyL/AssD7wM4gsO289sHYILWlwMzFzSCx' +
    'uMG2v80gsKO03MfPwfa4uCDIv8CywPvAziCwtMO8wfbH4sfBt86x17ehudbAuwrB' +
    '9r/4x9W0z7TZLiDGxMDMvePAxyC/7L7GKOnQ5Lopx9Egua65/bD6ILW/wPsgxbjA' +
    'zMfOLCCx17iusO0gwM7FzcfBuK7GwwrIr7DmwLogxsTAzL3jwLsgvbrFqbizxsOw' +
    '+iC/qbevILrQvt+/obytv80gtOu6zrrQwMcgx8O3p8b7v6G8rcDHILr8uKUKvtbH' +
    'w7iuxMnAzLzHILCzud/AuyDH0iC89iDA1rTCIMDMu/PA+8DOIL7wvu63ziC4uLXp' +
    'vu7B3bTPtNkuCgqh2cO5sKGzoTogs6++xrbzIKTUpLak0KTUpNSktqTQpNS+sX4g' +
    'pNSkpKTSpLfFrSEgpNSkqKTRpLex3b74wMwgwPyk1KS+pMiksrTPtNkuIKTUpLKk' +
    'zqSqLiCx17exsMUgpNSkt6TRpLS02S4K', 51949);
  CheckCodePage('gb2312',
    'UHl0aG9u77yI5rS+5qOu77yJ6K+t6KiA5piv5LiA56eN5Yqf6IO95by65aSn6ICM' +
    '5a6M5ZaE55qE6YCa55So5Z6L6K6h566X5py656iL5bqP6K6+6K6h6K+t6KiA77yM' +
    'CuW3sue7j+WFt+acieWNgeWkmuW5tOeahOWPkeWxleWOhuWPsu+8jOaIkOeGn+S4' +
    'lOeos+WumuOAgui/meenjeivreiogOWFt+aciemdnuW4uOeugOaNt+iAjOa4heaZ' +
    'sArnmoTor63ms5XnibnngrnvvIzpgILlkIjlrozmiJDlkITnp43pq5jlsYLku7vl' +
    'iqHvvIzlh6DkuY7lj6/ku6XlnKjmiYDmnInnmoTmk43kvZzns7vnu5/kuK0K6L+Q' +
    '6KGM44CC6L+Z56eN6K+t6KiA566A5Y2V6ICM5by65aSn77yM6YCC5ZCI5ZCE56eN' +
    '5Lq65aOr5a2m5Lmg5L2/55So44CC55uu5YmN77yM5Z+65LqO6L+ZCuenjeivreio' +
    'gOeahOebuOWFs+aKgOacr+ato+WcqOmjnumAn+eahOWPkeWxle+8jOeUqOaIt+aV' +
    'sOmHj+aApeWJp+aJqeWkp++8jOebuOWFs+eahOi1hOa6kOmdnuW4uOWkmuOAggoK',
    'UHl0aG9uo6jFycmto6nT79HUysfSu9bWuabE3Me/tPO2+M3qyca1xM2o08PQzbzG' +
    'y+O7+rPM0PLJ6LzG0+/R1KOsCtLRvq2+39PQyq624MTqtcS3otW5wPrKt6Oss8nK' +
    '7MfSzsi2qKGj1eLW1tPv0dS+39PQt8ezo7zyvd22+MflzvoKtcTT77eozNi146Os' +
    'ysq6z83qs8m499bWuN+y48jOzvGjrLy4uvW/ydLU1NrL+dPQtcSy2df3z7XNs9bQ' +
    'CtTL0NCho9Xi1tbT79HUvPK1pbb4x7+086Osysq6z7j31tbIy8q/0afPsMq508Oh' +
    'o8S/x7CjrLv509rV4grW1tPv0dS1xM/gudi8vMr11f3U2rfJy9m1xLei1bmjrNPD' +
    'u6fK/cG/vLG+58CptPOjrM/gudi1xNfK1LS3x7OjtuChowoK', 936);
  CheckCodePage('gbk',
    'UHl0aG9u77yI5rS+5qOu77yJ6K+t6KiA5piv5LiA56eN5Yqf6IO95by65aSn6ICM' +
    '5a6M5ZaE55qE6YCa55So5Z6L6K6h566X5py656iL5bqP6K6+6K6h6K+t6KiA77yM' +
    'CuW3sue7j+WFt+acieWNgeWkmuW5tOeahOWPkeWxleWOhuWPsu+8jOaIkOeGn+S4' +
    'lOeos+WumuOAgui/meenjeivreiogOWFt+aciemdnuW4uOeugOaNt+iAjOa4heaZ' +
    'sArnmoTor63ms5XnibnngrnvvIzpgILlkIjlrozmiJDlkITnp43pq5jlsYLku7vl' +
    'iqHvvIzlh6DkuY7lj6/ku6XlnKjmiYDmnInnmoTmk43kvZzns7vnu5/kuK0K6L+Q' +
    '6KGM44CC6L+Z56eN6K+t6KiA566A5Y2V6ICM5by65aSn77yM6YCC5ZCI5ZCE56eN' +
    '5Lq65aOr5a2m5Lmg5L2/55So44CC55uu5YmN77yM5Z+65LqO6L+ZCuenjeivreio' +
    'gOeahOebuOWFs+aKgOacr+ato+WcqOmjnumAn+eahOWPkeWxle+8jOeUqOaIt+aV' +
    'sOmHj+aApeWJp+aJqeWkp++8jOebuOWFs+eahOi1hOa6kOmdnuW4uOWkmuOAggrl' +
    'poLkvZXlnKggUHl0aG9uIOS4reS9v+eUqOaXouacieeahCBDIGxpYnJhcnk/CuOA' +
    'gOWcqOizh+ioiuenkeaKgOW/q+mAn+eZvOWxleeahOS7iuWkqSwg6ZaL55m85Y+K' +
    '5ris6Kmm6Luf6auU55qE6YCf5bqm5piv5LiN5a655b+96KaW55qECuiqsumhjC4g' +
    '54K65Yqg5b+r6ZaL55m85Y+K5ris6Kmm55qE6YCf5bqmLCDmiJHlgJHkvr/luLjl' +
    'uIzmnJvog73liKnnlKjkuIDkupvlt7Lplovnmbzlpb3nmoQKbGlicmFyeSwg5Lim' +
    '5pyJ5LiA5YCLIGZhc3QgcHJvdG90eXBpbmcg55qEIHByb2dyYW1taW5nIGxhbmd1' +
    'YWdlIOWPrwrkvpvkvb/nlKguIOebruWJjeacieioseioseWkmuWkmueahCBsaWJy' +
    'YXJ5IOaYr+S7pSBDIOWvq+aIkCwg6ICMIFB5dGhvbiDmmK/kuIDlgIsKZmFzdCBw' +
    'cm90b3R5cGluZyDnmoQgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2UuIOaVheaIkeWAkeW4' +
    'jOacm+iDveWwh+aXouacieeahApDIGxpYnJhcnkg5ou/5YiwIFB5dGhvbiDnmoTn' +
    'krDlooPkuK3muKzoqablj4rmlbTlkIguIOWFtuS4reacgOS4u+imgeS5n+aYr+aI' +
    'keWAkeaJgAropoHoqI7oq5bnmoTllY/poYzlsLHmmK86Cgo=',
    'UHl0aG9uo6jFycmto6nT79HUysfSu9bWuabE3Me/tPO2+M3qyca1xM2o08PQzbzG' +
    'y+O7+rPM0PLJ6LzG0+/R1KOsCtLRvq2+39PQyq624MTqtcS3otW5wPrKt6Oss8nK' +
    '7MfSzsi2qKGj1eLW1tPv0dS+39PQt8ezo7zyvd22+MflzvoKtcTT77eozNi146Os' +
    'ysq6z83qs8m499bWuN+y48jOzvGjrLy4uvW/ydLU1NrL+dPQtcSy2df3z7XNs9bQ' +
    'CtTL0NCho9Xi1tbT79HUvPK1pbb4x7+086Osysq6z7j31tbIy8q/0afPsMq508Oh' +
    'o8S/x7CjrLv509rV4grW1tPv0dS1xM/gudi8vMr11f3U2rfJy9m1xLei1bmjrNPD' +
    'u6fK/cG/vLG+58CptPOjrM/gudi1xNfK1LS3x7OjtuChowrI57rO1NogUHl0aG9u' +
    'INbQyrnTw7zI09C1xCBDIGxpYnJhcnk/CqGh1NrZWdONv8a8vL/sy9mwbNW5tcS9' +
    '8czsLCDpX7BsvLCcedSH3Jvzd7XEy9m2yMrHsrvI3br20pW1xArVbu59LiCe6bzT' +
    'v+zpX7BsvLCcedSHtcTL2bbILCDO0oKDseOzo8+jzfvE3MD708PSu9Cp0tHpX7Bs' +
    'usO1xApsaWJyYXJ5LCCBS9PQ0ruCgCBmYXN0IHByb3RvdHlwaW5nILXEIHByb2dy' +
    'YW1taW5nIGxhbmd1YWdlIL/JCrmpyrnTwy4gxL/HsNPQ1FPUU7bgtuC1xCBsaWJy' +
    'YXJ5IMrH0tQgQyCMkbPJLCC2+CBQeXRob24gysfSu4KACmZhc3QgcHJvdG90eXBp' +
    'bmcgtcQgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2UuILnKztKCg8+jzfvE3IyivMjT0LXE' +
    'CkMgbGlicmFyeSDEw7W9IFB5dGhvbiC1xK1ovrPW0Jx51Ie8sNX7us8uIMbk1tDX' +
    '7tb30qrSssrHztKCg8v5CtKq05HVk7XEhpbufb7Nysc6Cgo=', 936);
  CheckCodePage('iso2022_jp',
    'UHl0aG9uIOOBrumWi+eZuuOBr+OAgTE5OTAg5bm044GU44KN44GL44KJ6ZaL5aeL' +
    '44GV44KM44Gm44GE44G+44GZ44CCCumWi+eZuuiAheOBriBHdWlkbyB2YW4gUm9z' +
    'c3VtIOOBr+aVmeiCsueUqOOBruODl+ODreOCsOODqeODn+ODs+OCsOiogOiqnuOA' +
    'jEFCQ+OAjeOBrumWi+eZuuOBq+WPguWKoOOBl+OBpuOBhOOBvuOBl+OBn+OBjOOA' +
    'gUFCQyDjga/lrp/nlKjkuIrjga7nm67nmoTjgavjga/jgYLjgb7jgorpganjgZfj' +
    'gabjgYTjgb7jgZvjgpPjgafjgZfjgZ/jgIIK44GT44Gu44Gf44KB44CBR3VpZG8g' +
    '44Gv44KI44KK5a6f55So55qE44Gq44OX44Ot44Kw44Op44Of44Oz44Kw6KiA6Kqe' +
    '44Gu6ZaL55m644KS6ZaL5aeL44GX44CB6Iux5Zu9IEJCUyDmlL7pgIHjga7jgrPj' +
    'g6Hjg4fjgqPnlarntYTjgIzjg6Ljg7Pjg4bjgqMg44OR44Kk44K944Oz44CN44Gu' +
    '44OV44Kh44Oz44Gn44GC44KLIEd1aWRvIOOBr+OBk+OBruiogOiqnuOCkuOAjFB5' +
    'dGhvbuOAjeOBqOWQjeOBpeOBkeOBvuOBl+OBn+OAggrjgZPjga7jgojjgYbjgaro' +
    'g4zmma/jgYvjgonnlJ/jgb7jgozjgZ8gUHl0aG9uIOOBruiogOiqnuioreioiOOB' +
    'r+OAgeOAjOOCt+ODs+ODl+ODq+OAjeOBp+OAjOe/kuW+l+OBjOWuueaYk+OAjeOB' +
    'qOOBhOOBhuebruaomeOBq+mHjeeCueOBjOe9ruOBi+OCjOOBpuOBhOOBvuOBmeOA' +
    'ggrlpJrjgY/jga7jgrnjgq/jg6rjg5fjg4jns7voqIDoqp7jgafjga/jg6bjg7zj' +
    'grbjga7nm67lhYjjga7liKnkvr/mgKfjgpLlhKrlhYjjgZfjgaboibLjgIXjgarm' +
    'qZ/og73jgpLoqIDoqp7opoHntKDjgajjgZfjgablj5bjgorlhaXjgozjgovloLTl' +
    'kIjjgYzlpJrjgYTjga7jgafjgZnjgYzjgIFQeXRob24g44Gn44Gv44Gd44GG44GE' +
    '44Gj44Gf5bCP57Sw5bel44GM6L+95Yqg44GV44KM44KL44GT44Go44Gv44GC44G+' +
    '44KK44GC44KK44G+44Gb44KT44CCCuiogOiqnuiHquS9k+OBruapn+iDveOBr+ac' +
    'gOWwj+mZkOOBq+aKvOOBleOBiOOAgeW/heimgeOBquapn+iDveOBr+aLoeW8teOD' +
    'ouOCuOODpeODvOODq+OBqOOBl+OBpui/veWKoOOBmeOCi+OAgeOBqOOBhOOBhuOB' +
    'ruOBjCBQeXRob24g44Gu44Od44Oq44K344O844Gn44GZ44CCCgo=',
    'UHl0aG9uIBskQiROMytILyRPISIbKEIxOTkwIBskQkcvJDQkbSQrJGkzKztPJDUk' +
    'bCRGJCQkXiQ5ISMbKEIKGyRCMytILzxUJE4bKEIgR3VpZG8gdmFuIFJvc3N1bSAb' +
    'JEIkTzY1MGlNUSROJVclbSUwJWklXyVzJTA4QDhsIVYbKEJBQkMbJEIhVyROMytI' +
    'LyRLOzIyQyQ3JEYkJCReJDckPyQsISIbKEJBQkMgGyRCJE88Qk1RPmUkTkxcRSok' +
    'SyRPJCIkXiRqRSwkNyRGJCQkXiQ7JHMkRyQ3JD8hIxsoQgobJEIkMyROJD8kYSEi' +
    'GyhCR3VpZG8gGyRCJE8kaCRqPEJNUUUqJEolVyVtJTAlaSVfJXMlMDhAOGwkTjMr' +
    'SC8kcjMrO08kNyEiMVE5cRsoQiBCQlMgGyRCSnxBdyROJTMlYSVHJSNIVkFIIVYl' +
    'YiVzJUYlIxsoQiAbJEIlUSUkJT0lcyFXJE4lVSUhJXMkRyQiJGsbKEIgR3VpZG8g' +
    'GyRCJE8kMyROOEA4bCRyIVYbKEJQeXRob24bJEIhVyRITD4kRSQxJF4kNyQ/ISMb' +
    'KEIKGyRCJDMkTiRoJCYkSkdYN0okKyRpQDgkXiRsJD8bKEIgUHl0aG9uIBskQiRO' +
    'OEA4bEBfN1ckTyEiIVYlNyVzJVclayFXJEchVj0sRkAkLE1GMFchVyRIJCQkJkxc' +
    'STgkSz1FRUAkLENWJCskbCRGJCQkXiQ5ISMbKEIKGyRCQj8kLyROJTklLyVqJVcl' +
    'SDdPOEA4bCRHJE8lZiE8JTYkTkxcQGgkTk14SlhALSRyTSVAaCQ3JEY/JyE5JEo1' +
    'IUc9JHI4QDhsTVdBRyRIJDckRjxoJGpGfiRsJGs+bDlnJCxCPyQkJE4kRyQ5JCwh' +
    'IhsoQlB5dGhvbiAbJEIkRyRPJD0kJiQkJEMkPz4uOlk5KSQsREkyQyQ1JGwkayQz' +
    'JEgkTyQiJF4kaiQiJGokXiQ7JHMhIxsoQgobJEI4QDhsPCtCTiRONSFHPSRPOkc+' +
    'LjhCJEsyISQ1JCghIkksTVckSjUhRz0kTzNIRCUlYiU4JWUhPCVrJEgkNyRGREky' +
    'QyQ5JGshIiRIJCQkJiROJCwbKEIgUHl0aG9uIBskQiROJV0laiU3ITwkRyQ5ISMb' +
    'KEIKCg==', 50222);
  CheckCodePage('iso2022_kr',
    '4peOIO2MjOydtOyNrChQeXRob24p7J2AIOuwsOyasOq4sCDsib3qs6AsIOqwleug' +
    'pe2VnCDtlITroZzqt7jrnpjrsI0g7Ja47Ja07J6F64uI64ukLiDtjIzsnbTsjazs' +
    'nYAK7Zqo7Jyo7KCB7J24IOqzoOyImOykgCDrjbDsnbTthLAg6rWs7KGw7JmAIOqw' +
    'hOuLqO2VmOyngOunjCDtmqjsnKjsoIHsnbgg6rCd7LK07KeA7Zal7ZSE66Gc6re4' +
    '656Y67CN7J2ECuyngOybkO2VqeuLiOuLpC4g7YyM7J207I2s7J2YIOyasOyVhCjl' +
    'hKrpm4Up7ZWcIOusuOuyleqzvCDrj5nsoIEg7YOA7J207ZWRLCDqt7jrpqzqs6Ag' +
    '7J247YSw7ZSE66as7YyFCu2ZmOqyveydgCDtjIzsnbTsjazsnYQg7Iqk7YGs66a9' +
    '7YyF6rO8IOyXrOufrCDrtoTslbzsl5DshJzsmYAg64yA67aA67aE7J2YIO2UjOue' +
    'q+2PvOyXkOyEnOydmCDruaDrpbgK7JWg7ZSM66as7LyA7J207IWYIOqwnOuwnOyd' +
    'hCDtlaAg7IiYIOyeiOuKlCDsnbTsg4HsoIHsnbgg7Ja47Ja066GcIOunjOuTpOyW' +
    'tOykjeuLiOuLpC4KCuKYhuyyq+qwgOuBnTog64Kg7JWE6528IOyTqX4g7YG8ISDq' +
    'uIjsl4bsnbQg7KCE64uI64ukLiDqt7jrn7DqsbAg64ukLgo=',
    'GyQpQw4hXQ8gDkZEQEw9Yw8oUHl0aG9uKQ5AOg8gDjloP2wxYg8gDj0xMG0PLCAO' +
    'MC03QkdRDyAOR0E3TjFXNyE5Vg8gDj5wPm5AVDRPNFkPLiAORkRATD1jQDoPCg5I' +
    'P0AyQHtATg8gDjBtPHZBWA8gDjUlQExFTQ8gDjE4QTY/TQ8gDjAjNFxHT0F2ODgP' +
    'IA5IP0AyQHtATg8gDjA0QzxBdkdiR0E3TjFXNyE5VkA7DwoOQXY/eEdVNE80WQ8u' +
    'IA5GREBMPWNARw8gDj9sPkYPKA5pUGQ6DykOR1EPIA45Ljl9MHoPIA41P0B7DyAO' +
    'RThATEdODywgDjFXOC4wbQ8gDkBORU1HQTguRkMPCg5ILzBmQDoPIA5GREBMPWNA' +
    'Ow8gDj06RSk4M0ZDMHoPIA4/KTcvDyAOOlA+Xz8hPC0/TQ8gDjRrOk46UEBHDyAO' +
    'R0M3J0Z7PyE8LUBHDyAOOnw4JQ8KDj5WR0M4LkRJQEw8Rw8gDjAzOV9AOw8gDkdS' +
    'DyAOPHYPIA5AVjRCDyAOQEw7c0B7QE4PIA4+cD5uN04PIA44ODVpPm5BXTRPNFkP' +
    'LgoKDiFZQzkwITMhDzogDjMvPkY2cw8gDj4xD34gDkUtDyEgDjFdPnhATA8gDkB8' +
    'NE80WQ8uIA4xVzcxMEUPIA40WQ8uCg==', 50225);
  CheckCodePage('johab',
    '65ig67Cp6rCB7ZWYIO2OsuyLnOy9nOudvAoK44mv44mv64KpISEg5Zug5Lmd5pyI' +
    '7Yyo66+k66aU6raIIOKToeKTlu2bgMK/wr/CvyDquI3rkpkg4pOU646oIOOJry4g' +
    'Lgrkup7smIHik5TriqXtmrkgLiAuIC4gLiDshJzsmrjrpIQg646Q7ZWZ5LmZIOWu' +
    'tu2bgCAhICEgIeOFoC7jhaAK7Z2Q7Z2Q7Z2QIOOEseOEseOEseKYhuOFoF/jhaAg' +
    '7Ja066aoIO2DuOy9sOq4kCDrjozsnZEg7LmR5Lmd65Ok5LmZIOOJr+uTnOq4kArs' +
    'hKTrpowg5a627ZuAIC4gLiAuIC4g6rW07JWg7ImMIOKTlOq2iCDik6HrppjjibHq' +
    'uJAg5Zug5LuB5bed76aB5Lit6rmM7Ka8CuyZgOySgO2bgCAhICEg5Lqe7JiB4pOU' +
    'IOWutuuKpeq2iCDimIbkuIrqtIAg7JeG64ql6raI64qlIOS6nuuKpeuSiO2bgCDq' +
    'uIDslaDrk7QK4pOh66Ck65OA5LmdIOyLgO2SlOyItO2bgCDslrTrpqgg5Zug5LuB' +
    '5bed76aB5Lit7IuB4pGo65Ok7JWcISEg44mv44mv64Kp4pmhIOKMkuKMkioKCg==',
    'mbGkd4hi0GEgzVyvocWpnGEKCtzA3MCQcyEhIPFn4pzwVcyBo4mfhYqhINze3NPS' +
    'etmv2a/ZryCLd5bTINzRlYEg3MAuIC4K7Ty1d9zRk3fScyAuIC4gLiAuIKzhtome' +
    'oSCVZdBi8OAg4DvSeiAhICEgIYdBLodBCtNh02HTYSCIQYhBiEHZaYdBX4dBILTh' +
    'n5ogyKHFwYt6IJVht3cgw5finJdp8OAg3MCXYYt6Cqzpn3og4DvSeiAuIC4gLiAu' +
    'IIqJtIGuuiDc0YqhINzen4ncwot6IPFn8WL1Se388+mMYbuaCrXBsqHSeiAhICEg' +
    '7Ty1d9zRIOA7k3eKoSDZaeq+icUgtPSTd4qhk3cg7TyTd5bB0nogi2m0gZd6Ctze' +
    'nWGXQeKcIK+BzqGuodJ6ILThn5og8WfxYvVJ7fzz6a+C3O+XabR6ISEg3MDcwJBz' +
    '2b0g2WLZYioKCg==', 1361);
  CheckCodePage('shift_jisx0213',
    'UHl0aG9uIOOBrumWi+eZuuOBr+OAgTE5OTAg5bm044GU44KN44GL44KJ6ZaL5aeL' +
    '44GV44KM44Gm44GE44G+44GZ44CCCumWi+eZuuiAheOBriBHdWlkbyB2YW4gUm9z' +
    'c3VtIOOBr+aVmeiCsueUqOOBruODl+ODreOCsOODqeODn+ODs+OCsOiogOiqnuOA' +
    'jEFCQ+OAjeOBrumWi+eZuuOBq+WPguWKoOOBl+OBpuOBhOOBvuOBl+OBn+OBjOOA' +
    'gUFCQyDjga/lrp/nlKjkuIrjga7nm67nmoTjgavjga/jgYLjgb7jgorpganjgZfj' +
    'gabjgYTjgb7jgZvjgpPjgafjgZfjgZ/jgIIK44GT44Gu44Gf44KB44CBR3VpZG8g' +
    '44Gv44KI44KK5a6f55So55qE44Gq44OX44Ot44Kw44Op44Of44Oz44Kw6KiA6Kqe' +
    '44Gu6ZaL55m644KS6ZaL5aeL44GX44CB6Iux5Zu9IEJCUyDmlL7pgIHjga7jgrPj' +
    'g6Hjg4fjgqPnlarntYTjgIzjg6Ljg7Pjg4bjgqMg44OR44Kk44K944Oz44CN44Gu' +
    '44OV44Kh44Oz44Gn44GC44KLIEd1aWRvIOOBr+OBk+OBruiogOiqnuOCkuOAjFB5' +
    'dGhvbuOAjeOBqOWQjeOBpeOBkeOBvuOBl+OBn+OAggrjgZPjga7jgojjgYbjgaro' +
    'g4zmma/jgYvjgonnlJ/jgb7jgozjgZ8gUHl0aG9uIOOBruiogOiqnuioreioiOOB' +
    'r+OAgeOAjOOCt+ODs+ODl+ODq+OAjeOBp+OAjOe/kuW+l+OBjOWuueaYk+OAjeOB' +
    'qOOBhOOBhuebruaomeOBq+mHjeeCueOBjOe9ruOBi+OCjOOBpuOBhOOBvuOBmeOA' +
    'ggrlpJrjgY/jga7jgrnjgq/jg6rjg5fjg4jns7voqIDoqp7jgafjga/jg6bjg7zj' +
    'grbjga7nm67lhYjjga7liKnkvr/mgKfjgpLlhKrlhYjjgZfjgaboibLjgIXjgarm' +
    'qZ/og73jgpLoqIDoqp7opoHntKDjgajjgZfjgablj5bjgorlhaXjgozjgovloLTl' +
    'kIjjgYzlpJrjgYTjga7jgafjgZnjgYzjgIFQeXRob24g44Gn44Gv44Gd44GG44GE' +
    '44Gj44Gf5bCP57Sw5bel44GM6L+95Yqg44GV44KM44KL44GT44Go44Gv44GC44G+' +
    '44KK44GC44KK44G+44Gb44KT44CCCuiogOiqnuiHquS9k+OBruapn+iDveOBr+ac' +
    'gOWwj+mZkOOBq+aKvOOBleOBiOOAgeW/heimgeOBquapn+iDveOBr+aLoeW8teOD' +
    'ouOCuOODpeODvOODq+OBqOOBl+OBpui/veWKoOOBmeOCi+OAgeOBqOOBhOOBhuOB' +
    'ruOBjCBQeXRob24g44Gu44Od44Oq44K344O844Gn44GZ44CCCgrjg47jgYvjgpog' +
    '44OI44KaIOODiOOCre+otu+ouSDwoZq08KqOjCDpuoDpvYHwqZuwCg==',
    'UHl0aG9uIILMikqUrYLNgUExOTkwIJROgrKC64KpgueKSo5ugrOC6oLEgqKC3IK3' +
    'gUIKikqUrY7SgswgR3VpZG8gdmFuIFJvc3N1bSCCzYuziOeXcILMg3aDjYNPg4mD' +
    'foOTg0+MvozqgXVBQkOBdoLMikqUrYLJjlGJwYK1gsSCooLcgrWCvYKqgUFBQkMg' +
    'gs2OwJdwj+OCzJbak0mCyYLNgqCC3ILok0uCtYLEgqKC3IK5gvGCxYK1gr2BQgqC' +
    'sYLMgr2C34FBR3VpZG8ggs2C5oLojsCXcJNJgsiDdoONg0+DiYN+g5ODT4y+jOqC' +
    'zIpKlK2C8IpKjm6CtYFBiXCNkSBCQlMglfqRl4LMg1KDgYNmg0KU1JFngXWDgoOT' +
    'g2WDQiCDcINDg1yDk4F2gsyDdINAg5OCxYKggukgR3VpZG8ggs2CsYLMjL6M6oLw' +
    'gXVQeXRob26BdoLGlryCw4KvgtyCtYK9gUIKgrGCzILmgqSCyJR3jGmCqYLnkLaC' +
    '3ILqgr0gUHl0aG9uIILMjL6M6pDdjHaCzYFBgXWDVoOTg3aDi4F2gsWBdY9Lk76C' +
    'qpdliNWBdoLGgqKCpJbalVeCyY9kk1+CqpJ1gqmC6oLEgqKC3IK3gUIKkb2CrYLM' +
    'g1iDToOKg3aDZ4xujL6M6oLFgs2DhoFbg1WCzJbakOaCzJeYldaQq4Lwl0SQ5oK1' +
    'gsSQRoFYgsiLQJRcgvCMvozql3aRZoLGgrWCxI7mguiT/ILqgumP6o2HgqqRvYKi' +
    'gsyCxYK3gqqBQVB5dGhvbiCCxYLNgruCpIKigsGCvY+sjdeNSIKqkseJwYKzguqC' +
    '6YKxgsaCzYKggtyC6IKgguiC3IK5gvGBQgqMvozqjqmRzILMi0CUXILNjcWPrIzA' +
    'gsmJn4KzgqaBQZVLl3aCyItAlFyCzYpnkqODgoNXg4WBW4OLgsaCtYLEkseJwYK3' +
    'gumBQYLGgqKCpILMgqogUHl0aG9uIILMg3yDioNWgVuCxYK3gUIKCoNtgvUgg54g' +
    'g2eDTIhLiHkgmIP81iD80vzm+9QK', 50220);
  CheckCodePage('shift_jis',
    'UHl0aG9uIOOBrumWi+eZuuOBr+OAgTE5OTAg5bm044GU44KN44GL44KJ6ZaL5aeL' +
    '44GV44KM44Gm44GE44G+44GZ44CCCumWi+eZuuiAheOBriBHdWlkbyB2YW4gUm9z' +
    'c3VtIOOBr+aVmeiCsueUqOOBruODl+ODreOCsOODqeODn+ODs+OCsOiogOiqnuOA' +
    'jEFCQ+OAjeOBrumWi+eZuuOBq+WPguWKoOOBl+OBpuOBhOOBvuOBl+OBn+OBjOOA' +
    'gUFCQyDjga/lrp/nlKjkuIrjga7nm67nmoTjgavjga/jgYLjgb7jgorpganjgZfj' +
    'gabjgYTjgb7jgZvjgpPjgafjgZfjgZ/jgIIK44GT44Gu44Gf44KB44CBR3VpZG8g' +
    '44Gv44KI44KK5a6f55So55qE44Gq44OX44Ot44Kw44Op44Of44Oz44Kw6KiA6Kqe' +
    '44Gu6ZaL55m644KS6ZaL5aeL44GX44CB6Iux5Zu9IEJCUyDmlL7pgIHjga7jgrPj' +
    'g6Hjg4fjgqPnlarntYTjgIzjg6Ljg7Pjg4bjgqMg44OR44Kk44K944Oz44CN44Gu' +
    '44OV44Kh44Oz44Gn44GC44KLIEd1aWRvIOOBr+OBk+OBruiogOiqnuOCkuOAjFB5' +
    'dGhvbuOAjeOBqOWQjeOBpeOBkeOBvuOBl+OBn+OAggrjgZPjga7jgojjgYbjgaro' +
    'g4zmma/jgYvjgonnlJ/jgb7jgozjgZ8gUHl0aG9uIOOBruiogOiqnuioreioiOOB' +
    'r+OAgeOAjOOCt+ODs+ODl+ODq+OAjeOBp+OAjOe/kuW+l+OBjOWuueaYk+OAjeOB' +
    'qOOBhOOBhuebruaomeOBq+mHjeeCueOBjOe9ruOBi+OCjOOBpuOBhOOBvuOBmeOA' +
    'ggrlpJrjgY/jga7jgrnjgq/jg6rjg5fjg4jns7voqIDoqp7jgafjga/jg6bjg7zj' +
    'grbjga7nm67lhYjjga7liKnkvr/mgKfjgpLlhKrlhYjjgZfjgaboibLjgIXjgarm' +
    'qZ/og73jgpLoqIDoqp7opoHntKDjgajjgZfjgablj5bjgorlhaXjgozjgovloLTl' +
    'kIjjgYzlpJrjgYTjga7jgafjgZnjgYzjgIFQeXRob24g44Gn44Gv44Gd44GG44GE' +
    '44Gj44Gf5bCP57Sw5bel44GM6L+95Yqg44GV44KM44KL44GT44Go44Gv44GC44G+' +
    '44KK44GC44KK44G+44Gb44KT44CCCuiogOiqnuiHquS9k+OBruapn+iDveOBr+ac' +
    'gOWwj+mZkOOBq+aKvOOBleOBiOOAgeW/heimgeOBquapn+iDveOBr+aLoeW8teOD' +
    'ouOCuOODpeODvOODq+OBqOOBl+OBpui/veWKoOOBmeOCi+OAgeOBqOOBhOOBhuOB' +
    'ruOBjCBQeXRob24g44Gu44Od44Oq44K344O844Gn44GZ44CCCgo=',
    'UHl0aG9uIILMikqUrYLNgUExOTkwIJROgrKC64KpgueKSo5ugrOC6oLEgqKC3IK3' +
    'gUIKikqUrY7SgswgR3VpZG8gdmFuIFJvc3N1bSCCzYuziOeXcILMg3aDjYNPg4mD' +
    'foOTg0+MvozqgXVBQkOBdoLMikqUrYLJjlGJwYK1gsSCooLcgrWCvYKqgUFBQkMg' +
    'gs2OwJdwj+OCzJbak0mCyYLNgqCC3ILok0uCtYLEgqKC3IK5gvGCxYK1gr2BQgqC' +
    'sYLMgr2C34FBR3VpZG8ggs2C5oLojsCXcJNJgsiDdoONg0+DiYN+g5ODT4y+jOqC' +
    'zIpKlK2C8IpKjm6CtYFBiXCNkSBCQlMglfqRl4LMg1KDgYNmg0KU1JFngXWDgoOT' +
    'g2WDQiCDcINDg1yDk4F2gsyDdINAg5OCxYKggukgR3VpZG8ggs2CsYLMjL6M6oLw' +
    'gXVQeXRob26BdoLGlryCw4KvgtyCtYK9gUIKgrGCzILmgqSCyJR3jGmCqYLnkLaC' +
    '3ILqgr0gUHl0aG9uIILMjL6M6pDdjHaCzYFBgXWDVoOTg3aDi4F2gsWBdY9Lk76C' +
    'qpdliNWBdoLGgqKCpJbalVeCyY9kk1+CqpJ1gqmC6oLEgqKC3IK3gUIKkb2CrYLM' +
    'g1iDToOKg3aDZ4xujL6M6oLFgs2DhoFbg1WCzJbakOaCzJeYldaQq4Lwl0SQ5oK1' +
    'gsSQRoFYgsiLQJRcgvCMvozql3aRZoLGgrWCxI7mguiT/ILqgumP6o2HgqqRvYKi' +
    'gsyCxYK3gqqBQVB5dGhvbiCCxYLNgruCpIKigsGCvY+sjdeNSIKqkseJwYKzguqC' +
    '6YKxgsaCzYKggtyC6IKgguiC3IK5gvGBQgqMvozqjqmRzILMi0CUXILNjcWPrIzA' +
    'gsmJn4KzgqaBQZVLl3aCyItAlFyCzYpnkqODgoNXg4WBW4OLgsaCtYLEkseJwYK3' +
    'gumBQYLGgqKCpILMgqogUHl0aG9uIILMg3yDioNWgVuCxYK3gUIKCg==', 932);
end;

procedure TTestCoreBase.Iso8601DateAndTime;

  procedure Test(D: TDateTime; Expanded: boolean);
  var
    s, t: RawUtf8;
    E, F: TDateTime;
    I, J: TTimeLogBits;
    st, s2: TSynSystemTime;
    P: PUtf8Char;
    d1, d2: TSynDate;
  begin
    s := DateTimeToIso8601(D, Expanded);
    if Expanded then
      Check(length(s) = 19)
    else
      Check(length(s) = 15);
    if Expanded then
    begin
      Check(Iso8601CheckAndDecode(Pointer(s), length(s), E));
      Check(Abs(D - E) < (1 / SecsPerDay)); // we allow 999 ms error
    end;
    st.FromDateTime(D);
    {%H-}s2.Clear;
    DecodeDate(D, s2.Year, s2.Month, s2.Day);
    DecodeTime(D, s2.Hour, s2.Minute, s2.Second, s2.MilliSecond);
    Check(abs(st.MilliSecond - s2.MilliSecond) <= 1); // allow 1 ms rounding error
    st.MilliSecond := 0;
    s2.MilliSecond := 0;
    Check(st.IsEqual(s2)); // ensure conversion matches the RTL's
    t := st.ToText(Expanded);
    Check(Copy(t, 1, length(s)) = s);
    {%H-}d1.Clear;
    check(d1.IsZero);
    {%H-}d2.SetMax;
    check(not d2.IsZero);
    check{%H-}(not d1.IsEqual(d2));
    check(d1.Compare(d2) < 0);
    check(d2.Compare(d1) > 0);
    t := d2.ToText(false);
    check(t = '99991231');
    check(d2.ToText(true) = '9999-12-31');
    d2.Clear;
    check(d1.IsEqual(d2));
    check(d1.Compare(d2) = 0);
    check(d2.Compare(d1) = 0);
    P := pointer(s);
    check(d1.ParseFromText(P));
    check(P <> nil);
    check(not d1.IsZero);
    check(st.IsDateEqual(d1));
    t := d1.ToText(Expanded);
    check(copy(s, 1, length(t)) = t);
    d2.Clear;
    check(d2.IsZero);
    check(not d1.IsEqual(d2));
    check(d1.Compare(d2) > 0);
    check(d2.Compare(d1) < 0);
    check(d2.ToText(Expanded) = '');
    d2.SetMax;
    check(not d2.IsZero);
    check(not d1.IsEqual(d2));
    check(d1.Compare(d2) < 0);
    check(d2.Compare(d1) > 0);
    d2 := d1;
    check(d1.IsEqual(d2));
    check(d1.Compare(d2) = 0);
    check(d2.Compare(d1) = 0);
    E := Iso8601ToDateTime(s);
    Check(Abs(D - E) < (1 / SecsPerDay)); // we allow 999 ms error
    E := Iso8601ToDateTime(s + 'Z');
    Check(Abs(D - E) < (1 / SecsPerDay)); // we allow 999 ms error
    I.From(D);
    Check(Iso8601ToTimeLog(s) = I.Value);
    t := s;
    t[11] := ''''; // as in SynDB VArray[] quoted parameters
    J.From(pointer(t), 10);
    Check(I.Value and not (1 shl (6 + 6 + 5) - 1) = J.Value);
    I.From(s);
    t := I.Text(Expanded);
    if t <> s then // we allow error on time = 00:00:00 -> I.Text = just date
      Check(I.Value and (1 shl (6 + 6 + 5) - 1) = 0)
    else
      Check(true);
    J.From(E);
    Check(Int64(I) = Int64(J));
    s := TimeToIso8601(D, Expanded); // e.g. 'T23:36:34'
    Check(PosEx('.', s) = 0);
    Check(abs(frac(D) - Iso8601ToDateTime(s)) < 1 / SecsPerDay);
    s := TimeToIso8601(D, Expanded, 'T', true); // 'T23:36:34.715'
    Check(PosEx('.', s) > 0);
    F := Iso8601ToDateTime(s);
    Check(abs(frac(D) - F) < 1 / MSecsPerDay, 'withms1');
    if expanded then
    begin
      delete(s, 1, 1); // '23:36:34.715'
      F := Iso8601ToDateTime(s);
      Check(abs(frac(D) - F) < 1 / MSecsPerDay, 'withmsNoT');
    end;
    s := DateToIso8601(D, Expanded);
    Check(trunc(D) = trunc(Iso8601ToDateTime(s)));
    Check(Abs(D - I.ToDateTime) < (1 / SecsPerDay));
    E := TimeLogToDateTime(I.Value);
    Check(Abs(D - E) < (1 / SecsPerDay));
    s := DateTimeToIso8601(D, Expanded, #0);
    if Expanded then
      Check(length(s) = 18)
    else
      Check(length(s) = 14);
    s := DateTimeToIso8601(D, Expanded, 'T', true);
    Check(PosEx('.', s) > 0);
    if Expanded then
      Check(length(s) = 23)
    else
      Check(length(s) = 19);
    F := Iso8601ToDateTime(s);
    Check(abs(D - F) < 1 / MSecsPerDay, 'withms2');
    if Expanded then
    begin
      F := 0;
      Check(Iso8601CheckAndDecode(pointer(s), length(s), F));
      Check(abs(D - F) < 1 / MSecsPerDay, 'withms3');
    end;
  end;

var
  i: integer;
  D, D2: TDateTime;
  u: Int64; // TUnixTime/TUnixMSTime
  tmp: RawUtf8;
  b: TTimeLogBits;
  st, start: TSynSystemTime;
begin
  Check(TTextDateWriter.InstanceSize <= SizeOf(TLocalWriter) - 256, 'TLocalWriter');
  Check(PtrUInt(@HTML_MONTH_NAMES[3]) - PtrUInt(@HTML_MONTH_NAMES[1]) = 8);
  Check(st.FromText('19821031T142319'));
  start := st;
  CheckEqual(st.ToText, '1982-10-31T14:23:19.000');
  st.Second := 60;
  st.Normalize;
  CheckEqual(st.ToText, '1982-10-31T14:24:00.000', 'next minute');
  st.Minute := 60;
  st.Normalize;
  CheckEqual(st.ToText, '1982-10-31T15:00:00.000', 'next hour');
  st.Hour := 24;
  st.Normalize;
  CheckEqual(st.ToText, '1982-11-01T00:00:00.000', 'next day');
  st.Day := st.DaysInMonth + 1; // + 1 to switch to next month
  CheckEqual(st.Day, 31);
  st.Normalize;
  CheckEqual(st.ToText, '1982-12-01T00:00:00.000', 'next month');
  st.Month := 13;
  st.Normalize;
  CheckEqual(st.ToText, '1983-01-01T00:00:00.000', 'next year 1');
  st.Month := 13;
  st.Normalize;
  CheckEqual(st.ToText, '1984-01-01T00:00:00.000', 'next year 2');
  // reset each time - as THttpAnalyzer.ComputeConsolidateTime
  st := start;
  CheckEqual(st.ToText, '1982-10-31T14:23:19.000');
  st.Second := 60;
  st.Normalize;
  CheckEqual(st.ToText, '1982-10-31T14:24:00.000', 'nextminute');
  st := start;
  st.Second := 0;
  st.Minute := 60;
  st.Normalize;
  CheckEqual(st.ToText, '1982-10-31T15:00:00.000', 'nexthour');
  st := start;
  st.Second := 0;
  st.Minute := 0;
  st.Hour := 24;
  st.Normalize;
  CheckEqual(st.ToText, '1982-11-01T00:00:00.000', 'nextday');
  st := start;
  st.Second := 0;
  st.Minute := 0;
  st.Hour := 0;
  st.Day := st.DaysInMonth + 1; // + 1 to switch to next month
  CheckEqual(st.Day, 32);
  st.Normalize;
  CheckEqual(st.ToText, '1982-11-01T00:00:00.000', 'nextmonth');
  st := start;
  st.Second := 0;
  st.Minute := 0;
  st.Hour := 0;
  st.Day := 1;
  st.Month := 13;
  st.Normalize;
  CheckEqual(st.ToText, '1983-01-01T00:00:00.000', 'nextyear 1');
  st.Month := 13;
  st.Normalize;
  CheckEqual(st.ToText, '1984-01-01T00:00:00.000', 'nextyear 2');
  for i := 1500 to 2500 do
    Check(mormot.core.datetime.IsLeapYear(i) = SysUtils.IsLeapYear(i), 'IsLeapYear');
  // this will test typically from year 1905 to 2065
  D := Now / 20 + rnd.NextDouble * 20; // some starting random date/time
  for i := 1 to 2000 do
  begin
    Test(D, true);
    Test(D, false);
    u := DateTimeToUnixTime(D);
    st.FromUnixTime(u);
    CheckEqual(st.ToUnixTime, u);
    D2 := st.ToDateTime;
    Check(Abs(D2 - D) < (1 / SecsPerDay)); // we allow 999 ms error
    u := DateTimeToUnixMSTime(D);
    st.FromUnixMsTime(u);
    CheckEqual(st.ToUnixMsTime, u);
    D2 := st.ToDateTime;
    Check(Abs(D2 - D) < (1 / MilliSecsPerDay)); // we allow 1 ms error
    D := D + rnd.NextDouble * 57; // go further a little bit: change date/time
  end;
  b.Value := Iso8601ToTimeLog('20150504');
  Check(b.Year = 2015);
  Check(b.Month = 5);
  Check(b.Day = 4);
  tmp := b.Text(false);
  CheckEqual(tmp, '20150504');
  IntervalTextToDateTimeVar('+0 06:03:20', D);
  CheckSame(D, 0.252314, 1e-5);
  D := IntervalTextToDateTime('+1 06:03:20');
  CheckSame(D, 1.252314, 1e-5);
  D := Iso8601ToDateTime('2022-05-11T23:59:56.971655858Z');
  CheckEqual(DateTimeToIso8601(D, true, 'T', true), '2022-05-11T23:59:56.971');
  CheckSame(IntervalTextToDateTime('-20 06:03:20'), -20.252314, 1e-6);
  Check(DateTimeToIso8601Text(IntervalTextToDateTime('+0 06:03:20')) = 'T06:03:20');
  tmp := DateTimeToIso8601Text(IntervalTextToDateTime('+1 06:03:20'));
  CheckEqual(tmp, '1899-12-31T06:03:20');
  tmp := DateTimeToIso8601Text(IntervalTextToDateTime('-2 06:03:20'));
  CheckEqual(tmp, '1899-12-28T06:03:20');
  CheckSame(TimeLogToDateTime(135131870949), 41578.477512, 1e-5);
  tmp := '1982-10-30T06:03:20';
  Check(Iso8601CheckAndDecode(Pointer(tmp), length(tmp), D));
  Check(DateTimeToIso8601(D, true) = tmp);
  tmp := '1982-10-30';
  Check(Iso8601CheckAndDecode(Pointer(tmp), length(tmp), D));
  Check(DateToIso8601(D, true) = tmp);
  tmp := 'T06:03:20';
  Check(Iso8601CheckAndDecode(Pointer(tmp), length(tmp), D));
  Check(TimeToIso8601(D, true) = tmp);
  tmp := '1982-10-30 06:03:20';
  Check(not Iso8601CheckAndDecode(Pointer(tmp), length(tmp), D));
  tmp := 'T06:03:2a';
  Check(not Iso8601CheckAndDecode(Pointer(tmp), length(tmp), D));
  tmp := '1435051262-45869-63626';
  check(Iso8601ToDateTime(tmp) = 0);
  check(Iso8601ToTimelog(tmp) = 0);
  tmp := UnixTimePeriodToString(0);
  CheckEqual(tmp, 'T00:00:00');
  tmp := UnixTimePeriodToString(30);
  CheckEqual(tmp, 'T00:00:30');
  tmp := UnixTimePeriodToString(SecsPerMin);
  CheckEqual(tmp, 'T00:01:00');
  tmp := UnixTimePeriodToString(SecsPerMin * MinsPerHour);
  CheckEqual(tmp, 'T01:00:00');
  tmp := UnixTimePeriodToString(SecsPerDay);
  CheckEqual(tmp, '0000-00-01');
  tmp := UnixTimePeriodToString(SecsPerDay * 15);
  CheckEqual(tmp, '0000-00-15');
  tmp := UnixTimePeriodToString(SecsPerDay * 31);
  CheckEqual(tmp, '0000-00-31');
  tmp := UnixTimePeriodToString(SecsPerDay * (31 + 4));
  CheckEqual(tmp, '0000-01-04');
  tmp := UnixTimePeriodToString(SecsPerDay * (31 + 28 + 7));
  CheckEqual(tmp, '0000-02-07');
  tmp := UnixTimePeriodToString(SecsPerDay * 365);
  CheckEqual(tmp, '0001-00-00');
  tmp := UnixTimePeriodToString(SecsPerDay * 365 + 1);
  CheckEqual(tmp, '0001-00-00');
  tmp := UnixTimePeriodToString(SecsPerDay * 366);
  CheckEqual(tmp, '0001-00-01');
  tmp := UnixTimePeriodToString(SecsPerDay * 365 * 2);
  CheckEqual(tmp, '0002-00-00');
  CheckEqual(DateTimeToIso8601Text(Iso8601ToDateTime('1492-10-12T16:00:00')),
    '1492-10-12T16:00:00');
  CheckEqual(DateTimeToIso8601(Iso8601ToDateTime('2026-01-01T12:00:23.1Z'),
      true, 'T', true), '2026-01-01T12:00:23.100');
  CheckEqual(DateTimeToIso8601(Iso8601ToDateTime('2026-01-01T12:00:23.13Z'),
      true, 'T', true), '2026-01-01T12:00:23.130');
  CheckEqual(DateTimeToIso8601(Iso8601ToDateTime('2026-01-01T12:00:23.123Z'),
      true, 'T', true), '2026-01-01T12:00:23.123');
  CheckEqual(DateTimeToIso8601(Iso8601ToDateTime('2026-01-01T12:00:23.123456Z'),
      true, 'T', true), '2026-01-01T12:00:23.123');
end;

{$R ..\src\mormot.tz.res} // validate our Win11-generated resource file

procedure TTestCoreBase.TimeZonesSlow(Context: TObject);
var
  tz: TSynTimeZone;
  st, stl: TSystemTime;
  t: TSynSystemTime;
  d: TTimeZoneData;
  i, bias: integer;
  m: word;
  hdl, reload: boolean;
  endtix, ts: Int64;
  buf: RawByteString;
  dt, dtl: TDateTime;
  ut: TUnixTime;
  s31: TShort31;

  procedure CheckTimeSpan(Value: Int64; const Expected: RawUtf8);
  var
    parsed: Int64;
    p: PUtf8Char;
  begin
    CheckEqual(TimeSpanToText(Value), Expected);
    p := TextToTimeSpanBuffer(pointer(Expected), parsed);
    if CheckUtf8(p <> nil, Expected) then
      CheckUtf8(p^ = #0, Expected);
    CheckEqual(parsed, Value - Value mod TicksPerMillisecond);
  end;

  procedure CheckInvalidTimeSpan(const Text: RawUtf8);
  var
    ts: Int64;
  begin
    CheckUtf8(not TextToTimeSpan(Text, ts), Text);
  end;

  procedure testBias(year, expected: integer);
  begin
    check(tz.GetBiasForDateTime(EncodeDate(year, 10, 30), '1', bias, hdl));
    check(bias = expected);
  end;

begin
  // validate low-level HTTP date parsing functions
  bias := -10;
  Check(not ParseTimeZone('', bias));
  CheckEqual(bias, -10);
  Check(ParseTimeZone('-0000', bias));
  CheckEqual(bias, TimeZoneLocalBias);
  Check(ParseTimeZone('+0000', bias));
  CheckEqual(bias, 0);
  Check(ParseTimeZone('+0100', bias));
  CheckEqual(bias, 60);
  Check(ParseTimeZone('+02', bias));
  CheckEqual(bias, 120);
  Check(ParseTimeZone('+1005', bias));
  CheckEqual(bias, 605);
  Check(ParseTimeZone('-1005', bias));
  CheckEqual(bias, -605);
  Check(ParseTimeZone('Z', bias));
  CheckEqual(bias, 0);
  Check(ParseTimeZone('+10', bias));
  CheckEqual(bias, 600);
  Check(ParseTimeZone('GMT', bias));
  CheckEqual(bias, 0);
  Check(not ParseTimeZone('-1', bias));
  Check(not ParseTimeZone('-100', bias));
  Check(ParseTimeZone('-10', bias));
  CheckEqual(bias, -600);
  Check(ParseTimeZone('-00:00', bias));
  CheckEqual(bias, TimeZoneLocalBias);
  Check(ParseTimeZone('+00:00', bias));
  CheckEqual(bias, 0);
  Check(ParseTimeZone('+01:00', bias));
  CheckEqual(bias, 60);
  Check(ParseTimeZone('+10:05', bias));
  CheckEqual(bias, 605);
  Check(ParseTimeZone('-10:05', bias));
  CheckEqual(bias, -605);
  Check(not ParseTimeZone('+1O05', bias));
  CheckEqual(bias, -605);
  Check(not ParseTimeZone('+105', bias));
  CheckEqual(bias, -605);
  bias := -10;
  Check(not ParseTimeZone('toto', bias));
  CheckEqual(bias, -10);
  Check(ParseTimeZone('z', bias));
  CheckEqual(bias, 0);
  Check(ParseTimeZone('M', bias));
  CheckEqual(bias, 12 * 60);
  Check(ParseTimeZone('NZDT', bias));
  CheckEqual(bias, 13 * 60);
  Check(ParseTimeZone(' NZT ', bias));
  CheckEqual(bias, 12 * 60);
  Check(ParseTimeZone('utc', bias));
  CheckEqual(bias, 0);
  Check(not ParseTimeZone('uta', bias));
  CheckEqual(bias, 0);
  Check(ParseTimeZone(' east', bias));
  CheckEqual(bias, -10 * 60);
  Check(ParseTimeZone('y   ', bias));
  CheckEqual(bias, -12 * 60);
  Check(ParseTimeZone('gmT ', bias));
  CheckEqual(bias, 0);
  Check(ParseTimeZone('    IDLW    ', bias));
  CheckEqual(bias, -12 * 60);
  m := 0;
  Check(ParseMonth('Jan', m));
  CheckEqual(m, 1);
  Check(not ParseMonth('Jab', m));
  CheckEqual(m, 1);
  Check(ParseMonth(' DEC ', m));
  CheckEqual(m, 12);
  Check(ParseMonth(' apr-', m));
  CheckEqual(m, 4);
  dt := HttpDateToDateTime('Sun, 06 Nov 1994 08:49:37 GMT');
  CheckEqual(DateTimeToIso8601Text(dt), '1994-11-06T08:49:37');
  CheckEqual(DateTimeToHttpDate(dt), 'Sun, 06 Nov 1994 08:49:37 GMT');
  UnixMSTimeUtcToHttpDate(DateTimeToUnixMSTime(dt), s31);
  CheckEqualShort(s31, 'Sun, 06 Nov 1994 08:49:37 GMT', 'UnixMSTimeUtcToHttpDate');
  CheckEqual(DateTimeToIso8601Text(HttpDateToDateTime(
    'Sunday, 06-DEC-94 08:49:37 UTC')), '1994-12-06T08:49:37');
  CheckEqual(DateTimeToIso8601Text(HttpDateToDateTime(
    'Sun Feb  6 08:49:37 1994')), '1994-02-06T08:49:37');
  CheckEqual(DateTimeToIso8601Text(HttpDateToDateTime(
    'Sun, 06 Nov 2021 08:49:37 east')), '2021-11-06T18:49:37');
  CheckEqual(DateTimeToIso8601Text(HttpDateToDateTime(
    'Sun, 06 Nov 08:49:37 east')), '');
  CheckEqual(DateTimeToIso8601Text(HttpDateToDateTime(
    'Sun, 06 Nov 2021 084937 east')), '');
  CheckEqual(DateTimeToIso8601Text(HttpDateToDateTime(
    'Tue, 15 Nov 1994 12:45:26 Z')), '1994-11-15T12:45:26');
  CheckEqual(DateTimeToIso8601Text(HttpDateToDateTime(
    'Sunday, 06-Nov-94 08:49:37 GMT')), '1994-11-06T08:49:37');
  // validate common TSynTimeZone process
  tz := TSynTimeZone.Create;
  try
    check(tz.Zone = nil);
    FillCharFast(d, SizeOf(d), 0);
    for i := 0 to 40 do
    begin
      UInt32ToUtf8(i, RawUtf8(d.id));
      d.display := 'displayed ' + d.id;
      d.tzi.Bias := i;
      check(tz.Zones.Add(d) = i, 'add some zones');
    end;
    tz.Zones.ForceReHash;
    dt := nowutc;
    for reload := false to true do
    begin
      check(tz.Zone <> nil);
      check(tz.Zones.Count = 41);
      for i := 0 to 40 do
      begin
        UInt32ToUtf8(i, RawUtf8(d.id));
        check(tz.GetDisplay(d.id) = 'displayed ' + d.id);
        hdl := true;
        check(tz.GetBiasForDateTime(dt, d.id, bias, hdl));
        check(bias = i);
        check(not hdl);
      end;
      check(not tz.GetBiasForDateTime(dt, 'fail', bias, hdl));
      buf := tz.SaveToBuffer;
      tz.Zones.Clear;
      check(tz.Zone = nil);
      tz.LoadFromBuffer(buf);
    end;
    with tz.Zone[1] do
    begin
      SetLength(dyn, 4);
      dyn[0].year := 2000;
      dyn[0].tzi.bias := 3600;
      dyn[1].year := 2003;
      dyn[1].tzi.bias := 3601;
      dyn[2].year := 2005;
      dyn[2].tzi.bias := 3602;
      dyn[3].year := 2006;
      dyn[3].tzi.bias := 3603;
    end;
    testBias(1990, 3600);
    testBias(2000, 3600);
    testBias(2001, 3600);
    testBias(2002, 3600);
    testBias(2003, 3601);
    testBias(2004, 3601);
    testBias(2005, 3602);
    testBias(2006, 3603);
    testBias(2007, 3603);
    testBias(2008, 3603);
  finally
    tz.Free;
  end;
  // validate mormot.core.os time conversions
  dt := NowUtc;
  dtl := UtcToLocal(dt);
  CheckSameTime(dtl, Now(), 'RTL Now should match mormot.core.os');
  ut := UnixTimeUtc;
  t.FromNow({localtime=}true);
  GetLocalTime(stl);
  //writeln(#10'utc=',DateTimeToSql(dt),#10'loc=',DateTimeToSql(dtl));
  CheckSameTime(UtcToLocal(dt), dtl, 'UtcToLocal');
  CheckSameTime(LocalToUtc(dtl), dt, 'LocalToUtc');
  CheckSameTime(UnixTimeToLocal(ut), dtl, 'UnixTimeToLocal');
  Check(abs(LocalToUnixTime(dtl) - ut) < 2, 'LocalToUnixTime');
  UnixTimeToLocal(ut, st);
  {$ifndef POSIXDELPHI} // SystemTimeToDateTime() not available on Delphi POSIX
  CheckSameTime(SystemTimeToDateTime(st), SystemTimeToDateTime(stl), 'UnixTimeToLocal');
  {$endif POSIXDELPHI}
  {$ifdef VER3_2_4}
  CheckSameTime(LocalTimeToUniversal(dtl), dt, 'LocalTimeToUniversal');
  CheckSameTime(UniversalTimeToLocal(dt), dtl, 'UniversalTimeToLocal');
  {$endif VER3_2_4}
  endtix := GetTickCount64 + 100; // 16ms resolution at worst on Windows
  repeat
    sleep(10); // likely to be executed in a background thread
  until CheckFailed(GetTickCount64 < endtix,
          'NowUtc should not truncate time within 100ms period') or
        (NowUtc > dt);
  // validate zones taken from Windows registry or mormot.tz.res on POSIX
  tz := TSynTimeZone.Default;
  CheckSameTime(tz.UtcToLocal(dt, 'UTC'), dt);
  check(tz.GetBiasForDateTime(dt, 'UTC', bias, hdl));
  check(bias = 0);
  check(not hdl);
  dtl := tz.UtcToLocal(dt, 'Romance Standard Time');
  check(not SameValue(dtl, dt,SecsPerDate), 'Perfide Albion');
  check(tz.GetBiasForDateTime(dt, 'Romance Standard Time', bias, hdl));
  check(hdl);
  check(bias < 0, 'Paris is always ahead of London');
  buf := tz.SaveToBuffer;
  tz := TSynTimeZone.Create;
  try
    tz.LoadFromBuffer(buf);
    CheckSameTime(dtl, tz.UtcToLocal(dt, 'Romance Standard Time'));
  finally
    tz.Free;
  end;
  CheckSameTime(dtl, UtcToLocal(dt, 'Romance Standard Time'));
  // validate TimeSpan conversion
  CheckTimeSpan(0,              '00:00:00');
  CheckTimeSpan(1,              '00:00:00');
  CheckTimeSpan(9999,           '00:00:00');
  CheckTimeSpan(10000,          '00:00:00.001');
  CheckTimeSpan(599990000,      '00:00:59.999');
  CheckTimeSpan(600000000,      '00:01:00');
  CheckTimeSpan(35999990000,    '00:59:59.999');
  CheckTimeSpan(36000000000,    '01:00:00');
  CheckTimeSpan(863999990000,   '23:59:59.999');
  CheckTimeSpan(864000000000,   '1');
  CheckTimeSpan(1728000000000,  '2');
  CheckTimeSpan(1838450060000,  '2.03:04:05.006');
  CheckTimeSpan(9092967890000,  '10.12:34:56.789');
  CheckTimeSpan(-599990000,     '-00:00:59.999');
  CheckTimeSpan(-35999990000,   '-00:59:59.999');
  CheckTimeSpan(-863999990000,  '-23:59:59.999');
  CheckTimeSpan(-1838450060000, '-2.03:04:05.006');
  CheckTimeSpan(-9092967890000, '-10.12:34:56.789');
  CheckTimeSpan(9999999,        '00:00:00.999');
  CheckTimeSpan(10000000,       '00:00:01');
  CheckTimeSpan(600000000,      '00:01:00');
  CheckTimeSpan(36000000000,    '01:00:00');
  CheckTimeSpan(36610000000,    '01:01:01');
  CheckTimeSpan(36611230000,    '01:01:01.123');
  CheckTimeSpan(36611234567,    '01:01:01.123');
  CheckTimeSpan(864000000000,   '1');
  CheckTimeSpan(864000010000,   '1.00:00:00.001');
  CheckTimeSpan(865000000000,   '1.00:01:40');
  CheckTimeSpan(900610000000,   '1.01:01:01');
  CheckTimeSpan(-10000,         '-00:00:00.001');
  CheckTimeSpan(-10000000,      '-00:00:01');
  CheckTimeSpan(-36611230000,   '-01:01:01.123');
  CheckTimeSpan(-864000000000,  '-1');
  CheckTimeSpan(-864000010000,  '-1.00:00:00.001');
  CheckTimeSpan(High(Int64),    '10675199.02:48:05.477');
  CheckTimeSpan(-High(Int64),   '-10675199.02:48:05.477');
  Check(TextToTimeSpan('0.06:18:55', ts));
  CheckEqual(ts, 227350000000);
  Check(TextToTimeSpan(' 0.00:00:00.001 ', ts));
  CheckEqual(ts, 10000);
  Check(TextToTimeSpan('000.23:59:59.99999999', ts));
  CheckEqual(ts, 863999990000);
  CheckInvalidTimeSpan('');
  CheckInvalidTimeSpan('-');
  CheckInvalidTimeSpan('.');
  CheckInvalidTimeSpan(':');
  CheckInvalidTimeSpan('abc');
  CheckInvalidTimeSpan('00:00');
  CheckInvalidTimeSpan('00:00:');
  CheckInvalidTimeSpan('00::00');
  CheckInvalidTimeSpan('1.');
  CheckInvalidTimeSpan('1.00');
  CheckInvalidTimeSpan('1.00:00');
  CheckInvalidTimeSpan('24:00:00');
  CheckInvalidTimeSpan('00:60:00');
  CheckInvalidTimeSpan('00:00:60');
  CheckInvalidTimeSpan('1.24:00:00');
  CheckInvalidTimeSpan('1.00:60:00');
  CheckInvalidTimeSpan('1.00:00:60');
  CheckInvalidTimeSpan('00:00:00.');
  CheckInvalidTimeSpan('00:00:00.1');
  CheckInvalidTimeSpan('00:00:00.12');
  CheckInvalidTimeSpan('00:00:00.12x');
  CheckInvalidTimeSpan('00:00:00.123x');
  CheckInvalidTimeSpan('+00:00:00');
  CheckInvalidTimeSpan('--00:00:00');
  CheckInvalidTimeSpan('-+00:00:00');
end;

const
  _REFSMB = // real export from a Lenovo T470 laptop
    'qjzHzUppv1D+CwAAAADeDgAAAZkAAxABIAIwA01lbW9yeSBJbml0IENvbXBsZQAAABB0ZQB' +
    'FbmQgb2YgRFhFIFBoYXNlAEJJT1MgQm9vaUQADggAAAAAAQAB3gAASW50ZWwoUikgU2lsaW' +
    'NvbiBWaWV3IFRlY2gAAABAbm9sb2d5AACGDQIAKAcXIAAAAAAAAAAQFwMAAwMDAQACGAAAA' +
    'P7/AgEABgARKAQAAwD+/0AAQAAAQA0AAQIagEBVCAMEBQYJAAAAIwBVCAIAsARDaGFubmVs' +
    'QS1ESU1NMABCQU5LIDAAU2FtcwAAAAB1bmcAMzU5N0Q4NEMATm9uZQBNNDcxQTJLNDNDQjE' +
    'tQyDGFwBSQyAgIAECESgFAzACAAAAAgESIwAEAAkAVeVCmgsyADk4NzY1NDMyMUAEAAAwAA' +
    'ATHwYDAP///wEwAQAAAAAAAAAAAAAAAAAAAAAAAAcTAAAAggcAAYABgACAACAAIAAABAUHT' +
    'DEgQ2FjaGUCBwgAAYEBASCCAIIAAgMiBQUFTDJIUwkAAYIBAAwADAMiBgUJTDNGUwQwCgAB' +
    'A80CAACAgOkGCAD/++u/A4pkAIwKKApBMwcACAAJAUUGAgIE/ADNAiCAAAgAAAQAVTNFMUj' +
    '+Q29ycG9yYXRpb25L/mUoVE0pIGk1LTczMAAABwAwVSBDUFUgQCAyLjYwR0h6RI+DmoOaAA' +
    'AYCwABAgDgA/+AmgAAAAAJfQAAEgADDQFGASRMRU5PVk8ATjFRRVQ5NVcgKDEuNwARAAAwI' +
    'CkAMDUvMnHBMDIyAQEbDAABAgMEzLuxmj40shGoXKeYgAAAAPAq1n4GBQaFGjIwSEVTMjNC' +
    'MFUAVGhpbmtQYWQgVDQ3MACEEI8AUEYwVkRFQjgAhBpfTVRfEktfQlVfI+xfRk2kLWdxI+x' +
    'ncQACD9IBVQEAADFFCWEACkWFABJLUxRxU0RLMEo0MDY5NyBXSU4ATDJIRjc3UzAIgIAAM0' +
    'UzQY90IEF2YWlsYWJsZU2PAAMWDgABCiE0AgICAgAAAABwgDCIAAAAAEaFg5pHVU5vIEFzc' +
    '2V0Qfxmb3JtZC+AGhcACAkPABECEhBOgWaBqqqqaAVVU0IgMQABiRAAEAYyAggRABAGMwII' +
    'EgAQBjQCCBMAEAY1AggUABAGNgIIFQAQBjcCCKoSoCQWABAGOAIIFwAQBjkCCBgCEAsfjIB' +
    'FdGhlcm5ldAIIGQIQBxyNgHh0IUhhbEiFAgAgTW+B4m9yAggaAhD/jY5IZG1pAggbABACRG' +
    'lzcGxheVBvcnQvRFYolECgSS1EAggcABAOSERNSQIIHQIQHx2MgEhlYWRwaJGDL01pY3JvY' +
    '+ggUZmABsAgYm8gSmFjaxMDHgAQISEDCREfAAEBAQMBAAABIAEATWVkaWFBU3JkEAMiDiBT' +
    'bG9BBwkRIAcRAQAAAFNpbUNhR2cMBSECAA0WIgERAgAJAAFlbi2AAAABVVMAABYaIwESAAA' +
    'DAmIJHi0E/3kHrEoFCgIARnJvbnQAUwAAgAJBTllPADAxQVY0MTkAMDMuMDEATElPTgIWJA' +
    'USxhvyKwT/CJAAAD4GiKVeUmVhcgBMR0M0MTI4OzOFBSUAAUtIT0lIR0lVQ0NIBAAQxEhJk' +
    'QSHUyYAVFAHAkJBWSBJL08gBAERQAAXAAYCAAEA/wIAAQEUFYBAAQQFAAIEAAABA/YPBPYP' +
    'BfUPAACCFCcAJEFNVBERAQGlrwLAARAAQIUEggCDQCgANQEACwEAAAHA+ABOnQIACcABCAA' +
    'LAH4QXAIAAP4A1xUDAIUhSgABACYBAHZQcm8BAAEA3RopADEQAwcDBQLwATAABQEAUmVmZX' +
    'JlbmNlIYQAwkFdZGUgLUJiAHVDbyF2VmVyc/KYVFhUIEFDTSB2JVUA3RoqCTGxAAACwAAMA' +
    'AMECwhcfhBPM01FIDExLjAATUVCeHcHkXRGaXJtd2FyZQYAAjQgBidWhmUgU0tVAADdSysA' +
    'CgEANHMD//////8EAAEAIQFQAwAGAIKODBACogAHAD4AAAIINAEAAZCxAAAACjTgCwBDA08' +
    'zU0tMIFBDSABBfS1DUgBUIGhJRCBTdGF0dXMAIedhQaNkWENPcmlnaW5x5lZhbHVlWENOIV' +
    'YEeU8QITqyUFJPTSHyUlNUIvJBSUQAdfkgSCBRpEhR+FcHePlEeCD7XUtC41RBokGtT1kgG' +
    'CB2+UxQQFoHkSRDrU8A3TYsAAcWAwBxIJtUATAzcwQF//////8G8g8CAK4AjJEH9A+B/wEA' +
    '/0AzAEEh8lN5c3RlbSBBZ2WRRk8zTVJDUXEh8lBDSXhQU0GQYAQvACgAdjiNTXY4gCMAVmL' +
    'bAAAPHy0AUgAAABAABBNA8AEAAQQCCAQKABQAFgFADIEBABgFLgAiAACEBy8AAdhhAxIXMA' +
    'EyJgCAAAAABQgVBzEABQQxAEAwoAAVBzIABwQhAIMWMwABAQALAAFUVlQtRW5ySm0ykgCIB' +
    'jQAWloAECAyYQCMEzVFhQsEAbIATVMgAQCMEzZGhQUBYwACABc3RoUGAYoTAQAFAA4ARAAC' +
    'CDgAAdsAACRNRZEE21E5ARMBRQIAlAaBEIkwAgBAyAABHwAAAADAAMkKQEQC///////////' +
    '/////////////////////MQCDAAAAKRAAAAAAAAAAAAAAAAAAAAAAQZVJMUKVMkKVMwAAhx' +
    'I6UhABAQBOCACQDwEAUgABjA87RoUHAQEC0UVIVDU0VwAwOC8xMC8yMDIxAYwrPEaFAAAAA' +
    'AgB////////////////////////////////////////AAAAAAAAfwT//gAA';

procedure TTestCoreBase.DmiSmbios;
var
  uid: TGUID;
  raw: TRawSmbiosInfo;
  os:  TSmbiosBasicInfos;
  dec: TSmbiosInfo;
  bak: byte;
  s: RawUtf8;
  b: RawByteString;
  act: TArmCpuType;
  aci: TArmCpuImplementer;

  procedure CheckAgainst(const full: TSmbiosInfo; const os: TSmbiosBasicInfos);
  begin
    CheckEqualTrim(full.Bios.VendorName,    os[sbiBiosVendor], 'vend');
    CheckEqualTrim(full.Bios.Version,       os[sbiBiosVersion], 'vers');
    CheckEqualTrim(full.Bios.Release,       os[sbiBiosRelease], 'rel');
    CheckEqualTrim(full.Bios.Firmware,      os[sbiBiosFirmware], 'firm');
    CheckEqualTrim(full.Bios.BuildDate,     os[sbiBiosDate], 'date');
    CheckEqualTrim(full.System.ProductName, os[sbiProductName], 'pname');
    CheckEqualTrim(full.System.Version,     os[sbiVersion], 'vers');
    CheckEqualTrim(full.System.Uuid,        os[sbiUuid], 'uuid');
    if full.Processor <> nil then
      CheckEqualTrim(full.Processor[0].Manufacturer, os[sbiCpuManufacturer], 'proc');
    if full.Battery <> nil then
      CheckEqualTrim(full.Battery[0].Manufacturer, os[sbiBatteryManufacturer], 'batt');
    // TSmbiosInfo also includes type 12 (System Configuration), while
    // GetSmbios(sbiOem) only exposes type 11 (OEM Strings). Some firmware
    // reports a placeholder such as "Unknown" only in type 12.
    if (full.Oem <> nil) and
       (os[sbiOem] <> '') then
      CheckEqualTrim(full.Oem[0], os[sbiOem], 'oem');
  end;

begin
  for act := low(act) to high(act) do
  begin
    ShortStringToAnsi7String(ARMCPU_ID_TXT[act], s);
    CheckEqual(ord(ArmCpuType(ARMCPU_ID[act])), ord(act), s);
  end;
  for aci := low(aci) to high(aci) do
  begin
    ShortStringToAnsi7String(ARMCPU_IMPL_TXT[aci], s);
    CheckEqual(ord(ArmCpuImplementer(ARMCPU_IMPL[aci])), ord(aci), s);
  end;
  CheckEqual(ord(arm64DCPODP), 64);
  CheckEqual(ord(arm32AES), 32);
  CheckEqual(SizeOf(TSmbiosBiosFlags), 8);
  CheckEqual(SizeOf(TSmbiosMemory) - 7 * SizeOf(RawUtf8), 11);
  CheckEqual(SizeOf(TSmbiosMemoryArray) - 2 * SizeOf(pointer), 5);
  Check(not IsDefaultString(pointer(s), length(s)));
  s := 'Default string';
  Check(IsDefaultString(pointer(s), length(s)));
  s := 'Default String';
  Check(IsDefaultString(pointer(s), length(s)));
  s := 'Default 5tring';
  Check(not IsDefaultString(pointer(s), length(s)));
  // validate actual retrieval from this computer
  GetComputerUuid(uid); // retrieve main SMBIOS and its UUID, or generate it
  Check(_SmbiosRetrieved);
  Check(not IsZero(THash128(uid)), 'machine UUID');
  GetSmbiosInfo; // parse using mormot.core.perf
  CheckAgainst(Smbios, _smbios);
  if Smbios.System.Uuid <> '' then
    Check(IdemPropNameU(ToUtf8(uid), Smbios.System.Uuid), 'uuid');
  // validate from reference binary export, decoding into binary or json
  raw.Data := Base64ToBin(_REFSMB);
  if CheckFailed(raw.Data <> '', '_REFSMB') or
     CheckFailed(CompressSynLZ(raw.Data, false) <> '', '_REFSMB synlz') then
    exit;
  PCardinal(@raw)^ := $010003ff;
  bak := PByte(@_SmbiosDecodeUuid)^;
  _SmbiosDecodeUuid := sduVersion; // consistent UUID decoding on all platforms
  CheckEqual(DecodeSmbios(raw, os), 3066, 'DecodeSmbios');
  Check(DecodeSmbiosInfo(raw, dec), 'DecodeSmbiosInfo');
  PByte(@_SmbiosDecodeUuid)^ := bak;
  CheckAgainst(dec, os);
  CheckHash(BinarySave(@dec.Bios,
    TypeInfo(TSmbiosBios), rkRecordTypes), $9362A439, 'Bios');
  CheckHash(BinarySave(@dec.System,
    TypeInfo(TSmbiosSystem), rkRecordTypes), $E9451367, 'System');
  CheckHash(BinarySave(@dec.Board[0],
    TypeInfo(TSmbiosBoard), rkRecordTypes), $25B6CB6C, 'Board');
  CheckHash(BinarySave(@dec.Chassis[0],
    TypeInfo(TSmbiosChassis), rkRecordTypes), $25633E53, 'Chassis');
  CheckHash(BinarySave(@dec.Processor[0],
    TypeInfo(TSmbiosProcessor), rkRecordTypes), $03E34B17, 'Proc');
  b := BinarySave(@dec.Memory[0], TypeInfo(TSmbiosMemoryArray), rkRecordTypes);
  //FileFromString(b, Executable.ProgramFilePath + CPU_ARCH_TEXT + '.dat');
  CheckEqual(length(b), 137, 'MemoryArray Len');
  CheckHash(b, $87CADDDA, 'MemoryArray');
  SaveJson(dec.Memory[0], TypeInfo(TSmbiosMemoryArray),
    [twoIgnoreDefaultInRecord], s);
  CheckEqual(s, '{"l":3,"u":3,"e":3,"c":"32 GB","n":2,"d":[{"w":64,"d":64,' +
    '"s":"16 GB","f":13,"r":2,"t":26,"e":16512,"l":"ChannelA-DIMM0","b":"B' +
    'ANK 0","m":"Samsung","n":"3597D84C","a":"None","p":"M471A2K43CB1-CRC"' +
    ',"c":2133},{"s":"0 B","f":2,"t":2,"l":"ChannelB-DIMM0","b":"BANK 2"}]}',
    'MemoryArray Json');
  CheckHash(BinarySave(@dec.Memory[0].Device[0],
    TypeInfo(TSmbiosMemory), rkRecordTypes), $895CE535, 'Memory');
  CheckHash(BinarySave(@dec.Connector[0],
    TypeInfo(TSmbiosConnector), rkRecordTypes), $129D5265, 'Conn');
  CheckHash(BinarySave(@dec.Slot[0],
    TypeInfo(TSmbiosSlot), rkRecordTypes), $0BE08E2D, 'Slot');
  CheckHash(BinarySave(@dec.Battery[0],
    TypeInfo(TSmbiosBattery), rkRecordTypes), $7FDA54A0, 'Battery');
  CheckHash(BinarySave(@dec,
    TypeInfo(TSmbiosInfo), rkRecordTypes), $C038E432, 'BinarySave1');
  SaveJson(dec, TypeInfo(TSmbiosInfo), [twoIgnoreDefaultInRecord], s);
  CheckHash(s, $87F82F78, 'BinarySave2');
end;

{$ifdef OSWINDOWS}

function CreateWellKnownSid(WellKnownSidType: byte; DomainSid: PSID;
  pSid: PSID; var cbSid: cardinal): BOOL; stdcall; external 'Advapi32.dll';
function ConvertSidToStringSidA(Sid: PSID; var StringSid: PAnsiChar): BOOL; stdcall;
  external 'Advapi32.dll';

{$endif OSWINDOWS}

procedure TTestCoreBase.OsErrors;
var
  se: TSystemError;
  err: integer;
  txt: RawUtf8;
  ss: TShort63;
  s7: TShort7;
begin
  // some cross-platform Windows/Linux/BSD error detection
  CheckEqual(SystemError(seSuccess), 0);
  CheckEqual(SystemError(seOther), 0);
  CheckEqual(SystemErrorText(seSuccess), 'Success');
  CheckEqual(SystemErrorText(seNameTooLong), 'NameTooLong');
  CheckEqual(SystemErrorText(seOther), 'Other');
  for se := succ(seSuccess) to pred(seOther) do
  begin
    err := SystemError(se);
    CheckNotEqual(err, 0);
    Check(GetSystemError(err) = se);
    Check(IsSystemError(se, err), 'IsOsError');
    ss := SystemErrorShort(err);
    Check(ss[0] <> #0, 'SystemErrorShort');
    txt := SystemErrorText(se);
    CheckNotEqual(txt, '');
    Check(PosEx(txt, ShortStringToUtf8(ss)) > 0);
  end;
  CheckEqualShort(WinErrorConstant(NO_ERROR)^, 'SUCCESS', 'weca');
  CheckEqualShort(WinErrorConstant(995)^, 'OPERATION_ABORTED', 'wecb1');
  CheckEqualShort(WinErrorConstant(1150)^, 'OLD_WIN_VERSION', 'wecb2');
  CheckEqualShort(WinErrorConstant(1450)^, 'NO_SYSTEM_RESOURCES', 'wecb3');
  CheckEqualShort(WinErrorConstant(1907)^, 'PASSWORD_MUST_CHANGE', 'wecb4');
  CheckEqualShort(WinErrorConstant(1200)^, 'BAD_DEVICE', 'wecc');
  CheckEqualShort(WinErrorConstant(234)^, 'MORE_DATA', 'wecd');
  CheckEqualShort(WinErrorConstant(5)^, 'ACCESS_DENIED', 'wece');
  CheckEqualShort(WinErrorConstant(12002)^, 'TIMEOUT', 'wecf');
  CheckEqualShort(WinErrorConstant($800b010a)^, 'CERT_E_CHAINING', 'wecg');
  CheckEqualShort(WinErrorConstant($800b010c)^, 'CERT_E_REVOKED', 'wecG');
  CheckEqualShort(WinErrorConstant($800b010e)^[0], #0, 'wec none');
  CheckEqualShort(WinErrorConstant($80092002)^, 'CRYPT_E_BAD_ENCODE', 'wecH');
  CheckEqualShort(WinErrorConstant(1229)^ , 'CONNECTION_INVALID', 'weci');
  CheckEqualShort(WinErrorConstant(122)^, 'INSUFFICIENT_BUFFER', 'wecj');
  CheckEqualShort(WinErrorConstant(12152)^, 'INVALID_SERVER_RESPONSE', 'weck');
  CheckEqualShort(WinErrorConstant(87)^, 'INVALID_PARAMETER', 'wecl');
  CheckEqualShort(WinErrorConstant(1315)^, 'INVALID_ACCOUNT_NAME', 'wecm');
  CheckEqualShort(WinErrorConstant(1331)^, 'ACCOUNT_DISABLED', 'wecn');
  CheckEqualShort(WinErrorConstant(1342)^, 'SERVER_NOT_DISABLED', 'weco');
  CheckEqualShort(WinErrorShort(0), '0 ERROR_SUCCESS', 'w0');
  CheckEqualShort(WinErrorShort(5), '5 ERROR_ACCESS_DENIED', 'wa');
  CheckEqualShort(WinErrorShort(12002), '12002 ERROR_WINHTTP_TIMEOUT', 'w1');
  CheckEqualShort(WinErrorShort($800b010a), '800b010a CERT_E_CHAINING', 'w2');
  CheckEqualShort(WinErrorShort($80000003), '80000003 EXCEPTION_BREAKPOINT', 'w3');
  CheckEqualShort(WinErrorShort(1722), '1722 RPC_S_SERVER_UNAVAILABLE', 'w4');
  CheckEqualShort(WinErrorShort(12152), '12152 ERROR_WINHTTP_INVALID_SERVER_RESPONSE', 'w5');
  CheckEqualShort(WinErrorShort($c00000fd), 'c00000fd EXCEPTION_STACK_OVERFLOW', 'w6');
  CheckEqualShort(WinErrorShort($80090330), '80090330 SEC_E_DECRYPT_FAILURE', 'w7');
  CheckEqualShort(WinErrorShort($00090321), '590625 SEC_I_RENEGOTIATE', 'w8');
  CheckEqualShort(WinErrorShort($8009002a), '8009002a NTE_NO_MORE_ITEMS', 'w9');
  CheckEqualShort(WinErrorShort($800b0114), '800b0114 CERT_E_INVALID_NAME', 'wa');
  CheckEqualShort(WinErrorShort(244, {noint=}false), '244', '244w');
  CheckEqualShort(WinErrorShort(245, {noint=}true), '', '245w');
  WinErrorShortVar($80092012, ss);
  CheckEqualShort(ss, '80092012 CRYPT_E_NO_REVOCATION_CHECK', 'winrevoc');
  WinErrorShortVar($80092012, s7);
  CheckEqualShort(s7, '8009201', 'trunc to string[7]');
  BsdErrorShortVar(1, ss);
  CheckEqualShort(ss, '1 EPERM', '1bsd');
  BsdErrorShortVar(5, ss);
  CheckEqualShort(ss, '5 EIO', '5bsd');
  BsdErrorShortVar(40, ss);
  CheckEqualShort(ss, '40 EMSGSIZE', '40bsd');
  BsdErrorShortVar(81, ss);
  CheckEqualShort(ss, '81 ENEEDAUTH', '81bsd');
  BsdErrorShortVar(82, ss);
  CheckEqualShort(ss, '82', '82bsd');
  LinuxErrorShortVar(1, ss);
  CheckEqualShort(ss, '1 EPERM', '1lin');
  LinuxErrorShortVar(5, ss);
  CheckEqualShort(ss, '5 EIO', '5lin');
  LinuxErrorShortVar(124, ss);
  CheckEqualShort(ss, '124 EMEDIUMTYPE', '124');
  LinuxErrorShortVar(125, ss);
  CheckEqualShort(ss, '125', '125');
  CheckEqualShort(OsErrorShort(244, {noint=}false), '244', '244a');
  CheckEqualShort(OsErrorShort(244, {noint=}true), '', '244b');
end;

procedure TTestCoreBase._SID;
var
  k: TWellKnownSid;
  s: RawUtf8;
  s1, s2: RawSid;
  {$ifdef OSWINDOWS}
  known: TWellKnownSids;
  sids: TRawUtf8DynArray;
  {$endif OSWINDOWS}
begin
  // validate cross-platform SID process
  CheckEqual(SizeOf(TSid), 1032, 'TSid');
  for k := low(k) to high(k) do
  begin
    s1 := KnownRawSid(k);
    Check(SidToKnown(pointer(s1)) = k);
    Check(SidCompare(pointer(s1), pointer(s1)) = 0);
    s := RawSidToText(s1);
    CheckEqual(s, RawUtf8(KnownSidToText(k)^));
    CheckUtf8(SidToKnown(s) = k, s);
    s2 := TextToRawSid(s);
    CheckEqual(s, RawSidToText(s2));
    CheckUtf8(SidCompare(pointer(s1), pointer(s2)) = 0, s);
  end;
  // validate Windows specific SID function, especially about the current user
  {$ifdef OSWINDOWS}
  CurrentRawSid(s1, wttProcess);
  CurrentRawSid(s2, wttThread);
  Check(SidCompare(pointer(s1), pointer(s2)) = 0);
  s := RawSidToText(s1);
  CheckUtf8(IdemPChar(pointer(s), 'S-1-'), s);
  // domain users are S-1-5-21-*, but LOCAL_SYSTEM S-1-5-18 and AD user S-1-12
  sids := CurrentGroupsSid;
  Check(sids <> nil);
  known := CurrentKnownGroups;
  Check(known <> []);
  for k := low(k) to high(k) do
  begin
    Check(CurrentUserHasGroup(k) = (k in known));
    s := RawSidToText(KnownRawSid(k));
    if k in known then
    begin
      Check(FindRawUtf8(sids, s) >= 0);
      CheckUtf8(CurrentUserHasGroup(s), s);
    end
    else
      CheckUtf8(not CurrentUserHasGroup(s), s);
  end;
  CheckEqualShort(OSErrorShort(5), '5 ERROR_ACCESS_DENIED', '5ead');
  CheckEqualShort(OSErrorShort(5, true), 'ERROR_ACCESS_DENIED', '5ead2');
  {$else}
  CheckEqualShort(OSErrorShort(1), '1 EPERM', '1eperm');
  CheckEqualShort(OSErrorShort(5), '5 EIO', '5eio');
  CheckEqualShort(OSErrorShort(5, true), 'EIO', '5eio2');
  {$endif OSWINDOWS}
end;

const
  // some reference Security Descriptor self-relative buffers
  SD_B64: array[0..9] of RawUtf8 = (
    // 0 [MS-DTYP] 2.5.1.4 SDDL String to Binary Example
    'AQAUsJAAAACgAAAAFAAAADAAAAACABwAAQAAAAKAFAAAAACAAQEAAAAAAAEAAAAAAgBgAAQAAAAAAxgA' +
    'AAAAoAECAAAAAAAFIAAAACECAAAAAxgAAAAAEAECAAAAAAAFIAAAACACAAAAAxQAAAAAEAEBAAAAAAAF' +
    'EgAAAAADFAAAAAAQAQEAAAAAAAMAAAAAAQIAAAAAAAUgAAAAIAIAAAECAAAAAAAFIAAAACACAAA=',
    // https://learn.microsoft.com/en-us/windows/win32/secauthz/security-descriptor-string-format
    // 1
    'AQAUgCgBAAA4AQAAFAAAADAAAAACABwAAQAAAALAFAArAA0AAQEAAAAAAAEAAAAABAD4AAcAAAAAABQA' +
    'PwAPAAEBAAAAAAAFEgAAAAAAGAA/AA8AAQIAAAAAAAUgAAAAJAIAAAUALAADAAAAAQAAALp6lr/mDdAR' +
    'ooUAqgAwSeIBAgAAAAAABSAAAAAkAgAABQAsAAMAAAABAAAAnHqWv+YN0BGihQCqADBJ4gECAAAAAAAF' +
    'IAAAACQCAAAFACwAAwAAAAEAAAD/pKhtUg7QEaKGAKoAMEniAQIAAAAAAAUgAAAAJAIAAAUALAADAAAA' +
    'AQAAAKh6lr/mDdARooUAqgAwSeIBAgAAAAAABSAAAAAmAgAAAAAUABQAAgABAQAAAAAABQsAAAABAgAA' +
    'AAAABSAAAAAkAgAAAQEAAAAAAAUSAAAA',
    // 2
    'AQAEgDAAAABAAAAAAAAAABQAAAACABwAAQAAAAAAFAA/AA4QAQEAAAAAAAAAAAAAAQIAAAAAAAUgAAAA' +
    'JAIAAAEBAAAAAAAFEgAAAA==',
    // 3
    'AQAEgAAAAAAAAAAAAAAAABQAAAACABwAAQAAAAAAFAAAAAAQAQEAAAAAAAUHAAAA',
    // 4
    'AQAEgBQAAAAwAAAAAAAAAEwAAAABBQAAAAAABRUAAADRYBkx0xfaYIKt9RgBAgAAAQUAAAAAAAUVAAAA' +
    '0WAZMdMX2mCCrfUYAAIAAAIALAABAAAAAAAkAP8BHwABBQAAAAAABRUAAADRYBkx0xfaYIKt9RgAAgAA',
    // executable file access security descriptors, exported from several Windows VMs
    // 5 WinXP
    'AQAEgBQAAAAwAAAAAAAAAEwAAAABBQAAAAAABRUAAACCi6YoI/P2Y4qnMj/rAwAAAQUAAAAAAAUVAAAA' +
    'goumKCPz9mOKpzI/AQIAAAIAcAAEAAAAAAAYAP8BHwABAgAAAAAABSAAAAAgAgAAAAAUAP8BHwABAQAA' +
    'AAAABRIAAAAAACQA/wEfAAEFAAAAAAAFFQAAAIKLpigj8/ZjiqcyP+sDAAAAABgAqQASAAECAAAAAAAF' +
    'IAAAACECAAA=',
    // 6 Win7
    'AQAEhBQAAAAkAAAAAAAAAEAAAAABAgAAAAAABSAAAAAgAgAAAQUAAAAAAAUVAAAA0WAZMdMX2mCCrfUY' +
    'AQIAAAIAYAAEAAAAABAYAP8BHwABAgAAAAAABSAAAAAgAgAAABAUAP8BHwABAQAAAAAABRIAAAAAEBgA' +
    'qQASAAECAAAAAAAFIAAAACECAAAAEBQAvwETAAEBAAAAAAAFCwAAAA==',
    // 7 Win10
    'AQAEhBQAAAAwAAAAAAAAAEwAAAABBQAAAAAABRUAAACrWLmSPIyOxBiy0bzpAwAAAQUAAAAAAAUVAAA' +
    'Aq1i5kjyMjsQYstG8AQIAAAIAYAAEAAAAABAYAP8BHwABAgAAAAAABSAAAAAgAgAAABAUAP8BHwABAQ' +
    'AAAAAABRIAAAAAEBgAqQASAAECAAAAAAAFIAAAACECAAAAEBQAvwETAAEBAAAAAAAFCwAAAA==',
    // 8 Active Directory ntSecurityDescriptor field
    'AQAUjMQJAADgCQAAFAAAAIwAAAAEAHgAAgAAAAdaOAAgAAAAAwAAAL47Dv' +
    'Pwn9ERtgMAAPgDZ8Glepa/5g3QEaKFAKoAMEniAQEAAAAAAAEAAAAAB1o4ACAAAAADAAAAvzsO8' +
    '/Cf0RG2AwAA+ANnwaV6lr/mDdARooUAqgAwSeIBAQAAAAAAAQAAAAAEADgJMwAAAAEAJAD/AQ8A' +
    'AQUAAAAAAAUVAAAAb66a5T9f7J/5hle4VQQAAAUAOAAQAAAAAQAAAABCFkzAINARp2gAqgBuBSk' +
    'BBQAAAAAABRUAAABvrprlP1/sn/mGV7gpAgAABQA4ABAAAAABAAAAECAgX6V50BGQIADAT8LUzw' +
    'EFAAAAAAAFFQAAAG+umuU/X+yf+YZXuCkCAAAFADgAEAAAAAEAAABAwgq8qXnQEZAgAMBPwtTPA' +
    'QUAAAAAAAUVAAAAb66a5T9f7J/5hle4KQIAAAUAOAAQAAAAAQAAAPiIcAPhCtIRtCIAoMlo+TkB' +
    'BQAAAAAABRUAAABvrprlP1/sn/mGV7gpAgAABQA4ADAAAAABAAAAf3qWv+YN0BGihQCqADBJ4gE' +
    'FAAAAAAAFFQAAAG+umuU/X+yf+YZXuAUCAAAFACwAEAAAAAEAAAAdsalGrmBaQLfo/4pY1FbSAQ' +
    'IAAAAAAAUgAAAAMAIAAAUALAAwAAAAAQAAAByatm0ilNERrr0AAPgDZ8EBAgAAAAAABSAAAAAxA' +
    'gAABQAsADAAAAABAAAAYrwFWMm9KESl4oVqD0wYXgECAAAAAAAFIAAAADECAAAFACgAAAEAAAEA' +
    'AABTGnKrLx7QEZgZAKoAQFKbAQEAAAAAAAEAAAAABQAoAAABAAABAAAAUxpyqy8e0BGYGQCqAEB' +
    'SmwEBAAAAAAAFCgAAAAUAKAAAAQAAAQAAAFQacqsvHtARmBkAqgBAUpsBAQAAAAAABQoAAAAFAC' +
    'gAAAEAAAEAAABWGnKrLx7QEZgZAKoAQFKbAQEAAAAAAAUKAAAABQAoABAAAAABAAAAQi+6WaJ50' +
    'BGQIADAT8LTzwEBAAAAAAAFCwAAAAUAKAAQAAAAAQAAAFQBjeT4vNERhwIAwE+5YFABAQAAAAAA' +
    'BQsAAAAFACgAEAAAAAEAAACGuLV3SpTREa69AAD4A2fBAQEAAAAAAAULAAAABQAoABAAAAABAAA' +
    'As5VX5FWU0RGuvQAA+ANnwQEBAAAAAAAFCwAAAAUAKAAwAAAAAQAAAIa4tXdKlNERrr0AAPgDZ8' +
    'EBAQAAAAAABQoAAAAFACgAMAAAAAEAAACylVfkVZTREa69AAD4A2fBAQEAAAAAAAUKAAAABQAoA' +
    'DAAAAABAAAAs5VX5FWU0RGuvQAA+ANnwQEBAAAAAAAFCgAAAAAAJAD/AQ8AAQUAAAAAAAUVAAAA' +
    'b66a5T9f7J/5hle4AAIAAAAAGAD/AQ8AAQIAAAAAAAUgAAAAJAIAAAAAFAAAAAIAAQEAAAAAAAU' +
    'LAAAAAAAUAJQAAgABAQAAAAAABQoAAAAAABQA/wEPAAEBAAAAAAAFEgAAAAUaPAAQAAAAAwAAAA' +
    'BCFkzAINARp2gAqgBuBSkUzChINxS8RZsHrW8BXl8oAQIAAAAAAAUgAAAAKgIAAAUSPAAQAAAAA' +
    'wAAAABCFkzAINARp2gAqgBuBSm6epa/5g3QEaKFAKoAMEniAQIAAAAAAAUgAAAAKgIAAAUaPAAQ' +
    'AAAAAwAAABAgIF+ledARkCAAwE/C1M8UzChINxS8RZsHrW8BXl8oAQIAAAAAAAUgAAAAKgIAAAU' +
    'SPAAQAAAAAwAAABAgIF+ledARkCAAwE/C1M+6epa/5g3QEaKFAKoAMEniAQIAAAAAAAUgAAAAKg' +
    'IAAAUaPAAQAAAAAwAAAEDCCrypedARkCAAwE/C1M8UzChINxS8RZsHrW8BXl8oAQIAAAAAAAUgA' +
    'AAAKgIAAAUSPAAQAAAAAwAAAEDCCrypedARkCAAwE/C1M+6epa/5g3QEaKFAKoAMEniAQIAAAAA' +
    'AAUgAAAAKgIAAAUaPAAQAAAAAwAAAEIvulmiedARkCAAwE/C088UzChINxS8RZsHrW8BXl8oAQI' +
    'AAAAAAAUgAAAAKgIAAAUSPAAQAAAAAwAAAEIvulmiedARkCAAwE/C08+6epa/5g3QEaKFAKoAME' +
    'niAQIAAAAAAAUgAAAAKgIAAAUaPAAQAAAAAwAAAPiIcAPhCtIRtCIAoMlo+TkUzChINxS8RZsHr' +
    'W8BXl8oAQIAAAAAAAUgAAAAKgIAAAUSPAAQAAAAAwAAAPiIcAPhCtIRtCIAoMlo+Tm6epa/5g3Q' +
    'EaKFAKoAMEniAQIAAAAAAAUgAAAAKgIAAAUSOAAwAAAAAQAAAA/WR1uQYLJAnzcqTeiPMGMBBQA' +
    'AAAAABRUAAABvrprlP1/sn/mGV7gOAgAABRI4ADAAAAABAAAAD9ZHW5BgskCfNypN6I8wYwEFAA' +
    'AAAAAFFQAAAG+umuU/X+yf+YZXuA8CAAAFGjgACAAAAAMAAACmbQKbPA1cRovuUZnXFly6hnqWv' +
    '+YN0BGihQCqADBJ4gEBAAAAAAADAAAAAAUaOAAIAAAAAwAAAKZtAps8DVxGi+5RmdcWXLqGepa/' +
    '5g3QEaKFAKoAMEniAQEAAAAAAAUKAAAABRo4ABAAAAADAAAAbZ7Gt8cs0hGFTgCgyYP2CIZ6lr/' +
    'mDdARooUAqgAwSeIBAQAAAAAABQkAAAAFGjgAEAAAAAMAAABtnsa3xyzSEYVOAKDJg/YInHqWv+' +
    'YN0BGihQCqADBJ4gEBAAAAAAAFCQAAAAUSOAAQAAAAAwAAAG2exrfHLNIRhU4AoMmD9gi6epa/5' +
    'g3QEaKFAKoAMEniAQEAAAAAAAUJAAAABRo4ACAAAAADAAAAk3sb6khe1Ua8bE30/aeKNYZ6lr/m' +
    'DdARooUAqgAwSeIBAQAAAAAABQoAAAAFGiwAlAACAAIAAAAUzChINxS8RZsHrW8BXl8oAQIAAAA' +
    'AAAUgAAAAKgIAAAUaLACUAAIAAgAAAJx6lr/mDdARooUAqgAwSeIBAgAAAAAABSAAAAAqAgAABR' +
    'IsAJQAAgACAAAAunqWv+YN0BGihQCqADBJ4gECAAAAAAAFIAAAACoCAAAFEygAMAAAAAEAAADlw' +
    '3g/mve9RqC4nRgRbdx5AQEAAAAAAAUKAAAABRIoADABAAABAAAA3kfmkW/ZcEuVV9Y/9PPM2AEB' +
    'AAAAAAAFCgAAAAASJAD/AQ8AAQUAAAAAAAUVAAAAb66a5T9f7J/5hle4BwIAAAASGAAEAAAAAQI' +
    'AAAAAAAUgAAAAKgIAAAASGAC9AQ8AAQIAAAAAAAUgAAAAIAIAAAEFAAAAAAAFFQAAAG+umuU/X+' +
    'yf+YZXuAACAAABBQAAAAAABRUAAABvrprlP1/sn/mGV7gAAgAA',
    // 9 from a real Windows System
    'AQAEgBQAAAAwAAAAAAAAAEwAAAABBQAAAAAABRUAAACBHhhytsTTB48bQEJPBAAAAQUAAAAAAAU' +
    'VAAAAgR4YcrbE0wePG0BCAQIAAAIAWAADAAAAABAUAP8BHwABAQAAAAAABRIAAAAAEBgA/wEfAA' +
    'ECAAAAAAAFIAAAACACAAAAECQA/wEfAAEFAAAAAAAFFQAAAIEeGHK2xNMHjxtAQk8EAAA='
    );
  // the expected SDDL export of those binary buffers
  SD_TXT: array[0..high(SD_B64)] of RawUtf8 = (
    // 0
    'O:BAG:BAD:P(A;OICI;GXGR;;;BU)(A;OICI;GA;;;BA)(A;OICI;GA;;;SY)(A;OICI;GA;;;CO)' +
    'S:P(AU;FA;GR;;;WD)',
    // 1
    'O:AOG:SYD:(A;;KA;;;SY)(A;;KA;;;AO)(OA;;CCDC;bf967aba-0de6-11d0-a285-00aa003049e2' +
    ';;AO)(OA;;CCDC;bf967a9c-0de6-11d0-a285-00aa003049e2;;AO)(OA;;CCDC;6da8a4ff-0e52-' +
    '11d0-a286-00aa003049e2;;AO)(OA;;CCDC;bf967aa8-0de6-11d0-a285-00aa003049e2;;PO)(A' +
    ';;LCRPRC;;;AU)S:(AU;SAFA;CCDCSWWPSDWDWO;;;WD)',
    // 2
    'O:AOG:SYD:(A;;CCDCLCSWRPWPRCWDWOGA;;;S-1-0-0)',
    // 3
    'D:(A;;GA;;;AN)',
    // 4
    'O:S-1-5-21-823746769-1624905683-418753922-513' +
    'G:S-1-5-21-823746769-1624905683-418753922-512' +
    'D:(A;;FA;;;S-1-5-21-823746769-1624905683-418753922-512)',
    // 5
    'O:S-1-5-21-682003330-1677128483-1060284298-1003' +
    'G:S-1-5-21-682003330-1677128483-1060284298-513' +
    'D:(A;;FA;;;BA)(A;;FA;;;SY)' +
      '(A;;FA;;;S-1-5-21-682003330-1677128483-1060284298-1003)(A;;0x1200a9;;;BU)',
    // 6
    'O:BA' +
    'G:S-1-5-21-823746769-1624905683-418753922-513' +
    'D:AI(A;ID;FA;;;BA)(A;ID;FA;;;SY)(A;ID;0x1200a9;;;BU)(A;ID;0x1301bf;;;AU)',
    // 7
    'O:S-1-5-21-2461620395-3297676348-3167859224-1001' +
    'G:S-1-5-21-2461620395-3297676348-3167859224-513' +
    'D:AI(A;ID;FA;;;BA)(A;ID;FA;;;SY)(A;ID;0x1200a9;;;BU)(A;ID;0x1301bf;;;AU)',
    //8
    'O:S-1-5-21-3852119663-2683068223-3092743929-512' +
    'G:S-1-5-21-3852119663-2683068223-3092743929-512' +
    'D:AI(D;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3852119663-2683068223-3092743929-1109)' +
    '(OA;;RP;4c164200-20c0-11d0-a768-00aa006e0529;;S-1-5-21-3852119663-2683068223-3092743929-553)' +
    '(OA;;RP;5f202010-79a5-11d0-9020-00c04fc2d4cf;;S-1-5-21-3852119663-2683068223-3092743929-553)' +
    '(OA;;RP;bc0ac240-79a9-11d0-9020-00c04fc2d4cf;;S-1-5-21-3852119663-2683068223-3092743929-553)' +
    '(OA;;RP;037088f8-0ae1-11d2-b422-00a0c968f939;;S-1-5-21-3852119663-2683068223-3092743929-553)' +
    '(OA;;RPWP;bf967a7f-0de6-11d0-a285-00aa003049e2;;S-1-5-21-3852119663-2683068223-3092743929-517)' +
    '(OA;;RP;46a9b11d-60ae-405a-b7e8-ff8a58d456d2;;S-1-5-32-560)' +
    '(OA;;RPWP;6db69a1c-9422-11d1-aebd-0000f80367c1;;S-1-5-32-561)' +
    '(OA;;RPWP;5805bc62-bdc9-4428-a5e2-856a0f4c185e;;S-1-5-32-561)' +
    '(OA;;CR;ab721a53-1e2f-11d0-9819-00aa0040529b;;WD)' +
    '(OA;;CR;ab721a53-1e2f-11d0-9819-00aa0040529b;;PS)' +
    '(OA;;CR;ab721a54-1e2f-11d0-9819-00aa0040529b;;PS)' +
    '(OA;;CR;ab721a56-1e2f-11d0-9819-00aa0040529b;;PS)' +
    '(OA;;RP;59ba2f42-79a2-11d0-9020-00c04fc2d3cf;;AU)' +
    '(OA;;RP;e48d0154-bcf8-11d1-8702-00c04fb96050;;AU)' +
    '(OA;;RP;77b5b886-944a-11d1-aebd-0000f80367c1;;AU)' +
    '(OA;;RP;e45795b3-9455-11d1-aebd-0000f80367c1;;AU)' +
    '(OA;;RPWP;77b5b886-944a-11d1-aebd-0000f80367c1;;PS)' +
    '(OA;;RPWP;e45795b2-9455-11d1-aebd-0000f80367c1;;PS)' +
    '(OA;;RPWP;e45795b3-9455-11d1-aebd-0000f80367c1;;PS)' +
    '(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3852119663-2683068223-3092743929-512)' +
    '(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;AO)' +
    '(A;;RC;;;AU)(A;;LCRPLORC;;;PS)' +
    '(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;SY)' +
    '(OA;CIIOID;RP;4c164200-20c0-11d0-a768-00aa006e0529;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
    '(OA;CIID;RP;4c164200-20c0-11d0-a768-00aa006e0529;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
    '(OA;CIIOID;RP;5f202010-79a5-11d0-9020-00c04fc2d4cf;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
    '(OA;CIID;RP;5f202010-79a5-11d0-9020-00c04fc2d4cf;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
    '(OA;CIIOID;RP;bc0ac240-79a9-11d0-9020-00c04fc2d4cf;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
    '(OA;CIID;RP;bc0ac240-79a9-11d0-9020-00c04fc2d4cf;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
    '(OA;CIIOID;RP;59ba2f42-79a2-11d0-9020-00c04fc2d3cf;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
    '(OA;CIID;RP;59ba2f42-79a2-11d0-9020-00c04fc2d3cf;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
    '(OA;CIIOID;RP;037088f8-0ae1-11d2-b422-00a0c968f939;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
    '(OA;CIID;RP;037088f8-0ae1-11d2-b422-00a0c968f939;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
    '(OA;CIID;RPWP;5b47d60f-6090-40b2-9f37-2a4de88f3063;;S-1-5-21-3852119663-2683068223-3092743929-526)' +
    '(OA;CIID;RPWP;5b47d60f-6090-40b2-9f37-2a4de88f3063;;S-1-5-21-3852119663-2683068223-3092743929-527)' +
    '(OA;CIIOID;SW;9b026da6-0d3c-465c-8bee-5199d7165cba;bf967a86-0de6-11d0-a285-00aa003049e2;CO)' +
    '(OA;CIIOID;SW;9b026da6-0d3c-465c-8bee-5199d7165cba;bf967a86-0de6-11d0-a285-00aa003049e2;PS)' +
    '(OA;CIIOID;RP;b7c69e6d-2cc7-11d2-854e-00a0c983f608;bf967a86-0de6-11d0-a285-00aa003049e2;ED)' +
    '(OA;CIIOID;RP;b7c69e6d-2cc7-11d2-854e-00a0c983f608;bf967a9c-0de6-11d0-a285-00aa003049e2;ED)' +
    '(OA;CIID;RP;b7c69e6d-2cc7-11d2-854e-00a0c983f608;bf967aba-0de6-11d0-a285-00aa003049e2;ED)' +
    '(OA;CIIOID;WP;ea1b7b93-5e48-46d5-bc6c-4df4fda78a35;bf967a86-0de6-11d0-a285-00aa003049e2;PS)' +
    '(OA;CIIOID;LCRPLORC;;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
    '(OA;CIIOID;LCRPLORC;;bf967a9c-0de6-11d0-a285-00aa003049e2;RU)' +
    '(OA;CIID;LCRPLORC;;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
    '(OA;OICIID;RPWP;3f78c3e5-f79a-46bd-a0b8-9d18116ddc79;;PS)' +
    '(OA;CIID;RPWPCR;91e647de-d96f-4b70-9557-d63ff4f3ccd8;;PS)' +
    '(A;CIID;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3852119663-2683068223-3092743929-519)' +
    '(A;CIID;LC;;;RU)(A;CIID;CCLCSWRPWPLOCRSDRCWDWO;;;BA)' +
    'S:AI(OU;CIIOIDSA;WP;f30e3bbe-9ff0-11d1-b603-0000f80367c1;bf967aa5-0de6-11d0-a285-00aa003049e2;WD)' +
    '(OU;CIIOIDSA;WP;f30e3bbf-9ff0-11d1-b603-0000f80367c1;bf967aa5-0de6-11d0-a285-00aa003049e2;WD)',
    // 9
    'O:S-1-5-21-1914183297-131318966-1111497615-1103G:S-1-5-21-1914183297-131318966-1111497615-513D:' +
    '(A;ID;FA;;;SY)(A;ID;FA;;;BA)(A;ID;FA;;;S-1-5-21-1914183297-131318966-1111497615-1103)'
    );
  // the Domain SID to be used for RID recognition
  DOM_TXT: array[4..high(SD_B64)] of RawUtf8 = (
    'S-1-5-21-823746769-1624905683-418753922',    // 4
    'S-1-5-21-682003330-1677128483-1060284298',   // 5
    'S-1-5-21-823746769-1624905683-418753922',    // 6
    'S-1-5-21-2461620395-3297676348-3167859224',  // 7
    'S-1-5-21-3852119663-2683068223-3092743929',  // 8
    'S-1-5-21-1914183297-131318966-1111497615');  // 9
  // the SDDL with proper RID recognition
  RID_TXT: array[4..high(SD_B64)] of RawUtf8 = (
    'O:DUG:DAD:(A;;FA;;;DA)',
    'O:S-1-5-21-682003330-1677128483-1060284298-1003G:DUD:(A;;FA;;;BA)(A;;FA;;;SY)' +
      '(A;;FA;;;S-1-5-21-682003330-1677128483-1060284298-1003)(A;;0x1200a9;;;BU)',
    'O:BAG:DUD:AI(A;ID;FA;;;BA)(A;ID;FA;;;SY)(A;ID;0x1200a9;;;BU)(A;ID;0x1301bf;;;AU)',
    'O:S-1-5-21-2461620395-3297676348-3167859224-1001G:DUD:AI(A;ID;FA;;;BA)' +
      '(A;ID;FA;;;SY)(A;ID;0x1200a9;;;BU)(A;ID;0x1301bf;;;AU)',
    'O:DAG:DAD:AI(D;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3852119663-2683068223-3092743929-1109)' +
      '(OA;;RP;4c164200-20c0-11d0-a768-00aa006e0529;;RS)' +
      '(OA;;RP;5f202010-79a5-11d0-9020-00c04fc2d4cf;;RS)' +
      '(OA;;RP;bc0ac240-79a9-11d0-9020-00c04fc2d4cf;;RS)' +
      '(OA;;RP;037088f8-0ae1-11d2-b422-00a0c968f939;;RS)' +
      '(OA;;RPWP;bf967a7f-0de6-11d0-a285-00aa003049e2;;CA)' +
      '(OA;;RP;46a9b11d-60ae-405a-b7e8-ff8a58d456d2;;S-1-5-32-560)' +
      '(OA;;RPWP;6db69a1c-9422-11d1-aebd-0000f80367c1;;S-1-5-32-561)' +
      '(OA;;RPWP;5805bc62-bdc9-4428-a5e2-856a0f4c185e;;S-1-5-32-561)' +
      '(OA;;CR;ab721a53-1e2f-11d0-9819-00aa0040529b;;WD)' +
      '(OA;;CR;ab721a53-1e2f-11d0-9819-00aa0040529b;;PS)' +
      '(OA;;CR;ab721a54-1e2f-11d0-9819-00aa0040529b;;PS)' +
      '(OA;;CR;ab721a56-1e2f-11d0-9819-00aa0040529b;;PS)' +
      '(OA;;RP;59ba2f42-79a2-11d0-9020-00c04fc2d3cf;;AU)' +
      '(OA;;RP;e48d0154-bcf8-11d1-8702-00c04fb96050;;AU)' +
      '(OA;;RP;77b5b886-944a-11d1-aebd-0000f80367c1;;AU)' +
      '(OA;;RP;e45795b3-9455-11d1-aebd-0000f80367c1;;AU)' +
      '(OA;;RPWP;77b5b886-944a-11d1-aebd-0000f80367c1;;PS)' +
      '(OA;;RPWP;e45795b2-9455-11d1-aebd-0000f80367c1;;PS)' +
      '(OA;;RPWP;e45795b3-9455-11d1-aebd-0000f80367c1;;PS)' +
      '(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;DA)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;AO)' +
      '(A;;RC;;;AU)(A;;LCRPLORC;;;PS)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;SY)' +
      '(OA;CIIOID;RP;4c164200-20c0-11d0-a768-00aa006e0529;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
      '(OA;CIID;RP;4c164200-20c0-11d0-a768-00aa006e0529;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
      '(OA;CIIOID;RP;5f202010-79a5-11d0-9020-00c04fc2d4cf;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
      '(OA;CIID;RP;5f202010-79a5-11d0-9020-00c04fc2d4cf;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
      '(OA;CIIOID;RP;bc0ac240-79a9-11d0-9020-00c04fc2d4cf;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
      '(OA;CIID;RP;bc0ac240-79a9-11d0-9020-00c04fc2d4cf;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
      '(OA;CIIOID;RP;59ba2f42-79a2-11d0-9020-00c04fc2d3cf;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
      '(OA;CIID;RP;59ba2f42-79a2-11d0-9020-00c04fc2d3cf;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
      '(OA;CIIOID;RP;037088f8-0ae1-11d2-b422-00a0c968f939;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
      '(OA;CIID;RP;037088f8-0ae1-11d2-b422-00a0c968f939;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
      '(OA;CIID;RPWP;5b47d60f-6090-40b2-9f37-2a4de88f3063;;KA)' +
      '(OA;CIID;RPWP;5b47d60f-6090-40b2-9f37-2a4de88f3063;;EK)' +
      '(OA;CIIOID;SW;9b026da6-0d3c-465c-8bee-5199d7165cba;bf967a86-0de6-11d0-a285-00aa003049e2;CO)' +
      '(OA;CIIOID;SW;9b026da6-0d3c-465c-8bee-5199d7165cba;bf967a86-0de6-11d0-a285-00aa003049e2;PS)' +
      '(OA;CIIOID;RP;b7c69e6d-2cc7-11d2-854e-00a0c983f608;bf967a86-0de6-11d0-a285-00aa003049e2;ED)' +
      '(OA;CIIOID;RP;b7c69e6d-2cc7-11d2-854e-00a0c983f608;bf967a9c-0de6-11d0-a285-00aa003049e2;ED)' +
      '(OA;CIID;RP;b7c69e6d-2cc7-11d2-854e-00a0c983f608;bf967aba-0de6-11d0-a285-00aa003049e2;ED)' +
      '(OA;CIIOID;WP;ea1b7b93-5e48-46d5-bc6c-4df4fda78a35;bf967a86-0de6-11d0-a285-00aa003049e2;PS)' +
      '(OA;CIIOID;LCRPLORC;;4828cc14-1437-45bc-9b07-ad6f015e5f28;RU)' +
      '(OA;CIIOID;LCRPLORC;;bf967a9c-0de6-11d0-a285-00aa003049e2;RU)' +
      '(OA;CIID;LCRPLORC;;bf967aba-0de6-11d0-a285-00aa003049e2;RU)' +
      '(OA;OICIID;RPWP;3f78c3e5-f79a-46bd-a0b8-9d18116ddc79;;PS)' +
      '(OA;CIID;RPWPCR;91e647de-d96f-4b70-9557-d63ff4f3ccd8;;PS)' +
      '(A;CIID;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;EA)(A;CIID;LC;;;RU)' +
      '(A;CIID;CCLCSWRPWPLOCRSDRCWDWO;;;BA)' +
      'S:AI(OU;CIIOIDSA;WP;f30e3bbe-9ff0-11d1-b603-0000f80367c1;bf967aa5-0de6-11d0-a285-00aa003049e2;WD)' +
      '(OU;CIIOIDSA;WP;f30e3bbf-9ff0-11d1-b603-0000f80367c1;bf967aa5-0de6-11d0-a285-00aa003049e2;WD)',
      'O:S-1-5-21-1914183297-131318966-1111497615-1103G:DUD:(A;ID;FA;;;SY)(A;ID;FA;;;BA)' +
      '(A;ID;FA;;;S-1-5-21-1914183297-131318966-1111497615-1103)');
  // [MS-DTYP] 2.4.4.17.9 Examples: Conditional Expression Binary Representation
  ARTX_HEX: array[0..2] of RawUtf8 = (
    '61727478f80a0000005400690074006c00650010040000005600500080000000',
    '61727478f91200000073006d006100720074006300610072006400' +
    '040100000000000000030280fb0e0000006d0061006e006100670065006400' +
    '040100000000000000030280a1fa080000006400650070007400' +
    '5018000000100a000000530061006c006500730010040000004800520088a000',
    '61727478f91c00000063006c0065006100720061006e00630065004c006500760065006c00' +
    'fa220000007200650071007500690072006500640043006c0065006100720061006e0063006500' +
    '85501500000051100000000102000000000005200000002002000089a1000000');
  ARTX_TXT: array[0..high(ARTX_HEX)] of RawUtf8 = (
    '(Title=="VP")',
    '(((@User.smartcard==1) || (@Device.managed==1)) && (@Resource.dept Any_of{"Sales","HR"}))',
    '((@User.clearanceLevel>=@Resource.requiredClearance) || (Member_of{SID(BA)}))');
  // some ACE conditional expressions
  COND_TXT: array[0..2] of RawUtf8 = (
    'D:(XA;;FX;;;WD;(@User.Title=="PM" && (@User.Division=="Finance" || ' +
      '@User.Division ==" Sales")))',
    'D:(XA;;FX;;;WD;(@User.Project Any_of @Resource.Project))(A;ID;FA;;;SY)',
    'D:(XA;;FR;;;WD;(Member_of{SID(S-1-5-21-111-222-333-500),SID(BO)} && ' +
      '@Device.Bitlocker))(A;ID;FA;;;SY)');
  // our SDDL output always add parenthesis on binary expressions
  COND_EXP: array[0..2] of RawUtf8 = (
    'D:(XA;;FX;;;WD;((@User.Title=="PM") && ((@User.Division=="Finance") || ' +
      '(@User.Division==" Sales"))))',
    'D:(XA;;FX;;;WD;(@User.Project Any_of @Resource.Project))(A;ID;FA;;;SY)',
    'D:(XA;;FR;;;WD;((Member_of{SID(S-1-5-21-111-222-333-500),SID(BO)}) && '+
      '@Device.Bitlocker))(A;ID;FA;;;SY)');

procedure TTestCoreBase._SDDL;
var
  i, j: PtrInt;
  c: TSecControls;
  k, k2: TWellKnownSid;
  r, r2: TWellKnownRid;
  bin, saved: RawSecurityDescriptor;
  u, u2, dom, dom2, json: RawUtf8;
  all: TRawUtf8DynArray;
  n: integer;
  domsid: RawSid;
  sd, sd2: TSecurityDescriptor;
  bintree: TAceBinaryTree;
  sddltree: TAceTextTree;
  atp: TAceTextParse;
  a: TAdsKnownAttribute;
  p: PUtf8Char;
begin
  // validate internal structures and types
  CheckEqual(KnownSidToSddl(wksNull), '');
  CheckEqual(KnownSidToSddl(wksWorld), 'WD');
  CheckEqual(KnownSidToSddl(wksLocal), '');
  CheckEqual(KnownSidToSddl(wksCreatorOwnerRights), 'OW');
  CheckEqual(KnownSidToSddl(wksDialup), '');
  CheckEqual(KnownSidToSddl(wksNetwork), 'NU');
  CheckEqual(KnownSidToSddl(wksSelf), 'PS');
  CheckEqual(KnownSidToSddl(wksLocalSystem), 'SY');
  CheckEqual(KnownSidToSddl(wksBuiltinAdministrators), 'BA');
  CheckEqual(KnownSidToSddl(wksBuiltinNetworkConfigurationOperators), 'NO');
  CheckEqual(KnownSidToSddl(wksBuiltinPerfLoggingUsers), 'LU');
  CheckEqual(KnownSidToSddl(wksBuiltinEventLogReadersGroup), 'ER');
  CheckEqual(KnownSidToSddl(wksBuiltinAccessControlAssistanceOperators), 'AA');
  CheckEqual(KnownSidToSddl(wksBuiltinWriteRestrictedCode), 'WR');
  CheckEqual(KnownSidToSddl(wksBuiltinUserModeDriver), 'UD');
  CheckEqual(KnownSidToSddl(wksBuiltinAnyPackage), 'AC');
  CheckEqual(KnownSidToSddl(wksAuthenticationServiceAsserted), 'SS');
  CheckEqual(KnownSidToSddl(wksCapabilityInternetClient), '');
  CheckEqual(KnownSidToSddl(high(TWellKnownSid)), '');
  CheckEqual(KnownRidToSddl(wrkUserModeHwOperator), 'HO');
  n := 0;
  for k := low(k) to high(k) do
  begin
    u := KnownSidToSddl(k);
    Check((u <> '') = (k in wksWithSddl));
    Check(SddlToKnownSid(u, k2) = (u <> ''));
    if u = '' then
      continue;
    CheckUtf8(k2 = k, u);
    CheckUtf8(not SddlToKnownRid(u, r2), u);
    AddRawUtf8(all, n, FormatUtf8('% = %', [u, ToText(k)^]));
  end;
  for r := low(r) to high(r) do
  begin
    u := KnownRidToSddl(r);
    Check((u <> '') = (r in wkrWithSddl));
    Check(SddlToKnownRid(u, r2) = (u <> ''));
    if u = '' then
      continue;
    CheckUtf8(r2 = r, u);
    CheckUtf8(not SddlToKnownSid(u, k2), u);
    AddRawUtf8(all, n, FormatUtf8('% = %', [u, ToText(r)^]));
  end;
  DynArrayFakeLength(all, n);
  QuickSortRawUtf8(all, n);
  u := RawUtf8ArrayToCsv(all, #10); //ConsoleWrite(u);
  CheckHash(u, $30EF8B6D, 'sid sddl list');
  CheckEqual(SizeOf(TSid)    and 3, 0, 'TSid    DWORD-aligned');
  CheckEqual(SizeOf(TRawSD)  and 3, 0, 'TRawSD  DWORD-aligned');
  CheckEqual(SizeOf(TRawAcl) and 3, 0, 'TRawAcl DWORD-aligned');
  CheckEqual(SizeOf(TRawAce) and 3, 0, 'TRawAce DWORD-aligned');
  CheckEqual(ord(scDaclAutoInheritReq), 8);
  CheckEqual(ord(scSelfRelative), 15);
  c := [scSelfRelative];
  CheckEqual(PWord(@c)^, $8000);
  CheckEqual(ord(samGenericRead), 31, 'sam');
  dom := 'S-1-5-21-823746769-1624905683-418753922';
  CheckEqual(KnownSidToText(wkrUserAdmin, dom), dom + '-500');
  CheckEqual(KnownSidToText(wrkGroupRasServers, dom), dom + '-553');
  Check(sd.FromText(RID_TXT[9]) = atpSuccess, 'guess domain from O:');
  CheckEqual(sd.ToText, SD_TXT[9]);
  bin := Base64ToBin('AQAEhBQAAAAkAAAAAAAAAEAAAAABAgAAAAAABSAAAAAgAgAAAQUAAAAAA' +
    'AUVAAAA/ZxDLSkUVWPZmlbYAQIAAAMAoAAFAAAAABAUAP8BHwABAQAAAAAABRIAAAAAEBgA/' +
    'wEfAAECAAAAAAAFIAAAACACAAAAECQAqQESAAEFAAAAAAAFFQAAAP2cQy0pFFVj2ZpW2EdYB' +
    'AAAECQA/wESAAEFAAAAAAAFFQAAAP2cQy0pFFVj2ZpW2JIfBwAAECQA/wEfAAEFAAAAAAAFF' +
    'QAAAKu8Fu9mK3SFkRuTS9XrAQA=');
  Check(sd.FromBinary(bin), 'tolerate acl rev3');
  u := sd.ToText('');
  CheckEqual(u,
    'O:BAG:S-1-5-21-759405821-1666520105-3629554393-513D:AI(A;ID;FA;;;SY)(A;ID;FA;;;B' +
    'A)(A;ID;0x1201a9;;;S-1-5-21-759405821-1666520105-3629554393-284743)(A;ID;0x1201f' +
    'f;;;S-1-5-21-759405821-1666520105-3629554393-466834)(A;ID;FA;;;S-1-5-21-40112447' +
    '15-2238983014-1267932049-125909)');
  {$ifdef OSWINDOWS}
  Check(CryptoApi.SecurityDescriptorToText(pointer(bin), u2), 'winapi aclv3');
  CheckEqual(u, u2);
  {$endif OSWINDOWS}
  u := sd.ToText('S-1-5-21-759405821-1666520105-3629554393'); // recognize G:DU
  CheckEqual(u, 'O:BAG:DUD:AI(A;ID;FA;;;SY)(A;ID;FA;;;BA)(A;ID;0x1201a9;;;' +
    'S-1-5-21-759405821-1666520105-3629554393-284743)(A;ID;0x1201ff;;;' +
    'S-1-5-21-759405821-1666520105-3629554393-466834)(A;ID;FA;;;' +
    'S-1-5-21-4011244715-2238983014-1267932049-125909)');
  // validate against some reference binary material
  for i := 0 to high(SD_B64) do
  begin
    // high-level IsValidSecurityDescriptor() and SecurityDescriptorToText()
    bin := Base64ToBin(SD_B64[i]);
    Check(bin <> '', 'b64');
    Check(IsValidSecurityDescriptor(pointer(bin), length(bin)), 'bin');
    Check(SecurityDescriptorToText(bin, u), 'sdtt1');
    CheckEqual(u, SD_TXT[i]);
    {$ifdef OSWINDOWS} // validate against the OS API
    if not (wsWine in WindowsSpecs) then
    begin
      Check(CryptoApi.SecurityDescriptorToText(pointer(bin), u), 'winapi1');
      CheckEqual(u, SD_TXT[i], 'winapi2');
    end;
    {$endif OSWINDOWS}
    // TSecurityDescriptor binary load and export as SDDL or binary
    sd.Clear;
    CheckEqual(sd.ToText, '', 'clear');
    Check(sd.Flags = [scSelfRelative]);
    Check(sd.FromBinary(bin));
    Check(sd.Dacl <> nil, 'dacl');
    Check(scSelfRelative in sd.Flags);
    Check((sd.Sacl = nil) = (i in [2 .. 7, 9]) , 'sacl');
    CheckEqual(sd.ToText, SD_TXT[i], 'ToText');
    Check(sd.Dacl[0].Opaque = '');
    Check(sd.Dacl[0].ConditionalExpression = '');
    saved := sd.ToBinary;
    Check(IsValidSecurityDescriptor(pointer(saved), length(saved)), 'saved');
    Check(SecurityDescriptorToText(saved, u), 'sdtt2');
    CheckEqual(u, SD_TXT[i]);
    {$ifdef OSWINDOWS}
    if not (wsWine in WindowsSpecs) then
    begin
      Check(CryptoApi.SecurityDescriptorToText(pointer(saved), u), 'winapi3');
      CheckEqual(u, SD_TXT[i], 'winapi4');
    end;
    {$endif OSWINDOWS}
    if i in [1, 2, 8] then
      // serialization offsets are not consistent between XP or later
      Check(saved = bin, 'ToBinary');
    // TSecurityDescriptor load from SDDL into another instance
    Check(sd2.FromText('') = atpMissingExpression);
    CheckEqual(sd2.ToText, '', 'fromnil');
    Check(not sd.IsEqual(sd2));
    Check(sd2.FromText(u) = atpSuccess, 'fromu');
    CheckEqual(sd2.ToText, u, 'fromutou');
    Check(sd.IsEqual(sd2));
    Check(sd2.IsEqual(sd));
    bin := sd2.ToBinary;
    Check(bin = saved, 'saved2');
    // TSecurityDescriptor JSON
    json := SecurityDescriptorToJson(sd);
    Check(IsValidJson(json), 'savejson');
    sd2.Clear;
    Check(not sd.IsEqual(sd2));
    Check(SecurityDescriptorFromJson(json, sd2), 'loadjson');
    Check(sd.IsEqual(sd2));
    Check(scSelfRelative in sd2.Flags);
    // TSecurityDescriptor.Add and Delete high-level methods
    Check(scDaclPresent in sd.Flags);
    if sd.Sacl <> nil then
    begin
      Check(scSaclPresent in sd.Flags);
      continue;
    end;
    Check(not (scSaclPresent in sd.Flags));
    Check(sd.Add('') = nil);
    Check(sd.IsEqual(sd2));
    Check(sd.Add('(toto;;;;)') = nil);
    Check(sd.Add('(D;;;;;SY)') = nil);
    Check(sd.Add('(A;;;;;SY)') = nil);
    Check(sd.IsEqual(sd2));
    Check(sd.Add('(A;;KA;;;SY)') <> nil);
    Check(not sd.IsEqual(sd2));
    CheckEqual(sd.ToText, u + '(A;;KA;;;SY)');
    Check(sd.Add(satCallbackAudit, 'AU', 'KR') <> nil);
    CheckEqual(sd.ToText, u + '(A;;KA;;;SY)(XU;;KR;;;AU)');
    sd.Delete(100);
    sd.Delete(length(sd.Dacl) - 2);
    CheckEqual(sd.ToText, u + '(XU;;KR;;;AU)');
    Check(not sd.IsEqual(sd2));
    sd.Delete(length(sd.Dacl) - 1);
    CheckEqual(sd.ToText, u);
    Check(sd.IsEqual(sd2));
    Check(sd.ToBinary = saved);
    Check(scDaclPresent in sd.Flags);
    for j := 1 to length(sd.Dacl) do
      sd.Delete(0);
    Check(sd.Dacl = nil);
    Check(not (scDaclPresent in sd.Flags));
    Check(sd.Add('(A;;KA;;;SY)') <> nil);
    Check(PosEx('(A;;KA;;;SY)', sd.ToText) <> 0);
    Check(scDaclPresent in sd.Flags);
  end;
  // validate parsing RID in text (e.g. DU,DA)
  atp := sd.FromText(RID_TXT[4]);
  Check(atp = atpInvalidOwner, 'dom0');
  Check(not sd.IsEqual(sd2));
  atp := sd.FromText(' O: DU G: DA D: ( A ; ; FA ; ; ; DA ) ', dom);
  Check(atp = atpSuccess, 'dom1');
  Check(not sd.IsEqual(sd2));
  u := sd.ToText;
  CheckEqual(u, FormatUtf8('O:%-513G:%-512D:(A;;FA;;;%-512)', [dom, dom, dom]));
  CheckEqual(u, SD_TXT[4], 'domasref');
  u := sd.ToText(dom);
  CheckEqual(u, RID_TXT[4], 'rid');
  saved := sd.ToBinary;
  CheckHash(saved, $F1B78A68, 'dombin');
  Check(IsValidSecurityDescriptor(pointer(saved), length(saved)), 'saveddom');
  Check(TryDomainTextToSid(dom, domsid));
  CheckEqual(sd.Dacl[0].SidText, dom + '-512');
  CheckEqual(sd.Dacl[0].SidText(pointer(domsid)), 'DA');
  CheckEqual(sd.Dacl[0].MaskText, 'FA');
  Check(sd.Dacl[0].SidParse('DU', pointer(domsid)));
  CheckEqual(sd.Dacl[0].SidText, dom + '-513');
  CheckEqual(sd.Dacl[0].SidText(pointer(domsid)), 'DU');
  dom2 := 'S-1-5-21-237846769-6124905683-148753929';
  Check(sd.FromBinary(saved));
  Check(sd2.FromBinary(saved));
  Check(sd.IsEqual(sd2));
  u := sd.ToText(dom);
  CheckEqual(u, RID_TXT[4], 'domsaved');
  Check(sd.Modified = []);
  CheckEqual(sd.ReplaceDomain(dom, dom2), 3);
  Check(sd.Modified = [sdiOwner, sdiGroup, sdiDacl]);
  sd.Modified := [];
  Check(not sd.IsEqual(sd2));
  u := sd.ToText;
  CheckNotEqual(u, SD_TXT[4], 'dom2a');
  u2 := sd.ToText(dom);
  CheckEqual(u, u2, 'dom2b');
  u := sd.ToText(dom2);
  CheckEqual(u, RID_TXT[4], 'dom2c');
  sd.Modified := [];
  CheckEqual(sd.ReplaceDomain(dom, dom2), 0);
  Check(sd.Modified = []);
  u := sd.ToText(dom);
  CheckEqual(u, u2, 'dom2d');
  u := sd.ToText(dom2);
  CheckEqual(u, RID_TXT[4], 'dom2e');
  Check(not sd.IsEqual(sd2));
  CheckEqual(sd.ReplaceDomain(dom2, dom), 3);
  Check(sd.Modified = [sdiOwner, sdiGroup, sdiDacl]);
  u := sd.ToText(dom);
  CheckNotEqual(u, SD_TXT[4], 'dom2f');
  CheckEqual(u, RID_TXT[4], 'dom2g');
  Check(sd.IsEqual(sd2), 'dom2h');
  sd.Modified := [];
  CheckEqual(sd.ReplaceDomain(dom2, dom), 0);
  Check(sd.Modified = []);
  Check(sd.IsEqual(sd2), 'dom2i');
  CheckEqual(sd.ReplaceSid(dom + '-512', dom + '-500'), 2, 'dom3a');
  Check(sd.Modified = [sdiGroup, sdiDacl]);
  u := sd.ToText(dom);
  CheckEqual(u, 'O:DUG:LAD:(A;;FA;;;LA)');
  Check(not sd.IsEqual(sd2), 'dom3c');
  sd.Modified := [];
  CheckEqual(sd.ReplaceSid(dom + '-501', dom + '-512'), 0, 'dom3d1');
  Check(sd.Modified = []);
  CheckEqual(sd.ReplaceSid(dom + '-500', dom + '-512'), 2, 'dom3d2');
  Check(sd.Modified = [sdiGroup, sdiDacl]);
  u := sd.ToText(dom);
  CheckEqual(u, RID_TXT[4]);
  Check(sd.IsEqual(sd2), 'dom3f');
  // RID reference material with several domains
  for i := low(DOM_TXT) to high(DOM_TXT) do
  begin
    atp := sd.FromText(SD_TXT[i]);
    Check(atp = atpSuccess);
    u := sd.ToText(DOM_TXT[i]);
    CheckEqual(u, RID_TXT[i]);
    Check(TryDomainTextToSid(DOM_TXT[i], domsid));
    p := pointer(u);
    atp := sd2.FromText(p, pointer(domsid));
    Check(atp = atpSuccess);
    Check(sd.IsEqual(sd2));
  end;
  // custom UUID values in SDDL text
  for a := low(a) to high(a) do
  begin
    Check(UuidToKnownAttribute(ATTR_UUID[a]) = a); // O(log(n)) binary search
    u := ATTR_TXT[a];
    CheckUtf8(TextToKnownAttribute(pointer(u), length(u)) = a, u);
  end;
  Check(sd.FromText(SD_TXT[1]) = atpSuccess, 'uuid');
  u := sd.ToText;
  CheckEqual(u, SD_TXT[1]);
  u := sd.ToText('', AppendShortKnownUuid);
  CheckEqual(u, 'O:AOG:SYD:(A;;KA;;;SY)(A;;KA;;;AO)(OA;;CCDC;User;;AO)' +
    '(OA;;CCDC;Group;;AO)(OA;;CCDC;6da8a4ff-0e52-11d0-a286-00aa003049e2;;AO)' +
    '(OA;;CCDC;Print-Queue;;PO)(A;;LCRPRC;;;AU)S:(AU;SAFA;CCDCSWWPSDWDWO;;;WD)');
  atp := sd2.FromText(u);
  Check(atp = atpInvalidUuid, 'uuid1');
  Check(not sd.IsEqual(sd2), 'uuid2');
  Check(sd2.FromText(u, '', @ShortToKnownUuid) = atpSuccess, 'uuid3');
  Check(sd.IsEqual(sd2), 'uuid4');
  // validate conditional ACEs reference binary
  for i := 0 to high(ARTX_HEX) do
  begin
    bin := mormot.core.text.HexToBin(ARTX_HEX[i]);
    Check(bin <> '');
    Check(bintree.FromBinary(bin));
    Check(bintree.Count > 0);
    u := bintree.ToText;
    CheckEqual(u, ARTX_TXT[i], 'artx1');
    atp := sddltree.FromText(u);
    Check(atp = atpSuccess);
    saved := sddltree.ToBinary;
    CheckEqual(length(saved), length(bin), '2binl');
    Check(saved = bin, '2bin');
    Check(bintree.FromBinary(saved), 'artx2');
    Check(bintree.Count > 0);
    u := bintree.ToText;
    CheckEqual(u, ARTX_TXT[i], 'artx3');
  end;
  // validate conditional ACEs
  for i := 0 to high(COND_TXT) do
  begin
    atp := sd.FromText(COND_TXT[i]);
    Check(atp = atpSuccess);
    Check(length(sd.Dacl) in [1, 2]);
    CheckEqual(length(sd.Sacl), 0);
    Check(sd.Dacl[0].AceType = satCallbackAccessAllowed);
    if Check(sd.Dacl[0].Opaque <> '') then
    begin
      u := sd.Dacl[0].ConditionalExpression;
      Check(u <> '');
      Check(u[1] = '(');
      Check(u[length(u)] = ')');
    end;
    u := sd.ToText;
    CheckEqual(u, COND_EXP[i]);
    saved := sd.ToBinary;
    Check(saved <> '');
    Check(IsValidSecurityDescriptor(pointer(saved), length(saved)), 'savcond');
    Check(sd2.FromBinary(saved));
    Check(sd.IsEqual(sd2));
    CheckEqual(sd2.ToText, u);
  end;
  dom := 'S-1-5-21-111-222-333';
  u := sd.ToText(dom);
  CheckEqual(u, 'D:(XA;;FR;;;WD;((Member_of{SID(LA),SID(BO)}) && ' +
    '@Device.Bitlocker))(A;ID;FA;;;SY)');
  dom2 := 'S-1-5-21-1111-2222-3333';
  sd.Modified := [];
  CheckEqual(sd.ReplaceDomain(dom, dom2), 1);
  Check(sd.Modified = [sdiDacl]);
  u2 := sd.ToText;
  CheckEqual(u2,
    'D:(XA;;FR;;;WD;((Member_of{SID(S-1-5-21-1111-2222-3333-500),SID(BO)}) && '+
    '@Device.Bitlocker))(A;ID;FA;;;SY)');
  u2 := sd.ToText(dom2);
  CheckEqual(u, u2);
  sd.Modified := [];
  CheckEqual(sd.ReplaceSid('S-1-5-21-1111-2222-3333-500',
    'S-1-5-21-111-222-333-512'), 1);
  Check(sd.Modified = [sdiDacl]);
  u := sd.ToText(dom);
  CheckEqual(u, 'D:(XA;;FR;;;WD;((Member_of{SID(DA),SID(BO)}) && ' +
    '@Device.Bitlocker))(A;ID;FA;;;SY)');
  sd.Modified := [];
  CheckEqual(sd.ReplaceSid('S-1-5-21-1111-2222-3333-500',
    'S-1-5-21-111-222-333-512'), 0);
  Check(sd.Modified = []);
end;

function IPNUSL(const s1, s2: RawUtf8; len: integer): boolean;
begin
  result := IdemPropNameUSameLenNotNull(pointer(s1), pointer(s2), len);
end;

procedure TTestCoreBase._IdemPropName;
const
  abcde: PUtf8Char = 'ABcdE';
  abcdf: PUtf8Char = 'abCDF';
  zbcde: PUtf8Char = 'zBcdE';
  edf: PUtf8Char = '$a_bc[0]edfghij';
  eda: PUtf8Char = '$a_bc[0]"edfghij';
var
  WinAnsi: WinAnsiString;
  i: integer;
begin
  Check(IdemPropName('a', 'A'));
  Check(not IdemPropName('a', 'z'));
  Check(IdemPropName('ab', 'AB'));
  Check(IdemPropName('abc', 'ABc'));
  Check(IdemPropName('abcD', 'ABcd'));
  Check(not IdemPropName('abcD', 'ABcF'));
  Check(not IdemPropName('abcD', 'ABcFG'));
  Check(not IdemPropName('abcDe', 'ABcFG'));
  Check(IdemPropName('abcDe', 'ABcdE'));
  Check(not IdemPropName('abcDef', 'ABcdEe'));
  Check(IdemPropName('abcDeF', 'ABcdEF'));
  Check(IdemPropName('ABCDEF', 'ABCDEF'));
  Check(not IdemPropName('abcD', ''));
  Check(not IdemPropName('', 'ABcFG'));
  Check(IdemPropName('', ''));
  Check(IdemPropNameU('a', 'A'));
  Check(not IdemPropNameU('a', 'z'));
  Check(IdemPropNameU('ab', 'AB'));
  Check(not IdemPropNameU('abc', 'ABz'));
  Check(not IdemPropNameU('zbc', 'abc'));
  Check(IdemPropNameU('abc', 'ABc'));
  Check(IdemPropNameU('abcD', 'ABcd'));
  Check(not IdemPropNameU('abcD', 'ABcF'));
  Check(not IdemPropNameU('abcD', 'ABcFG'));
  Check(not IdemPropNameU('abcDe', 'ABcFG'));
  Check(IdemPropNameU('abcDe', 'ABcdE'));
  Check(not IdemPropNameU('abcDef', 'ABcdEe'));
  Check(IdemPropNameU('abcDeF', 'ABcdEF'));
  Check(IdemPropNameU('ABCDEF', 'ABCDEF'));
  Check(not IdemPropNameU('abcD', ''));
  Check(not IdemPropNameU('', 'ABcFG'));
  Check(not IdemPropNameU('ABcFG', ''));
  Check(IdemPropNameU('', ''));
  for i := 0 to 100 do
    Check(IdemPropNameU(RawUtf8OfChar('a', i), RawUtf8OfChar('A', i)));
  CheckEqual(UpperCaseU('abcd'), 'ABCD');
  Check(IdemPropNameU('abcDe', abcde, 5));
  Check(not IdemPropNameU('abcD', abcde, 5));
  Check(not IdemPropNameU('abcDF', abcde, 5));
  Check(IdemPropName(abcde, abcde, 4, 4));
  Check(IdemPropName(abcde, abcde, 5, 5));
  Check(not IdemPropName(abcde, abcde, 4, 5));
  Check(not IdemPropName(abcde, abcdf, 5, 5));
  Check(IdemPropName(abcde, nil, 0, 0));
  Check(not IdemPropName(abcde, nil, 1, 0));
  Check(not IPNUSL('abcD', 'ABcF', 4));
  Check(not IPNUSL('abcD', 'ABcFG', 4));
  Check(IPNUSL('abcDe', 'ABcdE', 5));
  Check(IPNUSL('ABcdE', 'abCDF', 1));
  Check(IPNUSL('ABcdE', 'abCDF', 2));
  Check(IPNUSL('ABcdE', 'abCDF', 3));
  Check(IPNUSL('ABcdE', 'abCDF', 4));
  Check(not IPNUSL('ABcdE', 'abCDF', 8));
  Check(IdemPropNameUSameLenNotNull(abcde, abcdf, 1));
  Check(IdemPropNameUSameLenNotNull(abcde, abcdf, 2));
  Check(IdemPropNameUSameLenNotNull(abcde, abcdf, 3));
  Check(IdemPropNameUSameLenNotNull(abcde, abcdf, 4));
  Check(not IdemPropNameUSameLenNotNull(abcde, abcdf, 5));
  Check(not IdemPropNameUSameLenNotNull(abcde, zbcde, 1));
  Check(not IdemPropNameUSameLenNotNull(abcde, zbcde, 2));
  Check(not IdemPropNameUSameLenNotNull(abcde, zbcde, 3));
  Check(not IdemPropNameUSameLenNotNull(abcde, zbcde, 4));
  Check(not IdemPropNameUSameLenNotNull(abcde, zbcde, 5));
  Check(FindRawUtf8(['a', 'bb', 'cc'], 'a') = 0);
  Check(FindRawUtf8(['a', 'bb', 'cc'], 'cc') = 2);
  Check(FindRawUtf8(['a', 'bb', 'cc'], 'ab') = -1);
  Check(FindRawUtf8(['a', 'bb', 'cc'], 'A') = -1);
  Check(FindRawUtf8(['a', 'bb', 'cc'], 'A', false) = 0);
  Check(FindPropName(['a', 'bb', 'cc'], 'A') = 0);
  Check(FindPropName(['a', 'bb', 'cc'], 'cC') = 2);
  Check(FindPropName(['a', 'bb', 'cc'], 'ab') = -1);
  WinAnsi := 'aecD';
  WinAnsi[2] := #$E9;
  WinAnsi[3] := #$E7;
  Check(UpperCaseU(WinAnsiToUtf8(WinAnsi)) = 'AECD');
  check(not JsonPropNameValid(nil));
  check(not JsonPropNameValid(@edf[15]));
  for i := 14 downto 0 do
    check(JsonPropNameValid(@edf[i]) <> (i in [5, 7]));
  for i := 15 downto 0 do
    check(JsonPropNameValid(@eda[i]) = (i > 8));
  Check(PosChar('ABC', 'z') = nil);
  Check(PosChar(nil, 'A') = nil);
  Check(PosChar('ABC', 'A')^ = 'A');
  Check(PosChar('ABC', 'B')^ = 'B');
  Check(PosChar('ABC', 'C')^ = 'C');
  Check(PosChar('ABC', 'a') = nil);
  Check(PosChar('ABC', #0) = nil);
  Check(PosCharAny('ABC', 'z') = nil);
  Check(PosCharAny('ABC', 'A')^ = 'A');
  Check(PosCharAny('ABC', 'B')^ = 'B');
  Check(PosCharAny('ABC', 'C')^ = 'C');
  Check(PosCharAny('ABC', 'az') = nil);
  Check(PosCharAny('ABC', 'aA')^ = 'A');
  Check(PosCharAny('ABC', 'bB')^ = 'B');
  Check(PosCharAny('ABC', 'cC')^ = 'C');
  Check(PosExChar('z', '') = 0, 'ABC');
  Check(PosExChar('z', 'A') = 0, 'ABC');
  Check(PosExChar('z', 'ABC') = 0, 'ABC');
  Check(PosExChar('A', 'A') = 1, 'ABC');
  Check(PosExChar('A', 'AB') = 1, 'ABC');
  Check(PosExChar('A', 'ABC') = 1, 'ABC');
  Check(PosExChar('B', 'ABC') = 2, 'ABC');
  Check(PosExChar('B', 'AB') = 2, 'ABC');
  Check(PosExChar('C', 'ABC') = 3, 'ABC');
end;

procedure TTestCoreBase._TSynCache;
var
  C: TSynCache;
  s, v: RawUtf8;
  i: integer;
  Tag: PtrInt;
begin
  C := TSynCache.Create;
  try
    Check(not C.Reset);
    for i := 0 to 100 do
    begin
      v := Int32ToUtf8(i);
      Tag := 0;
      s := C.Find(v, @Tag);
      Check(s = '');
      Check(Tag = 0);
      C.AddOrUpdate(v, v + v, i);
    end;
    CheckEqual(c.Count, 101);
    for i := 0 to 100 do
    begin
      v := Int32ToUtf8(i);
      Check(C.Find(v, @Tag) = v + v);
      Check(Tag = i);
    end;
    Check(C.Reset);
    CheckEqual(c.Count, 0);
  finally
    C.Free;
  end;
end;

procedure TTestCoreBase._TSynFilter;
type
  TFilterProcess = function(const Value: RawUtf8): RawUtf8;

  procedure Test(Filter: TSynFilterClass; Proc: TFilterProcess);
  var
    V, Old, New: RawUtf8;
    i: integer;
  begin
    with Filter.Create do
    try
      for i := 0 to 200 do
      begin
        V := RandomUtf8(i);
        Old := V;
        New := Proc(Old);
        Process(0, V);
        CheckEqual(V, New);
        V := Old;
        Filter.Execute('', V);
        CheckEqual(V, New);
      end;
    finally
      Free;
    end;
  end;

begin
  Test(TSynFilterTrim, TrimU);
  Test(TSynFilterLowerCase, LowerCase);
  Test(TSynFilterUpperCase, UpperCase);
  Test(TSynFilterLowerCaseU, LowerCaseU);
  Test(TSynFilterUpperCaseU, UpperCaseU);
end;

procedure TTestCoreBase._TSynValidate;

  procedure TestValidateLength(const Params: RawUtf8; aMin, aMax: cardinal);
  var
    i: cardinal;
    V: RawUtf8;
    Msg: string;
    ok: boolean;
    valid: TSynValidateText;
  begin
    valid := TSynValidateText.Create(Params);
    try
      Check(valid.MinLength = aMin);
      Check(valid.MaxLength = aMax);
      for i := 0 to 100 do
      begin
        V := RandomUtf8(i);
        CheckEqual(Utf8ToUnicodeLength(pointer(V)), i, 'Unicode glyph=Ansi char=i');
        Msg := '';
        ok := (i >= aMin) and
              (i <= aMax);
        Check(valid.Process(0, V, Msg) = ok, Msg);
        Check((Msg = '') = ok, Msg);
        Msg := TSynValidateText.Execute(Params, V);
        Check((Msg = '') = ok, Msg);
      end;
    finally
      valid.Free;
    end;
  end;

var
  Msg: string;
begin
  with TSynValidateIPAddress.Create do
  try
    Check(Process(0, '192.168.1.1', Msg));
    Check(Msg = '');
    Msg := '';
    Check(not Process(0, ' 192.168.1.1', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(not Process(0, '292.168.1.1', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(Process(0, '192.168.001.001', Msg));
    Check(Msg = '');
  finally
    Free;
  end;
  with TSynValidateEmail.Create do
  try
    Msg := '';
    Check(Process(0, 'test@synopse.info', Msg));
    Check(Msg = '');
    Msg := '';
    Check(not Process(0, 'test@ synopse.info', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(not Process(0, 'test@synopse.delphi', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(Process(0, 'test_two@blog.synopse.info', Msg));
    Check(Msg = '');
    Msg := '';
    Check(Process(0, 'test_two@blog.synopse.fr', Msg));
    Check(Msg = '');
  finally
    Free;
  end;
  with TSynValidateEmail.Create('{"ForbiddenDomains":"google.fr,synopse.info"}') do
  try
    Msg := '';
    Check(Process(0, 'test@blog.synopse.fr', Msg));
    Check(Process(0, 'test@blog.synopse.info', Msg));
    Check(not Process(0, 'test@synopse.info', Msg));
    Msg := '';
    Check(Process(0, 'test@blog.google.fr', Msg));
    Check(not Process(0, 'test@google.fr', Msg));
  finally
    Free;
  end;
  with TSynValidateEmail.Create('{"AllowedTLD":"com,org,net","ForbiddenTLD":"net"}') do
  try
    Msg := '';
    Check(Process(0, 'test@synopse.com', Msg));
    Check(Msg = '');
    Msg := '';
    Check(not Process(0, 'test@ synopse.com', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(not Process(0, 'test@synopse.info', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(not Process(0, 'test_two@blog.synopse.net', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(not Process(0, 'test_two@blog.synopse.fr', Msg));
    Check(Msg <> '');
  finally
    Free;
  end;
  with TSynValidatePattern.Create('this [e-n]s a [!zy]est') do
  try
    Msg := '';
    Check(Process(0, 'this is a test', Msg));
    Check(Msg = '');
    Msg := '';
    Check(Process(0, 'this is a rest', Msg));
    Check(Msg = '');
    Msg := '';
    Check(not Process(0, 'this is a zest', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(not Process(0, 'this as a test', Msg));
    Check(Msg <> '');
    Msg := '';
    Check(not Process(0, 'this as a rest', Msg));
    Check(Msg <> '');
  finally
    Free;
  end;
  TestValidateLength('', 1, maxInt);
  TestValidateLength('{"mAXlength": 10 , "MInLENgtH" : 3 }', 3, 10);
  with TSynValidateText.Create do
  try
    Msg := '';
    MaxLeftTrimCount := 0;
    Check(Process(0, 'one', Msg));
    Check(not Process(0, ' one', Msg));
    MaxRightTrimCount := 0;
    Check(Process(0, 'one', Msg));
    Check(not Process(0, ' one', Msg));
    Check(not Process(0, 'one ', Msg));
    Msg := '';
    MinAlphaCount := 3;
    Check(Process(0, 'one', Msg));
    Check(not Process(0, 'on2', Msg));
    Msg := '';
    MinDigitCount := 2;
    Check(Process(0, 'one12', Msg));
    Check(not Process(0, 'one2', Msg));
    Msg := '';
    MinPunctCount := 1;
    Check(Process(0, 'one12_', Msg));
    Check(Process(0, '_one12_', Msg));
    Check(Process(0, '_one12', Msg));
    Check(not Process(0, 'one12', Msg));
    Msg := '';
    MinLowerCount := 3;
    Check(Process(0, 'o12_ne', Msg));
    Check(not Process(0, 'o12_An', Msg));
    Msg := '';
    MinUpperCount := 3;
    Check(Process(0, 'o12_neABC', Msg));
    Check(not Process(0, 'o12_AnBc', Msg));
    Msg := '';
    MinSpaceCount := 3;
    Check(Process(0, 'o12 _ne AB C', Msg));
    Check(not Process(0, 'O1 2_A neeB', Msg));
    Msg := '';
    MaxSpaceCount := 3;
    Check(Process(0, 'o12 _ne AB C', Msg));
    Check(not Process(0, 'o12 _ ne AB C', Msg));
  finally
    Free;
  end;
  with TSynValidatePassword.Create do
  try
    Msg := '';
    Check(Process(0, 'aA3!Z', Msg));
    Check(not Process(0, 'aA3!', Msg));
    Msg := '';
    Check(not Process(0, 'aA 3!Z', Msg));
  finally
    Free;
  end;
end;

procedure TTestCoreBase.UrlDecoding;
var
  i, V: integer;
  c: cardinal;
  v64: Int64;
  s, t, d: RawUtf8;
  U: PUtf8Char;
begin
  for i := 1 to 100 do
  begin
    s := DateTimeToIso8601(Now / 20 + rnd.NextDouble * 20, true);
    t := UrlEncode(s); // e.g. '1906-05-18T02%3A02%3A22'
    CheckEqual(UrlDecode(t), s);
    d := 'seleCT=' + t + '&where=' + Int32ToUtf8(i);
    Check(UrlDecodeNeedParameters(pointer(d), 'where,select'));
    Check(not UrlDecodeNeedParameters(pointer(d), 'foo,select'));
    Check(not UrlDecodeNeedParameters(pointer(d), 'wher,select'));
    Check(not UrlDecodeNeedParameters(pointer(d), 'where,selected'));
    Check(not UrlDecodeNeedParameters(pointer(d), 'wheres,select'));
    Check(UrlDecodeValue(pointer(d), 'SELECT=', t, @U));
    CheckEqual(t, s, 'UrlDecodeValue');
    Check(IdemPChar(U, 'WHERE='), 'Where');
    Check(UrlDecodeInteger(U, 'WHERE=', V));
    CheckEqual(V, i);
    Check(UrlDecodeInt64(U, 'WHERE=', v64));
    CheckEqual(v64, i);
    Check(UrlDecodeCardinal(U, 'WHERE=', c));
    CheckEqual(c, i);
    Check(not UrlDecodeValue(pointer(d), 'NOTFOUND=', t, @U));
    Check(UrlDecodeInteger(U, 'WHERE=', V, @U));
    Check(U = nil);
  end;
  s := '{"b":30,"a":"toto"}'; // temp read-only var for proper overload call
  CheckEqual(UrlEncodeJsonObject('', s, []), '?b=30&a=toto');
  {$ifdef OSWINDOWS}
  Check(GetFileNameFromUrl('file:///c:/temp/toto.text') = 'c:\temp\toto.text', 't1');
  Check(GetFileNameFromUrl('file:///c:\temp\toto.text') = 'c:\temp\toto.text', 't2');
  Check(GetFileNameFromUrl(
    'file://someserver/temp/toto.text') = '\\someserver\temp\toto.text', 't3');
  {$else}
  Check(GetFileNameFromUrl('file://someserver/temp/toto.text') = '', 'posix1');
  Check(GetFileNameFromUrl('file:///temp/toto.text') = '/temp/toto.text', 'posix2');
  {$endif OSWINDOWS}
end;

type
  /// TStream returning only a few bytes per Read, as a slow network source
  // - used by TTestCoreBase.MultiPartDecoder to validate the incremental
  // decoding of any content split at unpredictable positions
  TTrickleStream = class(TStreamWithNoSeek)
  protected
    fData: RawByteString;
    fMax: PtrInt;
  public
    constructor Create(const aData: RawByteString; aMax: PtrInt); reintroduce;
    function Read(var Buffer; Count: Longint): Longint; override;
  end;

constructor TTrickleStream.Create(const aData: RawByteString; aMax: PtrInt);
begin
  inherited Create;
  fData := aData;
  fMax := aMax;
  fSize := length(aData);
end;

function TTrickleStream.Read(var Buffer; Count: Longint): Longint;
begin
  result := length(fData) - fPosition;
  if result > fMax then
    result := fMax;
  if result > Count then
    result := Count;
  if result <= 0 then
  begin
    result := 0;
    exit;
  end;
  MoveFast(PByteArray(fData)[fPosition], Buffer, result);
  inc(fPosition, result);
end;

const
  // test data shared by TTestCoreBase.MimeTypes and MultiPartDecoder
  MIM: array[0 .. 27 * 2 - 1] of RawUtf8 = (
    'png',      'image/png',
    'PNg',      'image/png',
    'gif',      'image/gif',
    'tif',      'image/tiff',
    'tiff',     'image/tiff',
    'heic',     'image/heic',
    'jpg',      'image/jpeg',
    'JPG',      'image/jpeg',
    'jpeg',     'image/jpeg',
    'bmp',      'image/bmp',
    'doc',      'application/msword',
    'docx',     'application/msword',
    'htm',      HTML_CONTENT_TYPE,
    'html',     HTML_CONTENT_TYPE,
    'HTML',     HTML_CONTENT_TYPE,
    'css',      'text/css',
    'js',       'text/javascript',
    'ico',      'image/x-icon',
    'pdf',      'application/pdf',
    'PDF',      'application/pdf',
    'Json',     JSON_CONTENT_TYPE,
    'webp',     'image/webp',
    'manifest', 'text/cache-manifest',
    'appcache', 'text/cache-manifest',
    'h264',     'video/H264',
    'x',        'application/x-compress',
    'ogv',      'video/ogg');

procedure TTestCoreBase.MimeTypes;
const
  BIN: array[0 .. 2] of Cardinal = (
    $04034B50, $38464947, $fd2fb528);
  BIN_MIME: array[0 .. high(BIN)] of RawUtf8 = (
    'application/zip', 'image/gif', 'application/zstd');
  HEX: array[0 .. 5] of RawUtf8 = (
    '000000186674797069736F6D0000000069736F6D6D703432',
    '000000186674797068656963000000006D69663168656963',
    '0000001C66747970663476200000000069736F6D6D70343266347620',
    '000000206674797061766966000000006D696631617669666D696166',
    '4F67675300020000000000000000123456780000000012345678011E01766F7262697' +
      '3000000000244AC0000000000000000000000000000060F',
    '4F67675300020000000000000000ABCDEF120000000087654321012A807468656F726' +
      '10302000050004001E001200000003C00000001000000');
  HEX_MIME: array[0 .. high(HEX)] of RawUtf8 = (
    'video/mp4', 'image/heic', 'video/H264', 'image/avif',
    'audio/ogg', 'video/ogg');
var
  i: integer;
  s, ct: RawUtf8;
begin
  // user agent bot detection
  Check(not IsHttpUserAgentBot(
    'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like ' +
    'Gecko) Chrome/120.0.6099.230 Mobile Safari/537.36'));
  Check(not IsHttpUserAgentBot(
    'Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/115.0'));
  Check(not IsHttpUserAgentBot(
    'Mozilla/5.0 (iPhone; CPU iPhone OS 17_2_1 like Mac OS X) AppleWebKit/' +
    '605.1.15 (KHTML, like Gecko) Version/17.2 Mobile/15E148 Safari/604.1'));
  Check(not IsHttpUserAgentBot(
    'Mozilla/5.0 (Windows NT 10.0; Trident/7.0; rv:11.0) like Gecko'));
  Check(not IsHttpUserAgentBot(DefaultUserAgent(self)),
    'Mozilla/5.0 (Linux x64; mORMot) TCB/3 mormot2tests');
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ' +
    'Amazonbot/0.1; +https://developer.amazon.com/support/amazonbot) ' +
    'Chrome/119.0.6045.214 Safari/537.36'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ' +
    'Amazonbot/0.1; +https://developer.amazon.com/support/amazonbot)'));
  Check(IsHttpUserAgentBot(
    'Amazonbot/0.1; +https://developer.amazon.com/support/amazonbot/)'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; AhrefsBot/7.0; +http://ahrefs.com/robot/)'));
  Check(IsHttpUserAgentBot(
    'Googlebot/2.1 (+http://www.google.org/bot.html)'));
  Check(IsHttpUserAgentBot(
    'Y!J-BRW/1.0 crawler (http://help.yahoo.co.jp/help/jp/search/indexing/indexing-15.html'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; adidxbot/2.0;  http://www.bing.com/bingbot.htm)'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; Yahoo! Slurp; http://help.yahoo.com/help/us/ysearch/slurp)'));
  Check(IsHttpUserAgentBot(
    'adidxbot/1.1 (+http://search.msn.com/msnbot.htm)'));
  Check(IsHttpUserAgentBot(
    'Speedy Spider (http://www.entireweb.com/about/search_tech/speedy_spider/'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html)'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; coccoc:1.0; +http://help.coccoc.com/searchengine)'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (Linux; Android 5.0; SM-G920A) AppleWebKit (KHTML, like Gecko) ' +
    'Chrome Mobile Safari (compatible; AdsBot-Google-Mobile; +http://www.google.com/mobile/adsbot.html)'));
  Check(IsHttpUserAgentBot(
    'DuckDuckBot/1.0; (+http://duckduckgo.com/duckduckbot.html)'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; Applebot/0.3; +http://www.apple.com/go/applebot'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; AhrefsBot/6.1; +http://ahrefs.com/robot/)'));
  Check(IsHttpUserAgentBot(
    'serpstatbot/1.0 (advanced backlink tracking bot; http://serpstatbot.com/;'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; TinEye-bot/1.31; +http://www.tineye.com/crawler.html)'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; Yeti/1.1; +http://naver.me/bot)'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; AhrefsBot/7.0; +http://ahrefs.com/robot/)'));
  Check(IsHttpUserAgentBot(
    'LinkedInBot/1.0 (compatible; Mozilla/5.0; Apache-HttpClient +http://www.linkedin.com)'));
  Check(IsHttpUserAgentBot(
    'Twitterbot/1.0 Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) '));
  Check(IsHttpUserAgentBot(
    'Wget/1.14 (linux-gnu)'));
  Check(IsHttpUserAgentBot(
    'CCBot/2.0 (https://commoncrawl.org/faq/'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; MegaIndex.ru/2.0; +http://megaindex.com/crawler)'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 (compatible; Exabot-Images/3.0; +http://www.exabot.com/go/robot'));
  Check(IsHttpUserAgentBot(
    'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; GPTBot/1.0; +https://openai.com/gptbot'));
  Check(IsHttpUserAgentBot(
    'Feedfetcher-Google; (+http://www.google.com/feedfetcher.html; 1 subscribers; feed-id=728742641706423)'));
  Check(IsHttpUserAgentBot(
    'Python-urllib/3.4'));
  // some HTTP headers processing methods
  Check(not IsInvalidHttpHeader(''));
  Check(not IsInvalidHttpHeader('a=b'));
  Check(not IsInvalidHttpHeader('a'#13#10));
  Check(not IsInvalidHttpHeader('a'#13#10'b'#13#10));
  Check(not IsInvalidHttpHeader('a'#13#10'b'));
  Check(not IsInvalidHttpHeader('aa'#13#10'bb'#13#10));
  Check(not IsInvalidHttpHeader('aaa'#13#10'bbb'));
  Check(not IsInvalidHttpHeader('aaa'#13#10'bbb'#13#10));
  Check(not IsInvalidHttpHeader('aaaa'#13#10'bbbb'));
  Check(not IsInvalidHttpHeader('aaaa'#13#10'bbbb'#13#10));
  Check(not IsInvalidHttpHeader('aaaaa'#13#10'bbbbb'));
  Check(not IsInvalidHttpHeader('aaaaa'#13#10'bbbbb'#13#10));
  Check(not IsInvalidHttpHeader('aaaaa '#13#10'bbbbb '));
  Check(not IsInvalidHttpHeader('aaaaa '#13#10'bbbbb '#13#10));
  Check(not IsInvalidHttpHeader('aaaaa  '#13#10'bbbbb  '));
  Check(not IsInvalidHttpHeader('aaaaa  '#13#10'bbbbb  '#13#10));
  Check(not IsInvalidHttpHeader('aaaaa  1'#13#10'bbbbb  1'));
  Check(not IsInvalidHttpHeader('aaaaa  1'#13#10'bbbbb  1'#13#10));
  Check(IsInvalidHttpHeader(#13#10'a'#13#10));
  Check(IsInvalidHttpHeader(#10'a'#13#10));
  Check(IsInvalidHttpHeader(#13#10#13#10'a'#13#10));
  Check(IsInvalidHttpHeader('a'#13#10'b'#10));
  Check(IsInvalidHttpHeader('a'#10'b'#13#10));
  Check(IsInvalidHttpHeader('a'#13#10#13#10'b'#13#10));
  Check(IsInvalidHttpHeader('a'#13#10'b'#13#10#13#10));
  Check(IsInvalidHttpHeader('a'#13#10#13'b'#13#10));
  Check(IsInvalidHttpHeader('a'#13#13'b'#13#10));
  Check(IsInvalidHttpHeader('a'#13#10'b'#13#13));
  Check(IsInvalidHttpHeader('a'#13#10'b'#13));
  Check(IsInvalidHttpHeader('a'#13#10'b'#10));
  s := 'Content-Type: text/html;charset=utf-8'#13#10'ETag: "E039C149"';
  Check(not IsInvalidHttpHeader(s), 'httphead0');
  Check(not IsInvalidHttpHeader(s), 'httphead1');
  Append(s, [#13#10]);
  Check(not IsInvalidHttpHeader(s), 'httphead2');
  AppendLine(s, ['name: ', 10]);
  Check(not IsInvalidHttpHeader(s), 'httphead3');
  AppendLine(s, ['ident: ', 7]);
  CheckHash(s, $56DED9BD, 'httphead4');
  s := 'toto'#13#10;
  Check(not IsInvalidHttpHeader(s));
  CheckEqual(PurgeHeaders(''), '');
  CheckEqual(PurgeHeaders('toto'), 'toto');
  CheckEqual(PurgeHeaders(#13#10), #13#10);
  CheckEqual(PurgeHeaders('toto'#13#10), 'toto'#13#10);
  CheckEqual(PurgeHeaders(#13#10, true), '');
  CheckEqual(PurgeHeaders('toto'#13#10, true), 'toto');
  CheckEqual(PurgeHeaders('', true), '');
  CheckEqual(PurgeHeaders('toto', true), 'toto');
  CheckEqual(PurgeHeaders('content-length: 10'#13#10'toto'#13#10, true), 'toto');
  CheckEqual(PurgeHeaders('toto'#13#10'content-length: 10'#13#10, true), 'toto');
  CheckEqual(PurgeHeaders(s), s);
  CheckEqual(PurgeHeaders('content-length: 10'#13#10'toto'#13#10), s);
  CheckEqual(PurgeHeaders('toto'#13#10'content-length: 10'#13#10), s);
  CheckEqual(PurgeHeaders(
    'accept: all'#13#10'toto'#13#10'content-length: 10'#13#10), s);
  CheckEqual(PurgeHeaders(
    'accept: all'#13#10'content-length: 10'#13#10'toto'#13#10), s);
  CheckEqual(DeleteHeader(s, ''), s);
  CheckEqual(DeleteHeader('content-length: 10'#13#10'toto'#13#10, 'content-length'), s);
  CheckEqual(DeleteHeader('toto'#13#10'content-length: 10'#13#10, 'Content-Length'), s);
  CheckEqual(DeleteHeader(Join([s, s, s, 'Auth: 1']), 'auth'), Join([s, s, s]));
  CheckEqual(DeleteHeader(Join(['Auth: 0'#13#10, s, s, s]), 'auth'), Join([s, s, s]));
  CheckEqual(DeleteHeader(Join(['Auth: 0'#13#10, s, s, s, 'Auth: 1']), 'auth'), Join([s, s, s]));
  CheckEqual(DeleteHeader(Join([s, s, s, 'Auth: 2'#13#10, s]), 'auth'), Join([s, s, s, s]));
  CheckEqual(DeleteHeader(Join([s, s, s, 'Auth: 2'#13#10, 'ab']), 'auth'), Join([s, s, s, 'ab']));
  // some HTTP methods
  Check(IsGet('GET'));
  Check(not IsGet('GeT'));
  Check(not IsGet('GETS'));
  Check(IsPost('POST'));
  Check(not IsPost('PoST'));
  Check(not IsPost('P0ST'));
  Check(IsPut('PUT'));
  Check(not IsPut('PuT'));
  Check(not IsPut('PUTS'));
  Check(IsDelete('DELETE'));
  Check(IsDelete('DELE'));
  Check(not IsDelete('delete'));
  Check(IsHead('HEAD'));
  Check(not IsHead('head'));
  Check(IsHead('HEADER'));
  Check(IsOptions('OPTIONS'));
  Check(not IsOptions('options'));
  Check(IsOptions('OPTION'));
  Check(IsOptions('OPTI'));
  Check(not IsHead('toto'));
  Check(not IsOptions('toto'));
  Check(not IsHead('HE4D'));
  Check(not IsHead('GET'));
  Check(not IsHead('POST'));
  Check(not IsHead('PUT'));
  Check(not IsOptions('OPT'));
  Check(not IsOptions('GET'));
  Check(not IsOptions('POST'));
  Check(not IsOptions('PUT'));
  // mime content types
  CheckEqual(GetMimeContentType('', 'toto.h264'), 'video/H264');
  CheckEqual(GetMimeContentType('', 'toto', 'def1'), 'def1');
  CheckEqual(GetMimeContentType('', 'toto.', 'def2'), 'def2');
  CheckEqual(GetMimeContentType('', 'toto.a', 'def3'), 'application/a');
  CheckEqual(GetMimeContentType('', 'toto.1', 'def4'), 'def4');
  CheckEqual(GetMimeContentType('', 'toto.ab', 'def5'), 'application/ab');
  for i := 0 to high(MIM) shr 1 do
    CheckEqual(GetMimeContentType('',
      MakeString(['toto.', MIM[i * 2]])), MIM[i * 2 + 1]);
  FastSetString(s, 63);
  for i := 0 to high(BIN) do
  begin
    PCardinal(s)^ := BIN[i];
    CheckEqual(GetMimeContentType(s), BIN_MIME[i]);
    ct := '';
    Check(GetMimeContentTypeFromBuffer(s, ct) <> mtUnknown);
    CheckEqual(ct, BIN_MIME[i]);
  end;
  for i := 0 to high(HEX) do
  if Check(length(HEX[i]) shr 1 < length(s)) then
  begin
    Check(mormot.core.text.HexToBin(pointer(HEX[i]), pointer(s), length(HEX[i]) shr 1));
    CheckEqual(GetMimeContentType(s), HEX_MIME[i]);
    ct := '';
    Check(GetMimeContentTypeFromBuffer(s, ct) <> mtUnknown);
    CheckEqual(ct, HEX_MIME[i]);
  end;
  s := '<?xml';
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtXml);
  CheckUtf8(IsContentCompressed(pointer(s), length(s)) = false, s);
  s := '<html><body>';
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtHtml);
  CheckUtf8(IsContentCompressed(pointer(s), length(s)) = false, s);
  s := '<!doctype html><html><body>';
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtHtml);
  s := '<!doctype note>';
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtXml);
  s := '<?XML';
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtXml);
  s := '<HTML><body>';
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtHtml);
  s := '<!DocType HTML<html><body>';
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtHtml);
  s := '{"json":123}';
  CheckUtf8(IsContentCompressed(pointer(s), length(s)) = false, s);
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtJson);
  s := '["json",123]';
  CheckUtf8(IsContentCompressed(pointer(s), length(s)) = false, s);
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtJson);
  s := '["json",'#0'123]';
  Check(GetMimeContentTypeFromMemory(pointer(s), length(s)) = mtUnknown);
  Check(not IsContentTypeCompressibleU('anything'));
  Check(not IsContentTypeCompressibleU('toto/plain'));
  Check(IsContentTypeCompressibleU('text/plain'));
  Check(IsContentTypeCompressibleU('text/xml'));
  Check(IsContentTypeCompressibleU('text/css'));
  Check(not IsContentTypeCompressibleU('texto/xml'));
  Check(IsContentTypeCompressibleU('application/json'));
  Check(IsContentTypeCompressibleU('APPLICATION/JSON'));
  Check(IsContentTypeCompressibleU('application/xml'));
  Check(IsContentTypeCompressibleU('application/rtf'));
  Check(not IsContentTypeCompressibleU('application/octet-stream'));
  Check(not IsContentTypeCompressibleU('application/zrtf'));
  Check(not IsContentTypeCompressibleU('application/xm'));
  Check(IsContentTypeCompressibleU('application/javascript'));
  Check(IsContentTypeCompressibleU('application/VND.API+JSON'));
  Check(IsContentTypeCompressibleU('application/vnd.mysoft.v1+json'));
  Check(IsContentTypeCompressibleU('application/atom+XMl'));
  Check(IsContentTypeCompressibleU('application/office+RTf'));
  Check(not IsContentTypeCompressibleU('application/office+rtl'));
  Check(not IsContentTypeCompressibleU('applications/atom+xml'));
  Check(not IsContentTypeCompressibleU('application/plain'));
  Check(IsContentTypeCompressibleU('image/svg'));
  Check(IsContentTypeCompressibleU('image/X-ico'));
  Check(IsContentTypeCompressibleU('image/X-ICO'));
  Check(not IsContentTypeCompressibleU('image/png'));
  Check(IsContentTypeJsonU('ApplicatioN/JSON'));
  Check(IsContentTypeJsonU('application/json; charset=utf8'));
  Check(IsContentTypeJsonU('application/Json;CharSet=Utf-8'));
  Check(IsContentTypeJsonU('application/VND.API+JSON;CharSet=Utf-8'));
  Check(not IsContentTypeJsonU('application/vnd.mysoft.v1+jso'));
  Check(IsContentTypeJsonU('application/vnd.mysoft.v1+json'));
  Check(not IsContentTypeJsonU('application/vnd.mysoft.v1+j'));
  Check(IsContentTypeJsonU('application/vnd.mysoft.v1+json2'));
  Check(not IsContentTypeJsonU('application/vnd.mysoft.v1+'));
  Check(IsContentTypeJsonU('application/+json'));
  Check(not IsContentTypeJsonU('application/xml'));
  Check(not IsContentTypeJsonU(XML_CONTENT_TYPE));
  Check(IsContentTypeJsonU('anything/json'));
  Check(IsContentTypeJsonU('something/JSON'));
  Check(not IsContentTypeJsonU('something/SON'));
  Check(not IsContentTypeJsonU('something/iSON'));
  Check(not IsContentTypeJsonU('something/JS0N'));
  Check(IsContentTypeTextU('text/plain'));
  Check(IsContentTypeTextU('text/xml'));
  Check(IsContentTypeTextU('text/css'));
  Check(not IsContentTypeTextU('texto/xml'));
  Check(IsContentTypeTextU('application/json'));
  Check(IsContentTypeTextU('APPLICATION/JSON'));
  Check(IsContentTypeTextU('application/xml'));
  Check(IsContentTypeTextU(XML_CONTENT_TYPE));
  Check(not IsContentTypeTextU('application/octet-stream'));
  Check(IsContentTypeTextU('application/javascript'));
  Check(IsContentTypeTextU('application/VND.API+JSON'));
  Check(IsContentTypeTextU('application/vnd.mysoft.v1+json'));
  Check(IsContentTypeTextU('application/atom+xml'));
  Check(not IsContentTypeTextU('applications/atom+xml'));
  Check(not IsContentTypeTextU('application/plain'));
  Check(IsContentTypeTextU('image/svg'));
  Check(not IsContentTypeTextU('image/X-ico'));
  Check(not IsContentTypeTextU('image/X-ICO'));
end;

procedure TTestCoreBase.MultiPartDecoder;
var
  i, j, n: integer;
  fa: TFileAge;
  fdt: TDateTime;
  fs, sz: Int64;
  fu: TUnixMSTime;
  fn: array[0..10] of TFileName;
  mp, mp2: TMultiPartDynArray;
  s, mpc, mpct, bound: RawUtf8;
  st: THttpMultiPartStream;
  rfc2388, raised: boolean;
  big, got: RawByteString;
  src: TStream;
  dec: THttpMultiPartDecoder;
  onebyte: array[0 .. 0] of byte;

  procedure DecodeAndTest;
  var
    i: integer;
  begin
    mp2 := nil;
    Check(MultiPartFormDataDecode(mpct, mpc, mp2));
    CheckEqual(length(mp2), length(mp));
    for i := 0 to high(mp2) do
      if i <= n then
      begin
        CheckEqual(mp2[i].Name,    MIM[i * 2]);
        CheckEqual(mp2[i].Content, MIM[i * 2 + 1]);
      end
      else
      begin
        j := i - n - 1;
        CheckEqual(mp2[i].FileName, StringToUtf8(ExtractFileName(fn[j])));
        CheckEqual(mp2[i].Content,  MIM[j * 2 + 1]);
      end;
  end;

  function ReadAll(strm: TStream): RawByteString;
  var
    tmp: array[0 .. 998] of byte; // odd size to exercise the sliding window
    r, len: PtrInt;
  begin
    result := '';
    len := 0;
    repeat
      r := strm.Read(tmp, SizeOf(tmp));
      if r > 0 then
      begin
        SetLength(result, len + r);
        MoveFast(tmp, PByteArray(result)[len], r);
        inc(len, r);
      end;
    until r = 0;
  end;

  procedure DecodeStreamAndTest(aBufferSize: PtrInt);
  var
    ssrc: TRawByteStringStream;
    sdec, nested: THttpMultiPartDecoder;
    i, f: integer;
    sgot: RawByteString;

    function ReadContent(part: THttpMultiPartDecoder): RawByteString;
    begin
      // the streaming decoder returns the raw section bytes: any
      // Content-Transfer-Encoding is up to the caller, as with Go
      result := ReadAll(part.Content); // also validate per-field properties
      if PropNameEquals(part.Encoding, 'base64') then
        result := Base64ToBin(result);
    end;

  begin
    // same expectations as DecodeAndTest, but using the incremental decoder
    ssrc := TRawByteStringStream.Create(mpc);
    sdec := THttpMultiPartDecoder.CreateFromContentType(ssrc, mpct, aBufferSize);
    try
      i := 0;
      f := 0;
      while sdec.NextPart do
        if IdemPChar(pointer(sdec.Current.ContentType), 'MULTIPART/MIXED') then
        begin
          // rfc2388 nested "files" section: decode it recursively
          nested := THttpMultiPartDecoder.CreateFromContentType(
            sdec.Current.Content, sdec.Current.ContentType, aBufferSize);
          try
            while nested.NextPart do
            begin
              CheckEqual(nested.Current.FileName,
                StringToUtf8(ExtractFileName(fn[f])), 'nested filename');
              sgot := ReadContent(nested);
              CheckEqual(sgot, MIM[f * 2 + 1]);
              inc(f);
            end;
            Check(nested.Close, 'nested Close');
          finally
            nested.Free;
          end;
        end
        else if sdec.Current.FileName <> '' then
        begin
          CheckEqual(sdec.Current.FileName,
            StringToUtf8(ExtractFileName(fn[f])), 'filename');
          sgot := ReadContent(sdec);
          CheckEqual(sgot, MIM[f * 2 + 1]);
          inc(f);
        end
        else
        begin
          CheckEqual(sdec.Current.Name, MIM[i * 2], 'field name');
          sgot := ReadContent(sdec);
          CheckEqual(sgot, MIM[i * 2 + 1]);
          inc(i);
        end;
      Check(sdec.Close, 'Close');
      CheckEqual(i, n + 1, 'field count');
      CheckEqual(f, length(fn), 'file count');
    finally
      sdec.Free;
      ssrc.Free;
    end;
  end;

  procedure TestOne(const body: RawByteString; const ctxt: RawUtf8;
    expparts: integer; expclose: boolean;
    const expcontent: RawByteString = ''; checkcontent: boolean = true);
  var
    tsrc: TRawByteStringStream;
    tdec: THttpMultiPartDecoder;
    parts: integer;
    tgot: RawByteString;
  begin
    // decode a hand-made body with the fixed 'xyz' boundary
    tsrc := TRawByteStringStream.Create(body);
    tdec := THttpMultiPartDecoder.Create(tsrc, 'xyz', 4096);
    try
      parts := 0;
      tgot := '';
      while tdec.NextPart do
      begin
        inc(parts);
        if parts = 1 then
          tgot := ReadAll(tdec.Current.Content);
      end;
      CheckEqual(parts, expparts, ctxt);
      CheckUtf8(tdec.Close = expclose, ctxt);
      CheckUtf8((tdec.State = mpdsFinished) = tdec.Close, ctxt);
      if checkcontent and
         (expparts <> 0) then
        CheckEqual(tgot, expcontent, ctxt); // '' = expect a void section
    finally
      tdec.Free;
      tsrc.Free;
    end;
  end;

const
  TRUNC: array[0 .. 3] of RawByteString = (
    'partial data without a final boundary', // eof within the content
    'data'#13#10'--xyz',                     // eof just after the delimiter
    'data'#13#10'--xyz'#13,                  // eof within the final crlf
    'data'#13#10'--xyz-');                   // eof within the final --
begin
  // mime multipart encoding, and round-trip with the incremental decoder
  for rfc2388 := false to true do
  begin
    mp := nil;
    mp2 := nil;
    n := high(MIM) shr 1;
    for i := 0 to n do
      Check(MultiPartFormDataAddField(MIM[i * 2], MIM[i * 2 + 1], mp));
    for i := 0 to high(fn) do
    begin
      fn[i] := WorkDir + 'mp' + IntToStr(i);
      s := MIM[i * 2 + 1];
      FileFromString(s, fn[i]);
      Check(MultiPartFormDataAddFile(fn[i], mp));
      fa := sysutils.FileAge(fn[i]);
      fdt := sysutils.FileDateToDateTime(fa);
      CheckSame(fdt, mormot.core.os.FileDateToDateTime(fa), DOUBLE_SAME, 'FileDateToDateTime');
      {$ifdef HASNEWFILEAGE}
      Check(FileAge(fn[i], fdt), 'FileAge');
      {$endif HASNEWFILEAGE}
      CheckSame(fdt, mormot.core.os.FileAgeToDateTime(fn[i]), 0.01, 'fdt');
      // FPC FileAge() is wrong and truncates 1-2 seconds on Windows -> 0.01
      Check(FileInfoByName(fn[i], fs, fu), 'FileInfoByName');
      CheckEqual(fs, length(s), 'FileInfoByName Size');
      CheckEqual(FileAgeToUnixTimeUtc(fn[i]), fu div 1000, 'FileAgeToUnixTimeUtc');
      // writeln('now=',DateTimeToIso8601Text(Now));
      // writeln('utc=',DateTimeToIso8601Text(NowUtc));
      // writeln('fdt=',DateTimeToIso8601Text(fdt));
      // writeln('osl=',DateTimeToIso8601Text(mormot.core.os.FileAgeToDateTime(fn[i])));
      // writeln('osu=',UnixTimeToString(FileAgeToUnixTimeUtc(fn[i])));
      //  now=2022-04-28T13:54:06
      //  utc=2022-04-28T11:54:06
      //  fdt=2022-04-28T13:54:08 -> 2 seconds error from FPC RTL FileAge()
      //  osl=2022-04-28T13:54:06
      //  osu=2022-04-28T11:54:06
    end;
    Check(MultiPartFormDataEncode(mp, mpct, mpc, rfc2388));
    DecodeAndTest;
    DecodeStreamAndTest(4096);
    st := THttpMultiPartStream.Create;
    st.Rfc2388NestedFiles := rfc2388;
    for i := 0 to n do
      st.AddContent(MIM[i * 2], MIM[i * 2 + 1]);
    for i := 0 to high(fn) do
      st.AddFile('', fn[i]);
    st.Flush;
    mpct := st.MultipartContentType;
    mpc := StreamToRawByteString(st);
    DecodeAndTest;
    DecodeStreamAndTest(4096);
    DecodeStreamAndTest(65536);
    // Flush should be idempotent: THttpClientSocket calls Seek(0, soBeginning)
    // before sending the body, which triggers Flush again - the closing
    // boundary was appended once more and the sent body exceeded the
    // Content-Length: computed from Size - see #565
    sz := st.Size;
    CheckEqual(sz, length(mpc), 'st size');
    st.Flush;
    CheckEqual(st.Size, sz, 'st flush twice');
    st.Seek(0, soBeginning);
    CheckEqual(st.Size, sz, 'st rewind');
    CheckEqual(StreamToRawByteString(st), mpc, 'st read twice');
    TSynLog.Family.ExceptionIgnoreCurrentThread := true;
    try
      raised := false;
      try
        st.AddContent('late', 'not allowed after Flush');
      except
        on EHttpSocket do
          raised := true;
      end;
      Check(raised, 'st add after flush');
      raised := false;
      try
        st.AddFile('late', fn[0]); // should not even open the file
      except
        on EHttpSocket do
          raised := true;
      end;
      Check(raised, 'st addfile after flush');
      CheckEqual(st.Size, sz, 'st size after failed add');
    finally
      TSynLog.Family.ExceptionIgnoreCurrentThread := false;
    end;
    st.Free;
    for i := 0 to high(fn) do
      check(DeleteFile(fn[i]));
  end;
  // incremental decoding of a huge section using a small work buffer, with
  // '--xyz' delimiter near-misses so that the scanner has to handle
  // delimiter prefixes split by the work buffer boundaries
  big := '';
  while length(big) < 300000 do
    Append(big, [#13#10'--xyzZ', length(big),      // wrong delimiter tail
                 #13#10'---xyz'#13#10,             // one dash too many
                 #13'--xyz'#13#10,                 // CR without LF
                 #13#10'--xyz'#13, 'no LF here'#10,// truncated CRLF tail
                 'plain content bytes'#13#10]);
  SetLength(big, 300000);
  mpc := Join(['--xyz'#13#10'Content-Disposition: form-data; name="f"'#13#10 +
    'Content-Type: application/octet-stream'#13#10#13#10, big, #13#10'--xyz--'#13#10]);
  // decode it with several work buffer sizes and consumer read sizes
  for i := 0 to 3 do
  begin
    case i of
      0: j := 4096;
      1: j := 4097;
      2: j := 8192;
    else
      j := 65536;
    end;
    src := TRawByteStringStream.Create(mpc);
    dec := THttpMultiPartDecoder.Create(src, 'xyz', j);
    try
      Check(dec.NextPart, 'big');
      CheckEqual(dec.Current.Name, 'f');
      CheckEqual(ReadAll(dec.Current.Content), big, 'big content');
      Check(not dec.NextPart, 'big end');
      Check(dec.Close, 'big Close');
    finally
      dec.Free;
      src.Free;
    end;
  end;
  // same, but from a source trickling only a few bytes per Read()
  for i := 1 to 7 do
  begin
    src := TTrickleStream.Create(mpc, i);
    dec := THttpMultiPartDecoder.Create(src, 'xyz', 4096);
    try
      Check(dec.NextPart, 'trickle');
      CheckEqual(ReadAll(dec.Current.Content), big, 'trickle content');
      Check(dec.Close, 'trickle Close');
    finally
      dec.Free;
      src.Free;
    end;
  end;
  // delimiters split at every possible offset around the work buffer edge
  for i := 4060 to 4110 do
  begin
    s := '';
    SetLength(s, i);
    FillCharFast(pointer(s)^, i, ord('a'));
    src := TRawByteStringStream.Create(Join(['--xyz'#13#10 +
      'Content-Disposition: form-data; name="s"'#13#10#13#10, s,
      #13#10'--xyz--'#13#10]));
    dec := THttpMultiPartDecoder.Create(src, 'xyz', 4096);
    try
      Check(dec.NextPart, 'edge');
      CheckEqual(ReadAll(dec.Current.Content), s, 'edge content');
      Check(dec.Close, 'edge Close');
    finally
      dec.Free;
      src.Free;
    end;
  end;
  // delimiter-like bytes within the content should be decoded as content
  TestOne('--xyz'#13#10'Content-Disposition: form-data; name="a"'#13#10#13#10 +
    'AAA'#13#10'--xyzZZZ more'#13#10'BBB'#13#10'--xyz--'#13#10,
    'fake delimiter', 1, true, 'AAA'#13#10'--xyzZZZ more'#13#10'BBB');
  TestOne('--xyz'#13#10'Content-Disposition: form-data; name="a"'#13#10#13#10 +
    'x'#13#10'--xyz-not-final'#13#10'y'#13#10'--xyz--'#13#10,
    'single dash', 1, true, 'x'#13#10'--xyz-not-final'#13#10'y');
  // preamble, transport padding and epilogue
  TestOne('some preamble'#13#10'--xyz '#9' '#13#10 +
    'Content-Disposition: form-data; name="p"'#13#10#13#10 +
    'v'#13#10'--xyz--  epilogue ignored', 'preamble padding', 1, true, 'v');
  SetLength(s, 80);
  FillCharFast(pointer(s)^, 80, 32); // 80 spaces > padding cap = content
  TestOne('--xyz'#13#10'Content-Disposition: form-data; name="a"'#13#10#13#10 +
    'x'#13#10'--xyz' + s + #13#10'y'#13#10'--xyz--'#13#10,
    'huge padding', 1, true, 'x'#13#10'--xyz' + s + #13#10'y');
  // void section, void multipart, no Content-Disposition
  TestOne('--xyz'#13#10'Content-Disposition: form-data; name="e"'#13#10#13#10 +
    #13#10'--xyz--'#13#10, 'void section', 1, true);
  TestOne('--xyz--'#13#10, 'void multipart', 0, true);
  TestOne('--xyz'#13#10'Content-Type: text/plain'#13#10#13#10 +
    'plain'#13#10'--xyz--'#13#10, 'no disposition', 1, true, 'plain');
  // header lines in any order/case/spacing, and unterminated quoted value
  src := TRawByteStringStream.Create(
    '--xyz'#13#10 +
    'content-disposition: form-data; filename="f.bin"; name="upload"'#13#10 +
    'content-type:application/octet-stream'#13#10#13#10 +
    'DATA'#13#10'--xyz--'#13#10);
  dec := THttpMultiPartDecoder.Create(src, 'xyz', 4096);
  try
    Check(dec.NextPart, 'hdr');
    CheckEqual(dec.Name, 'upload'); // direct per-field properties
    CheckEqual(dec.FileName, 'f.bin');
    CheckEqual(dec.ContentType, 'application/octet-stream');
    CheckEqual(ReadAll(dec.Content), 'DATA');
    Check(dec.Close, 'hdr Close');
  finally
    dec.Free;
    src.Free;
  end;
  TestOne('--xyz'#13#10 +
    'Content-Disposition: form-data; name="unterminated'#13#10#13#10 +
    'v'#13#10'--xyz--'#13#10, 'unterminated quote', 1, true, 'v');
  // token (unquoted) parameter values, and \" quoted-pairs in a value
  src := TRawByteStringStream.Create(
    '--xyz'#13#10'Content-Disposition: form-data; name=plain'#13#10#13#10 +
    'tok'#13#10'--xyz'#13#10 +
    'Content-Disposition: form-data; name="n"; filename="a\"b\\c.txt"'#13#10 +
    #13#10'esc'#13#10'--xyz--'#13#10);
  dec := THttpMultiPartDecoder.Create(src, 'xyz', 4096);
  try
    Check(dec.NextPart, 'token');
    CheckEqual(dec.Current.Name, 'plain', 'token name');
    CheckEqual(ReadAll(dec.Current.Content), 'tok');
    Check(dec.NextPart, 'quotedpair');
    CheckEqual(dec.Current.Name, 'n');
    CheckEqual(dec.Current.FileName, 'a"b\c.txt', 'quoted-pair filename');
    CheckEqual(ReadAll(dec.Current.Content), 'esc');
    Check(dec.Close, 'token Close');
  finally
    dec.Free;
    src.Free;
  end;
  // header lines flood: up to 100 lines per section, then rejected
  s := '';
  for i := 1 to 99 do
    Append(s, ['X-', i, ': v'#13#10]);
  TestOne('--xyz'#13#10'Content-Disposition: form-data; name="a"'#13#10 + s +
    #13#10'v'#13#10'--xyz--'#13#10, 'headers below limit', 1, true, 'v');
  TestOne('--xyz'#13#10'Content-Disposition: form-data; name="a"'#13#10 + s +
    'X-100: v'#13#10#13#10'v'#13#10'--xyz--'#13#10,
    'headers above limit', 0, false);
  // truncated input before any content -> no part, error state
  TestOne('preamble bytes with no boundary at all', 'trunc preamble', 0, false);
  TestOne('--xy', 'trunc first delimiter', 0, false);
  TestOne('--xyz'#13#10'Content-Type: text/pl', 'trunc headers', 0, false);
  // truncated content should raise EHttpMultiPart on Read
  for i := 0 to high(TRUNC) do
  begin
    src := TRawByteStringStream.Create(
      '--xyz'#13#10'Content-Disposition: form-data; name="a"'#13#10#13#10 +
      TRUNC[i]);
    dec := THttpMultiPartDecoder.Create(src, 'xyz', 4096);
    try
      Check(dec.NextPart, 'trunc');
      TSynLog.Family.ExceptionIgnoreCurrentThread := true;
      raised := false;
      try
        ReadAll(dec.Current.Content);
      except
        on EHttpMultiPart do
          raised := true;
      end;
      TSynLog.Family.ExceptionIgnoreCurrentThread := false;
      Check(raised, 'trunc raised');
      Check(dec.State = mpdsError, 'trunc state');
      Check(not dec.Close, 'trunc Close');
    finally
      dec.Free;
      src.Free;
    end;
  end;
  // one-byte consumer reads
  src := TRawByteStringStream.Create(
    '--xyz'#13#10'Content-Disposition: form-data; name="s"'#13#10#13#10 +
    'abcdefghij'#13#10'--xyz--'#13#10);
  dec := THttpMultiPartDecoder.Create(src, 'xyz', 4096);
  try
    Check(dec.NextPart, 'onebyte');
    got := '';
    while dec.Current.Content.Read(onebyte, 1) = 1 do
      Append(RawUtf8(got), [AnsiChar(onebyte[0])]);
    CheckEqual(got, 'abcdefghij', 'onebyte content');
    Check(dec.Close, 'onebyte Close');
  finally
    dec.Free;
    src.Free;
  end;
  // MultiPartFormDataBoundary() edge cases
  Check(MultiPartFormDataBoundary(
    'multipart/form-data; boundary=abc', bound) and (bound = 'abc'), 'b1');
  Check(MultiPartFormDataBoundary(
    'multipart/form-data; Boundary=abc', bound) and (bound = 'abc'), 'b2');
  Check(MultiPartFormDataBoundary(
    'multipart/form-data; boundary="q1"', bound) and (bound = 'q1'), 'b3');
  Check(MultiPartFormDataBoundary(
    'multipart/form-data; notboundary=evil; boundary=real', bound) and
    (bound = 'real'), 'b4');
  Check(MultiPartFormDataBoundary(
    'multipart/form-data; foo="boundary=fake"; boundary=real', bound) and
    (bound = 'real'), 'b5');
  Check(MultiPartFormDataBoundary(
    'multipart/form-data; boundary=abc; charset=utf-8', bound) and
    (bound = 'abc'), 'b6');
  Check(MultiPartFormDataBoundary(
    'multipart/form-data; note="x\"; boundary=evil"; boundary=good', bound) and
    (bound = 'good'), 'b7');
  Check(not MultiPartFormDataBoundary(
    'multipart/form-data; boundary="abc', bound), 'b8');
  Check(not MultiPartFormDataBoundary(
    'multipart/form-data; charset=utf-8', bound), 'b9');
  Check(MultiPartFormDataBoundary( // \: quoted-pair is unescaped
    'multipart/form-data; boundary="ab\:cd"', bound) and
    (bound = 'ab:cd'), 'b10');
  Check(MultiPartFormDataBoundary(
    'multipart/form-data;boundary=nospace', bound) and
    (bound = 'nospace'), 'b11');
  Check(MultiPartFormDataBoundary(
    'MULTIPART/FORM-DATA; BOUNDARY=upper', bound) and
    (bound = 'upper'), 'b12');
  // invalid boundaries are rejected in the constructors
  src := TRawByteStringStream.Create('X');
  try
    TSynLog.Family.ExceptionIgnoreCurrentThread := true;
    raised := false;
    try
      SetLength(bound, 500);
      FillCharFast(pointer(bound)^, 500, ord('A'));
      dec := THttpMultiPartDecoder.Create(src, bound, 4096);
      dec.Free;
    except
      on EHttpMultiPart do
        raised := true;
    end;
    Check(raised, 'oversized boundary');
    raised := false;
    try
      dec := THttpMultiPartDecoder.Create(src, 'bad'#10'bnd', 4096);
      dec.Free;
    except
      on EHttpMultiPart do
        raised := true;
    end;
    Check(raised, 'control char boundary');
    raised := false;
    try
      dec := THttpMultiPartDecoder.CreateFromContentType(src, 'text/plain', 4096);
      dec.Free;
    except
      on EHttpMultiPart do
        raised := true;
    end;
    Check(raised, 'no boundary content type');
  finally
    src.Free;
    TSynLog.Family.ExceptionIgnoreCurrentThread := false;
  end;
end;

function TTestCoreBase.QuickSelectGT(IndexA, IndexB: PtrInt): boolean;
begin
  result := fQuickSelectValues[IndexA] > fQuickSelectValues[IndexB];
end;

procedure TTestCoreBase.QuickSelect;

  function Median(const Csv: RawUtf8; Expected: integer): integer;
  var
    IDA: TIntegerDynArray;
  begin
    CsvToIntegerDynArray(pointer(Csv), IDA);
    result := MedianQuickSelectInteger(pointer(IDA), length(IDA));
    Check(result = Expected);
  end;

var
  n, i, med2, med1, len: integer;
  tmp: TSynTempBuffer;
  P: PIntegerArray;
begin
  Median('', 0);
  Median('2', 2);
  Median('3,5,12', 5);
  Median('12,3,5', 5);
  Median('19,10,84,11,23', 19);
  Median('1,3,3,6,7,8,9', 6);
  Median('1,2,3,4,5,6,8,9', 4);
  Median('3,5,7,12,13,14,21,23,23,23,23,29,39,40,56', 23);
  Median('3,13,7,5,21,23,39,23,40,23,14,12,56,23,29', 23);
  Median('3,5,7,12,13,14,21,23,23,23,23,29,40,56', 21);
  Median('3,13,7,5,21,23,23,40,23,14,12,56,23,29', 21);
  for n := 0 to 1000 do
  begin
    len := n * 2 + 1;
    SetLength(fQuickSelectValues, len);
    P := pointer(fQuickSelectValues);
    FillIncreasing(P, 1, len);
    med1 := MedianQuickSelect(QuickSelectGT, len, tmp);
    Check(fQuickSelectValues[med1] = n + 1);
    Check(MedianQuickSelectInteger(P, len) = n + 1);
    for i := 0 to high(fQuickSelectValues) do
      fQuickSelectValues[i] := rnd.Next31;
    med1 := fQuickSelectValues[MedianQuickSelect(QuickSelectGT, len, tmp)];
    med2 := MedianQuickSelectInteger(P, len);
    Check(med1 = med2);
    QuickSortInteger(P, 0, len - 1);
    check(med2 = fQuickSelectValues[n]);
  end;
end;

type
  TSynLogInitProbe = class(TSynLog)
  protected
    procedure CreateLogWriter; override;
  end;

var
  SynLogInitProbeCount: integer;
  SynLogInitNestedDone: boolean;

procedure TSynLogInitProbe.CreateLogWriter;
begin
  inc(SynLogInitProbeCount);
  // we are already inside this TSynLog writer lock:
  // this nested log must be silently ignored
  if not SynLogInitNestedDone then
  begin
    SynLogInitNestedDone := true;
    Log(sllDebug, 'nested during CreateLogWriter');
  end;
  inherited CreateLogWriter;
end;

procedure TTestCoreBase.Debugging;

  procedure TestLogFileInit;
  var
    fam: TSynLogFamily;
  begin
    fam := TSynLogInitProbe.Family;
    fam.Level := [sllDebug];
    fam.NoFile := true;
    TSynLogInitProbe.Add.CloseLogFile; // force LogFileInit
    Check(not fam.ExceptionIgnoreCurrentThread);
    SynLogInitProbeCount := 0;
    SynLogInitNestedDone := false;
    TSynLogInitProbe.Add.Log(sllDebug, 'init');
    CheckEqual(SynLogInitProbeCount, 1, 'no recursive CreateLogWriter');
    Check(SynLogInitNestedDone, 'nested logging probe executed');
    Check(not fam.ExceptionIgnoreCurrentThread, 'exception flag untouched');
  end;

  procedure TestLiveAppendedLines;
  const
    STAMPS: array[0..1] of RawUtf8 = ( // calendar and high resolution layouts
      '20250213 16410200', '0000000000001234');
    THREADS: array[0..2] of integer = (0, 1, 4096);
    HEADER = 'C:\mormot2tests.exe 1.0.0 (2025-02-13 16:41:00)'#13#10 +
      'Host=Test User=Test CPU=1 OS=0 Wow64=0 Freq=1000000'#13#10 +
      'TSynLog 2.0 2025-02-13T16:41:00'#13#10#13#10;
  var
    log: TSynLogFile;
    s, t, i, n: integer;
    stamp, input, source: RawUtf8;
  begin
    // AddInMemoryLine() rows are standalone #0 ended strings which don't belong
    // to the memory mapped buffer: fMapEnd is no valid line end for them, for
    // any layout - e.g. with or without ptIdentifiedInOneFile thread columns
    for s := low(STAMPS) to high(STAMPS) do
      for t := low(THREADS) to high(THREADS) do
      begin
        input := STAMPS[s];
        if THREADS[t] <> 0 then
          Append(input, Int18ToChars3(THREADS[t]));
        input := input + ' info  Mapped payload';
        source := HEADER;
        for i := 1 to 4 do
          Append(source, input, #13#10);
        log := TSynLogFile.Create(pointer(source), length(source));
        try
          CheckEqual(log.Count, 4, 'mapped rows');
          CheckEqual(log.EventText[0], ' Mapped payload');
          if THREADS[t] = 0 then
            Check(log.EventThread = nil)
          else
            CheckEqual(log.EventThread[0], THREADS[t]);
          log.AddInMemoryLine(input);
          CheckEqual(log.Count, 5, 'appended row');
          CheckEqual(log.Lines[4], input);
          CheckEqual(log.LineSize(4), length(input));
          Check(not log.LineSizeSmallerThan(4, length(input) - 1));
          Check(log.LineSizeSmallerThan(4, length(input)));
          CheckEqual(log.EventText[4], ' Mapped payload');
          Check(log.LineContains('PAYLOAD', 4));
          if THREADS[t] <> 0 then
            CheckEqual(log.EventThread[4], THREADS[t]);
        finally
          log.Free;
        end;
      end;
    // LoadFromMap() did size fLines[] and fThreads[] down without adjusting
    // their fLinesMax/fThreadsCount capacity, so the next AddInMemoryLine()
    // rows were stored past the reallocated buffers
    n := 1700; // long enough lines to trigger the down-sizing
    for t := 0 to 1 do
    begin
      stamp := STAMPS[0];
      if t <> 0 then
        Append(stamp, Int18ToChars3(THREADS[2]));
      Join([stamp, ' info  ', RawUtf8OfChar('m', 1078)], input);
      Join([input, #13#10], source);
      s := n * (length(input) + 2);
      while length(source) < s do
        source := source + source; // O(log n) instead of O(n2) concatenations
      SetLength(source, s);
      source := HEADER + source;
      log := TSynLogFile.Create(pointer(source), length(source));
      try
        CheckEqual(log.Count, n, 'big mapped rows');
        for i := 1 to 100 do
          log.AddInMemoryLine(input); // did corrupt the heap before the fix
        CheckEqual(log.Count, n + 100);
        for i := n to log.Count - 1 do
        begin
          CheckEqual(log.LineSize(i), length(input));
          if t <> 0 then
            CheckEqual(log.EventThread[i], THREADS[2]);
        end;
        // a row shorter than fLineTextOffset is no valid search start - the
        // invalid read itself is not observable in-process, so this asserts
        // the guard's result, and that longer rows still are searchable
        log.AddInMemoryLine('short');
        Check(not log.LineContains('SHORT', log.Count - 1));
        Check(log.LineContains('MMM', log.Count - 2));
        // fLogProcStack[] is released by LoadFromMap() but needed on append
        log.AddInMemoryLine(stamp + '  +    Work');
        log.AddInMemoryLine(stamp + '  -    Work 00.020.006');
        CheckEqual(log.Count, n + 103);
        Check(log.EventLevel[log.Count - 2] = sllEnter);
        Check(log.EventLevel[log.Count - 1] = sllLeave);
        Check(log.LogProc = nil, 'no sllEnter among the mapped rows');
        log.LogProcMerged := false; // sets LogProc[] from fLogProcNatural[]
        Check(log.LogProc <> nil);
        for i := 1 to 10 do
          log.AddInMemoryLine(stamp + '  +    More'); // reallocs fLogProcNatural
        CheckEqual(log.LogProc[0].Index, n + 101); // the appended sllEnter row
        CheckEqual(log.LogProc[0].Time, 20006);    // no dangling LogProc[]
        // note: LogProcCount is a snapshot made by LogProcMerged, and
        // LogProc[].ProperTime is computed by LoadFromMap() only: both are
        // not maintained for appended rows - out of scope for this fix
        CheckEqual(log.LogProcCount, 1);
      finally
        log.Free;
      end;
    end;
    // an appended row is never stored as a reference into the mapped buffer,
    // so that its line pointer alone tells it apart from a mapped line
    source := RawUtf8OfChar('x', 64);
    with TMemoryMapText.Create(pointer(source), 32) do
    try
      AddInMemoryLine(source);
      CheckEqual(Count, 2);
      Check(LinePointers[1] <> pointer(source), 'unaliased');
      CheckEqual(LineSize(0), 32);
      CheckEqual(LineSize(1), 64);
      CheckEqual(Lines[1], source);
      Check(LineContains('XXX', 1));
    finally
      Free;
    end;
  end;

  procedure TestPlainText;
  var
    log: TSynLogFileView;
    source: RawUtf8;
  begin
    // a file with no TSynLog header nor rows is searched as plain text
    source := 'first line'#13#10'some needle here'#13#10'last line';
    log := TSynLogFileView.Create(pointer(source), length(source));
    try
      CheckEqual(log.Count, 3);
      Check(log.EventLevel = nil, 'plain text');
      CheckEqual(StringToUtf8(log.GetLineForClipboard(1)), 'some needle here');
      CheckEqual(StringToUtf8(log.GetLineForClipboard(-1)), '', 'out of range');
      CheckEqual(StringToUtf8(log.GetLineForClipboard(log.Count)), '');
      log.Events := LOG_VERBOSE; // no level to select in a plain text file
      CheckEqual(log.Select(0), 0);
      CheckEqual(log.SelectedCount, 0);
      log.Events := [];
      Check(log.LineContains('NEEDLE', 1));
      Check(not log.LineContains('NEEDLE', 0));
      Check(not log.LineContains('NEEDLE', 3), 'out of range');
      CheckEqual(log.SearchNextText('NEEDLE', 0, 1), 1);
      CheckEqual(log.SearchPreviousText('NEEDLE', 2), 1);
      CheckEqual(log.SearchNextText('NOTHING', 0, 1), -1);
    finally
      log.Free;
    end;
  end;

  procedure TestNoProcNoEvent;
  var
    log: TSynLogFileView;
    source: RawUtf8;
  begin
    source := 'test.exe 1.0.0 (2026-02-13 16:41:00)'#13#10 +
      'Host=Test User=Test CPU=1 OS=0 Wow64=0 Freq=1000000'#13#10 +
      'TSynLog 2.0 2026-02-13T16:41:00'#13#10#13#10 +
      '20260213 16410200 info  first row'#13#10 +
      '20260213 16410300 warn  second row'#13#10;
    log := TSynLogFileView.Create(pointer(source), length(source));
    try
      CheckEqual(log.Count, 2);
      // merging the methods profiler of a log with no sllEnter at all
      CheckEqual(log.LogProcCount, 0, 'no method');
      log.LogProcMerged := true; // should not read fLogProcNatural[0]
      CheckEqual(log.LogProcCount, 0, 'nothing to merge');
      log.LogProcMerged := false;
      CheckEqual(log.LogProcCount, 0, 'nothing to unmerge');
      // unchecking all levels should display no row, not the previous rows
      log.Events := LOG_VERBOSE;
      log.Select(0);
      CheckEqual(log.SelectedCount, 2);
      log.Events := [];
      CheckEqual(log.Select(0), 0);
      CheckEqual(log.SelectedCount, 0, 'no level selected');
      log.Events := LOG_VERBOSE; // back to all rows
      log.Select(0);
      CheckEqual(log.SelectedCount, 2);
    finally
      log.Free;
    end;
  end;

  procedure TestZonedLayout;
  const
    HEADER = 'C:\mormot2tests.exe 1.0.0 (2025-02-13 16:41:00)'#13#10 +
      'Host=Test User=Test CPU=1 OS=0 Wow64=0 Freq=1000000'#13#10 +
      'TSynLog 2.0 2025-02-13T16:41:00'#13#10#13#10;
  var
    log: TSynLogFile;
    t, i: integer;
    input, source: RawUtf8;
  begin
    // Int18ToText() encodes a thread number as $20 + 6-bit chars, so thread 58
    // ends with 'Z' - which the ZonedTimestamp detection did read as its own
    // 'Z' marker, shifting fLineLevelOffset and loading the whole file empty
    for t := 0 to 1 do
    begin
      input := '20250213 16410200';
      if t <> 0 then
        Append(input, 'Z'); // TSynLogFamily.ZonedTimestamp layout
      Append(input, Int18ToChars3(58), ' info  Zoned payload');
      source := HEADER;
      for i := 1 to 4 do
        Append(source, input, #13#10);
      log := TSynLogFile.Create(pointer(source), length(source));
      try
        CheckEqual(log.Count, 4, 'zoned rows');
        CheckEqual(log.EventThread[0], 58);
        CheckEqual(log.EventText[0], ' Zoned payload');
        Check(log.EventLevel[0] = sllInfo);
      finally
        log.Free;
      end;
    end;
  end;

  procedure Test(const LOG: RawUtf8; ExpectedDate: TDateTime);
  var
    L: TSynLogFile;
    o: TLogProcSortOrder;
  begin
    L := TSynLogFile.Create(pointer(LOG), length(LOG));
    try
      Check(L.ExecutableName = 'D:\Dev\lib\SQLite3\exe\TestSQL3.exe');
      Check(L.ExecutableVersion = '1.2.3.4');
      if trunc(ExpectedDate) = 40640 then
        Check(L.InstanceName = 'D:\Dev\MyLibrary.dll')
      else
        Check(L.InstanceName = '');
      CheckSame(L.ExecutableDate, ExpectedDate, 1 / SecsPerDay);
      Check(L.ComputerHost = 'MyPC');
      Check(L.LevelUsed = [sllEnter, sllLeave, sllDebug]);
      Check(L.RunningUser = 'MySelf');
      Check(L.CPU = '2*0-15-1027');
      Check(L.OS = wXP);
      Check(L.ServicePack = 3);
      Check(not L.Wow64);
      Check(L.Freq = 0);
      CheckSame(L.StartDateTime, 40640.502882, 1 / SecsPerDay);
      if CheckFailed(L.Count = 3) then
        exit;
      Check(L.EventLevel[0] = sllEnter);
      Check(L.EventLevel[1] = sllDebug);
      CheckSame(L.EventDateTime(1), L.StartDateTime, 1 / SecsPerDay);
      Check(L.EventLevel[2] = sllLeave);
      if CheckFailed(L.LogProcCount = 1) then
        exit;
      CheckEqual(L.LogProc[0].Index, 0);
      CheckEqual(L.LogProc[0].Time, 10020006);
      for o := low(o) to high(o) do
        L.LogProcSort(o);
    finally
      L.Free;
    end;
  end;

var
  tmp: TBuffer2K;
  dst, up: PUtf8Char;
  msg, n, v: RawUtf8;
  os, os2: TOperatingSystem;
  ld: TLinuxDistribution;
  islinux: boolean;
  osv: TOperatingSystemVersion;
  len: integer;
  //sock: TNetSocket;
begin
  // validate UserAgentParse()
  Check(not UserAgentParse('toto (mozilla)', n, v, os));
  Check(UserAgentParse('myprogram/3.1.0.2W', n, v, os));
  Check(n = 'myprogram');
  Check(v = '3.1.0.2');
  check(os = osWindows);
  Check(UserAgentParse('mormot2tests/D', n, v, os));
  Check(n = 'mormot2tests');
  Check(v = '');
  check(os = osDebian);
  Check(UserAgentParse('myprogram/3.1.2W32', n, v, os));
  Check(n = 'myprogram');
  Check(v = '3.1.2');
  check(os = osWindows);
  // validate TOperatingSystemVersion
  osv.os := osWindows;
  osv.win := wSeven;
  osv.winbuild := 0;
  CheckEqualShort(ToText(osv), 'Windows 7');
  osv.win := wTen_64;
  CheckEqualShort(ToText(osv), 'Windows 10 64bit');
  osv.winbuild := 10240;
  CheckEqualShort(ToText(osv), 'Windows 10 64bit 1507');
  osv.winbuild := 10241;
  CheckEqualShort(ToText(osv), 'Windows 10 64bit 1507');
  osv.win := wTen;
  osv.winbuild := 19045;
  CheckEqualShort(ToText(osv), 'Windows 10 22H2');
  osv.win := wEleven;
  osv.winbuild := 22000;
  CheckEqualShort(ToText(osv), 'Windows 11 21H2');
  osv.winbuild := 22621;
  CheckEqualShort(ToText(osv), 'Windows 11 22H2');
  osv.win := wEleven_64;
  osv.winbuild := 26100;
  CheckEqualShort(ToText(osv), 'Windows 11 64bit 24H2');
  osv.winbuild := 26100;
  CheckEqualShort(ToTextOS(cardinal(osv)), 'Windows 11 64bit 24H2 26100');
  osv.winbuild := 26210;
  CheckEqualShort(ToTextOS(cardinal(osv)), 'Windows 11 64bit 25H2 26210');
  osv.win := wServer2022_64;
  osv.winbuild := 20349;
  CheckEqualShort(ToText(osv), 'Windows Server 2022 64bit 21H2');
  CheckEqual(ToTextOSU(cardinal(osv)), 'Windows Server 2022 64bit 21H2 20349');
  // validate OS definitions logic
  for os := low(os) to high(os) do
  begin
    islinux := false;
    for ld := succ(low(ld)) to high(ld) do
      if os in LINUX_DIST[ld] then
        if Check(not islinux, 'os twice') then
          if Check(LinuxDistribution(os) = ld, 'ld') then
            islinux := true;
    Check((os in OS_LINUX) = islinux, 'islinux');
    Check(islinux = not (os in LINUX_DIST[ldNotLinux]));
    Check(islinux = (LinuxDistribution(os) <> ldNotLinux));
    for os2 := low(os) to high(os) do
      Check((OS_INITIAL[os2] = OS_INITIAL[os]) = (os2 = os), 'OS_INITIAL');
  end;
  // validate OSX kernel number to Apple Corp marketing "logic"
  osv.os := osOSX;
  osv.utsrelease[2] := 7;
  CheckEqualShort(MACOS_NUM[MacKernel(osv)], '10.4');
  osv.utsrelease[2] := 8;
  CheckEqualShort(MACOS_NUM[MacKernel(osv)], '10.4');
  osv.utsrelease[2] := 24;
  CheckEqualShort(MACOS_NUM[MacKernel(osv)], '15');
  osv.utsrelease[2] := 25;
  CheckEqualShort(MACOS_NUM[MacKernel(osv)], '26');
  osv.utsrelease[2] := 27;
  CheckEqualShort(MACOS_NUM[MacKernel(osv)], '27');
  osv.utsrelease[2] := 28;
  CheckEqualShort(MACOS_NUM[MacKernel(osv)], '28');
  CheckEqualShort(MACOS_NAME[MacKernel(osv)], 'Next');
  osv.utsrelease[2] := 29;
  CheckEqualShort(MACOS_NAME[MacKernel(osv)], 'Next');
  // validate Syslog messages formatting
  msg := ' test  ';
  dst := @tmp;
  FillcharFast(tmp, SizeOf(tmp), 1);
  len := SyslogBsdPrepare(sllInfo, pointer(msg), length(msg), tmp);
  // e.g. '<14>Feb 11 13:45:19 dev-ab mormot2tests[23014]: test'
  Check(len > 10);
  Check(IdemPChar(dst, PAnsiChar('<14>')));
  Check(tmp[len] = #0, 'ending #0');
  Check(tmp[len + 1] = #1, 'buffer');
  {if NewUnixSocket('/dev/log', sock) = nrOk then
  begin
    writeln(sock.Send(@tmp, len));
    sock.Close;
  end;}
  FillcharFast(tmp, SizeOf(tmp), 1);
  len := SyslogMessage(sfAuth, ssCrit, pointer(msg), length(msg),
    '', '', tmp, SizeOf(tmp), false);
  // e.g. <34>1 2026-02-11T15:01:23.552Z dev-ab mormot2tests - - - test
  Check(len > 50); // len different for every PC, due to PC name differences
  Check(IdemPChar(dst, PAnsiChar('<34>1 ')));
  up := ' - - - TEST';
  CheckEqual(StrPosI(up, dst) - dst, len - 11);
  msg := RawUtf8OfChar('+', 300);
  len := SyslogMessage(sfLocal4, ssNotice, pointer(msg), length(msg),
    'proc', 'msg', tmp, 300, false);
  Check(IdemPChar(dst, PAnsiChar('<165>1 ')));
  up := ' PROC MSG - ++++';
  Check(StrPosI(up, dst) <> nil, 'proc msg');
  Check(len < 300, 'truncated to avoid buffer overflow');
  Check(tmp[len - 1] = '+', 'last+');
  Check(tmp[len] = #0, 'ending #0');
  Check(tmp[len + 1] = #1, 'buffer');
  FillcharFast(tmp, len, 1);
  len := SyslogPrepare(sllInfo, pointer(msg), length(msg), tmp, dst, {tls=}false);
  Check(len > 50);
  Check(len < 400);
  Check(IdemPChar(dst, PAnsiChar('<14>1 ')));
  Check(dst[len - 1] = '+', 'last+');
  Check(dst[len] = #0, 'ending #0');
  Check(dst[len + 1] = #1, 'buffer');
  // '361 <14>1 2026-02-11T12:03:02.386Z dev-ab mormot2tests 20096 - - +++++...'
  FillcharFast(dst^, len, 1);
  len := SyslogPrepare(sllInfo, pointer(msg), length(msg), tmp, dst, {tls=}true);
  Check(StrPosI(pointer(msg), dst) <> nil, 'msg in syslog');
  FormatUtf8(' % ', [GetCurrentProcessId], v);
  Check(StrPosI(pointer(v), dst) <> nil, 'pid in syslog');
  UpperCaseCopy(Executable.Host, v);
  Check(StrPosI(pointer(v), dst) <> nil, 'host in syslog');
  UpperCaseCopy(Executable.ProgramName, v);
  Check(StrPosI(pointer(v), dst) <> nil, 'appname in syslog');
  Check(len > 50);
  Check(len < 400);
  Check(dst[3] = ' ');
  Check(IdemPChar(@dst[4], PAnsiChar('<14>1 ')));
  CheckEqual(GetInteger(dst), len - 4);
  Check(dst[len - 1] = '+', 'last+');
  Check(dst[len] = #0, 'ending #0');
  Check(dst[len + 1] = #1, 'buffer');
  TestLogFileInit;
  // validate TSynLogFile
  TestLiveAppendedLines;
  TestPlainText;
  TestNoProcNoEvent;
  TestZonedLayout;
  Test('D:\Dev\lib\SQLite3\exe\TestSQL3.exe 1.2.3.4 (2011-04-07 11:09:06)'#13#10 +
    'Host=MyPC User=MySelf CPU=2*0-15-1027 OS=2.3=5.1.2600 Wow64=0 Freq=3579545 ' +
    'Instance=D:\Dev\MyLibrary.dll'#13#10 +
    'TSynLog 1.15 LVCL 2011-04-07 12:04:09'#13#10#13#10 +
    '20110407 12040903  +    SQLite3Commons.TRestServer.Uri (14163)'#13#10 +
    '20110407 12040904 debug {"TObjectList(00AF8D00)":["TObjectList(00AF8D20)",' +
    '"TObjectList(00AF8D60)","TFileVersion(00ADC0B0)","TDebugFile(00ACC990)"]}'#13#10 +
    '20110407 12040915  -    SQLite3Commons.TRestServer.Uri (14163) 10.020.006',
    40640.464653);
  Test('D:\Dev\lib\SQLite3\exe\TestSQL3.exe 1.2.3.4 (2011-04-08 11:09:06)'#13#10 +
    'Host=MyPC User=MySelf CPU=2*0-15-1027 OS=2.3=5.1.2600 Wow64=0 Freq=3579545'#13#10 +
    'TSynLog 1.15 LVCL 2011-04-07 12:04:09'#13#10#13#10 +
    '20110407 12040903  +    SQLite3Commons.TRestServer.Uri (14163)'#13#10 +
    '20110407 12040904 debug {"TObjectList(00AF8D00)":["TObjectList(00AF8D20)",' +
    '"TObjectList(00AF8D60)","TFileVersion(00ADC0B0)","TDebugFile(00ACC990)"]}'#13#10 +
    '20110407 12040915  -    SQLite3Commons.TRestServer.Uri (14163) 10.020.006',
    40641.464653);
end;

procedure TTestCoreBase._TSynNameValue;
const
  MAX = 10000;
var
  nv: TSynNameValue;
  i: integer;
  v: RawUtf8;
  tmp: TSynTempBuffer;
begin
  nv.Init(false);
  check(nv.Count = 0);
  for i := 1 to MAX do
    nv.Add(UInt32ToUtf8(i), UInt32ToUtf8(i + MAX));
  check(nv.Count = MAX);
  for i := 1 to MAX do
    checkEqual(nv.Find(UInt32ToUtf8(i)), i - 1);
  for i := MAX + 1 to MAX * 2 do
    check(nv.Find(UInt32ToUtf8(i)) < 0);
  for i := 1 to MAX do
  begin
    UInt32ToUtf8(i + MAX, v);
    checkEqual(nv.Value(UInt32ToUtf8(i)), v);
    checkEqual(nv.Str[UInt32ToUtf8(i)], v);
  end;
  nv.InitFromNamesValues(['a', 'b'], ['1', 'be']);
  checkEqual(nv.Count, 2);
  checkEqual(nv.Str['a'], '1');
  checkEqual(nv.Str['b'], 'be');
  checkEqual(nv.Str['c'], '');
  checkEqual(nv.ValueInt('a'), 1);
  checkEqual(nv.ValueInt('b'), 0);
  checkEqual(nv.ValueInt('c'), 0);
  checkEqual(nv.AsCsv('=', ';'), 'a=1;b=be;');
  checkEqual(nv.AsJson, '{"a":"1","b":"be"}');
  tmp.Init('{a:10,b:"bee"}');
  check(nv.InitFromJsonBuffer(tmp.buf, false));
  checkEqual(nv.Count, 2);
  checkEqual(nv.Str['a'], '10');
  checkEqual(nv.Str['b'], 'bee');
  checkEqual(nv.Str['c'], '');
  checkEqual(nv.Int['a'], 10);
  checkEqual(nv.Int['b'], 0);
  checkEqual(nv.Int['c'], 0);
  checkEqual(nv.AsCsv('=', ';'), 'a=10;b=bee;');
  checkEqual(nv.AsJson, '{"a":"10","b":"bee"}');
  check(nv.Delete('b'));
  checkEqual(nv.ValueInt('a'), 10);
  checkEqual(nv.Str['b'], '');
  check(not nv.Delete('b'));
  checkEqual(nv.DeleteByValue('10'), 1);
  checkEqual(nv.ValueInt('a'), 0);
  checkEqual(nv.DeleteByValue('10'), 0);
  checkEqual(nv.Count, 0);
  checkEqual(nv.AsCsv('=', ';'), '');
  check(not nv.InitFromJson('{"a":20,b:"bi"]'));
  checkEqual(nv.Count, 0);
  checkEqual(nv.AsCsv('=', ';'), '');
  checkEqual(nv.AsJson, '{}');
  check(nv.InitFromJson('{a:10,b:"bee"}', false));
  checkEqual(nv.Count, 2);
  checkEqual(nv.AsCsv('=', ';'), 'a=10;b=bee;');
end;

procedure TTestCoreBase.TSynUniqueIdentifierSlow(Sender: TObject);
const
  JAN2015_UNIX = 1420070400;
var
  gen: TSynUniqueIdentifierGenerator;
  i1, i2: TSynUniqueIdentifierBits;
  js: TSynUnique53;
  i3: TSynUniqueIdentifier;
  rounds, i: integer;
  json, obfusc: RawUtf8;
  timer: TPrecisionTimer;
begin
  for rounds := 0 to 1 do
  begin
    gen := TSynUniqueIdentifierGenerator.Create(10, 'toto', rounds * 100);
    try
      for i := 1 to 50000 do
      begin
        i1.Value := 0;
        i2.Value := 0;
        gen.ComputeNew(i1);
        gen.ComputeNew(i2);
        check(i1.Value <> 0);
        check(i2.Value <> 0);
        check(i1.ProcessID = 10);
        check(i2.ProcessID = 10);
        check(i1.CreateTimeUnix > JAN2015_UNIX);
        check(i1.CreateTimeUnix <= i2.CreateTimeUnix);
        check(i1.Value < i2.Value);
        check(not i1.Equal(i2));
        i2.From(i1.Value);
        check(i1.Equal(i2));
        json := VariantSaveJson(i1.AsVariant);
        checkEqual(VariantSaveJson(i2.AsVariant), json);
        CheckEqual(json, FormatUtf8(
          '{"Created":"%","Identifier":%,"Counter":%,"Value":%,"Hex":"%"}',
          [DateTimeToIso8601Text(i1.CreateDateTime), i1.ProcessID, i1.Counter,
           i1.Value, Int64ToHex(i1.Value)]), 'asvariant');
        obfusc := gen.ToObfuscated(i1.Value);
        check(gen.FromObfuscated(obfusc, i3));
        check(i1.Value = i3);
        if rounds > 0 then
          check(Length(obfusc) = 32)
        else
          check(Length(obfusc) = 24);
        inc(obfusc[12]);
        check(not gen.FromObfuscated(obfusc, i3), 'tempered text');
        dec(obfusc[12]);
      end;
      check(gen.FromObfuscated(obfusc, i3), 'detempered');
      //writeln('LastUnixCreateTime=', gen.LastUnixCreateTime);
      //writeln('UnixTimeUtc=', UnixTimeUtc);
    finally
      gen.Free;
    end;
  end;
  gen := TSynUniqueIdentifierGenerator.Create(10, 'toto', 100);
  try
    i3 := 0;
    check(gen.FromObfuscated(obfusc, i3), 'SharedObfuscationKey');
    checkEqual(i1.Value, i3, 'FromObfuscated');
    i1.Value := 0;
    timer.Start;
    for i := 1 to 100000 do
    begin
      gen.ComputeNew(i2);
      check(i2.Value <> 0);
      Check(i1.Value <> i2.Value, 'ComputeNew');
      i1 := i2;
    end;
    NotifyTestSpeed('ComputeNew', gen.ComputedCount, 0, @timer);
    check(i1.Value <> 0);
    check(i2.Value <> 0);
    js := i1.JavaScriptID;
    check(js < MAX_SAFE_JS_INTEGER);
    check(i1.Value <> 0);
    check(i2.Value <> 0);
    CheckEqual(js, i1.JavaScriptID);
    CheckEqual(i1.Value, i2.Value);
    i2.Value := 0;
    CheckNotEqual(i1.Value, i2.Value);
    CheckNotEqual(js, i2.JavaScriptID);
    i2.JavaScriptID := js;
    CheckEqual(i1.Value, i2.Value);
  finally
    gen.Free;
  end;
end;

type
  TSDKey = record
    i: integer;
    u: TGuid;
    j: integer;
  end;
  TSDKeys = array of TSDKey;

{  TSynDictionary perf numbers on increasing integers or random guid strings
   with FPC 3.2.0 on x86_64 with our fpcx64mm - which is our main server target

 About Find(), we tested 3 scenarios based on the pre-computed r[] lookups

 A) r[i] := i;  =  unrealistic case, but best performance

 count=1,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=8KB col=5.1K curcol=1K 107%  add 6.1M/s find 14M/s
  crc32c int  setcap slots=8KB col=1K curcol=1K 108%  add 12.2M/s find 14.9M/s
  crc32c guid grow   slots=8KB col=3.2K curcol=497 49%  add 6.7M/s find 14.6M/s
  crc32c guid setcap slots=8KB col=489 curcol=489 48%  add 13.6M/s find 14.9M/s
  aesni  int  grow   slots=8KB col=3.3K curcol=466 46%  add 6.9M/s find 15.6M/s
  aesni  int  setcap slots=8KB col=466 curcol=466 46%  add 12.8M/s find 15.8M/s
  aesni  guid grow   slots=8KB col=4K curcol=587 58%  add 6.2M/s find 14M/s
  aesni  guid setcap slots=8KB col=540 curcol=540 54%  add 13.2M/s find 14.2M/s
 count=10,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=64KB col=17.9K curcol=2.3K 24%  add 9.9M/s find 19.3M/s
  crc32c int  setcap slots=128KB col=1.2K curcol=1.2K 12%  add 17.1M/s find 20M/s
  crc32c guid grow   slots=64KB col=33K curcol=7.7K 79%  add 6.5M/s find 13.9M/s
  crc32c guid setcap slots=128KB col=2.1K curcol=2.1K 22%  add 8M/s find 15.3M/s
  aesni  int  grow   slots=64KB col=33.1K curcol=7.9K 81%  add 7.2M/s find 14.1M/s
  aesni  int  setcap slots=128KB col=2.1K curcol=2.1K 22%  add 15M/s find 18M/s
  aesni  guid grow   slots=64KB col=33.2K curcol=7.1K 73%  add 6.3M/s find 14M/s
  aesni  guid setcap slots=128KB col=2.1K curcol=2.1K 21%  add 14M/s find 16.8M/s
 count=100,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=512KB col=185.9K curcol=74.6K 76%  add 6.2M/s find 11.1M/s
  crc32c int  setcap slots=1MB col=15.3K curcol=15.3K 15%  add 8.3M/s find 14.4M/s
  crc32c guid grow   slots=512KB col=358.1K curcol=156K 159%  add 3.8M/s find 6M/s
  crc32c guid setcap slots=1MB col=30.2K curcol=30.2K 30%  add 7.8M/s find 8M/s
  aesni  int  grow   slots=512KB col=366.8K curcol=155.2K 158%  add 3.7M/s find 6.6M/s
  aesni  int  setcap slots=1MB col=29.7K curcol=29.7K 30%  add 6.2M/s find 10M/s
  aesni  guid grow   slots=512KB col=360K curcol=158.5K 162%  add 3.5M/s find 5.7M/s
  aesni  guid setcap slots=1MB col=30.3K curcol=30.3K 31%  add 6.9M/s find 7.8M/s
 count=1,000,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=7.9MB col=2.9M curcol=503.6K 51%  add 2.7M/s find 6M/s
  crc32c int  setcap slots=7.9MB col=503.6K curcol=503.6K 51%  add 5.9M/s find 6M/s
  crc32c guid grow   slots=7.9MB col=3.6M curcol=454.9K 46%  add 1.6M/s find 4.4M/s
  crc32c guid setcap slots=7.9MB col=452.1K curcol=452.1K 46%  add 4.5M/s find 4.4M/s
  aesni  int  grow   slots=7.9MB col=3.6M curcol=453.6K 46%  add 1.6M/s find 4.6M/s
  aesni  int  setcap slots=7.9MB col=453.6K curcol=453.6K 46%  add 4.7M/s find 4.6M/s
  aesni  guid grow   slots=7.9MB col=3.6M curcol=457.8K 46%  add 1.6M/s find 4.4M/s
  aesni  guid setcap slots=7.9MB col=454.2K curcol=454.2K 46%  add 4.4M/s find 4.4M/s
 count=10,000,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=63.2MB col=28.6M curcol=6.4M 67%  add 2.3M/s find 5.1M/s
  crc32c int  setcap slots=79.7MB col=4.5M curcol=4.5M 47%  add 5.2M/s find 5.6M/s
  crc32c guid grow   slots=63.2MB col=32.5M curcol=7.2M 76%  add 1.4M/s find 3.3M/s
  crc32c guid setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 3.9M/s find 4M/s
  aesni  int  grow   slots=63.2MB col=32.4M curcol=7.2M 75%  add 1.5M/s find 3.6M/s
  aesni  int  setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 4.1M/s find 4.2M/s
  aesni  guid grow   slots=63.2MB col=32.6M curcol=7.2M 75%  add 1.4M/s find 3.3M/s
  aesni  guid setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 3.9M/s find 3.9M/s

 B) r[i] := Random32((Count shr 2) - 1) - maybe realistic use case (25% coverage)

 count=1,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=8KB col=5.1K curcol=1K 107%  add 6.9M/s find 18.7M/s
  crc32c int  setcap slots=8KB col=1K curcol=1K 108%  add 13.8M/s find 19M/s
  crc32c guid grow   slots=8KB col=4K curcol=540 54%  add 6.1M/s find 19.8M/s
  crc32c guid setcap slots=8KB col=395 curcol=395 39%  add 14M/s find 20.2M/s
  aesni  int  grow   slots=8KB col=3.3K curcol=478 47%  add 7.2M/s find 20.2M/s
  aesni  int  setcap slots=8KB col=478 curcol=478 47%  add 14.6M/s find 20.7M/s
  aesni  guid grow   slots=8KB col=4.3K curcol=531 53%  add 5.9M/s find 18.3M/s
  aesni  guid setcap slots=8KB col=437 curcol=437 43%  add 13.4M/s find 19M/s
 count=10,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=64KB col=17.9K curcol=2.3K 24%  add 9.8M/s find 17.8M/s
  crc32c int  setcap slots=128KB col=1.2K curcol=1.2K 12%  add 17.4M/s find 17.5M/s
  crc32c guid grow   slots=64KB col=31.2K curcol=7.5K 77%  add 6.8M/s find 17.3M/s
  crc32c guid setcap slots=128KB col=2.1K curcol=2.1K 21%  add 10.9M/s find 11.5M/s
  aesni  int  grow   slots=64KB col=31.5K curcol=7.3K 74%  add 7.4M/s find 16.1M/s
  aesni  int  setcap slots=128KB col=2K curcol=2K 21%  add 16.1M/s find 17.4M/s
  aesni  guid grow   slots=64KB col=32.2K curcol=7.3K 75%  add 6.3M/s find 16.4M/s
  aesni  guid setcap slots=128KB col=2.1K curcol=2.1K 22%  add 14.7M/s find 16.4M/s
 count=100,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=512KB col=185.9K curcol=74.6K 76%  add 5.9M/s find 10.3M/s
  crc32c int  setcap slots=1MB col=15.3K curcol=15.3K 15%  add 9.4M/s find 8.9M/s
  crc32c guid grow   slots=512KB col=366.7K curcol=153.2K 156%  add 3.9M/s find 6.8M/s
  crc32c guid setcap slots=1MB col=30.2K curcol=30.2K 31%  add 6.9M/s find 6.1M/s
  aesni  int  grow   slots=512KB col=355.4K curcol=156.2K 160%  add 3.8M/s find 7.3M/s
  aesni  int  setcap slots=1MB col=29.6K curcol=29.6K 30%  add 6.2M/s find 8.8M/s
  aesni  guid grow   slots=512KB col=362.3K curcol=158.4K 162%  add 3.7M/s find 5.9M/s
  aesni  guid setcap slots=1MB col=30K curcol=30K 30%  add 6.9M/s find 5.8M/s
 count=1,000,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=7.9MB col=2.9M curcol=503.6K 51%  add 2.7M/s find 2.3M/s
  crc32c int  setcap slots=7.9MB col=503.6K curcol=503.6K 51%  add 5.8M/s find 2.3M/s
  crc32c guid grow   slots=7.9MB col=3.6M curcol=455.7K 46%  add 1.6M/s find 2.4M/s
  crc32c guid setcap slots=7.9MB col=456.5K curcol=456.5K 46%  add 4.5M/s find 2.4M/s
  aesni  int  grow   slots=7.9MB col=3.6M curcol=453.1K 46%  add 1.7M/s find 2.4M/s
  aesni  int  setcap slots=7.9MB col=453.1K curcol=453.1K 46%  add 4.7M/s find 2.3M/s
  aesni  guid grow   slots=7.9MB col=3.5M curcol=452K 46%  add 1.6M/s find 2.3M/s
  aesni  guid setcap slots=7.9MB col=452.9K curcol=452.9K 46%  add 4.5M/s find 2.3M/s
 count=10,000,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=63.2MB col=28.6M curcol=6.4M 67%  add 2.3M/s find 2M/s
  crc32c int  setcap slots=79.7MB col=4.5M curcol=4.5M 47%  add 5.2M/s find 2M/s
  crc32c guid grow   slots=63.2MB col=32.6M curcol=7.2M 75%  add 1.4M/s find 2M/s
  crc32c guid setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 3.9M/s find 1.9M/s
  aesni  int  grow   slots=63.2MB col=32.5M curcol=7.2M 75%  add 1.5M/s find 2M/s
  aesni  int  setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 4.1M/s find 2M/s
  aesni  guid grow   slots=63.2MB col=32.5M curcol=7.2M 75%  add 1.4M/s find 1.9M/s
  aesni  guid setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 3.9M/s find 2M/s

 C) r[i] := Random32(Count - 1) - worse case with full range coverage

 count=1,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=8KB col=5.1K curcol=1K 107%  add 6.5M/s find 13.8M/s
  crc32c int  setcap slots=8KB col=1K curcol=1K 108%  add 13.6M/s find 14.6M/s
  crc32c guid grow   slots=8KB col=3.6K curcol=574 57%  add 6.1M/s find 14.6M/s
  crc32c guid setcap slots=8KB col=527 curcol=527 52%  add 13.2M/s find 15.6M/s
  aesni  int  grow   slots=8KB col=3.7K curcol=479 47%  add 7M/s find 16.4M/s
  aesni  int  setcap slots=8KB col=480 curcol=480 48%  add 12.2M/s find 16.7M/s
  aesni  guid grow   slots=8KB col=3K curcol=514 51%  add 6.5M/s find 15.1M/s
  aesni  guid setcap slots=8KB col=527 curcol=527 52%  add 13M/s find 14.6M/s
 count=10,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=64KB col=17.9K curcol=2.3K 24%  add 9.7M/s find 13.9M/s
  crc32c int  setcap slots=128KB col=1.2K curcol=1.2K 12%  add 17.3M/s find 14.4M/s
  crc32c guid grow   slots=64KB col=30.4K curcol=7.1K 73%  add 6.4M/s find 10M/s
  crc32c guid setcap slots=128KB col=2.1K curcol=2.1K 22%  add 9.7M/s find 9.3M/s
  aesni  int  grow   slots=64KB col=30.8K curcol=7.6K 77%  add 7.2M/s find 10.7M/s
  aesni  int  setcap slots=128KB col=2.1K curcol=2.1K 22%  add 14.2M/s find 12.2M/s
  aesni  guid grow   slots=64KB col=32.6K curcol=7.9K 81%  add 6M/s find 9.4M/s
  aesni  guid setcap slots=128KB col=2.1K curcol=2.1K 21%  add 13.8M/s find 7.1M/s
 count=100,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=512KB col=185.9K curcol=74.6K 76%  add 6.8M/s find 2.9M/s
  crc32c int  setcap slots=1MB col=15.3K curcol=15.3K 15%  add 6.4M/s find 3.2M/s
  crc32c guid grow   slots=512KB col=367.9K curcol=159.9K 163%  add 3.7M/s find 2.3M/s
  crc32c guid setcap slots=1MB col=30.8K curcol=30.8K 31%  add 7.1M/s find 2.5M/s
  aesni  int  grow   slots=512KB col=361.5K curcol=157.8K 161%  add 3.5M/s find 2.4M/s
  aesni  int  setcap slots=1MB col=29.5K curcol=29.5K 30%  add 5.4M/s find 2.9M/s
  aesni  guid grow   slots=512KB col=356.2K curcol=156.4K 160%  add 3.2M/s find 2.3M/s
  aesni  guid setcap slots=1MB col=30.7K curcol=30.7K 31%  add 7.4M/s find 3M/s
 count=1,000,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=7.9MB col=2.9M curcol=503.6K 51%  add 2.7M/s find 1.8M/s
  crc32c int  setcap slots=7.9MB col=503.6K curcol=503.6K 51%  add 5.8M/s find 1.8M/s
  crc32c guid grow   slots=7.9MB col=3.5M curcol=453K 46%  add 1.6M/s find 1.8M/s
  crc32c guid setcap slots=7.9MB col=454.2K curcol=454.2K 46%  add 4.5M/s find 1.8M/s
  aesni  int  grow   slots=7.9MB col=3.6M curcol=456.4K 46%  add 1.7M/s find 1.8M/s
  aesni  int  setcap slots=7.9MB col=456.4K curcol=456.4K 46%  add 4.7M/s find 1.8M/s
  aesni  guid grow   slots=7.9MB col=3.6M curcol=452.6K 46%  add 1.6M/s find 1.8M/s
  aesni  guid setcap slots=7.9MB col=453.3K curcol=453.3K 46%  add 4.2M/s find 1.8M/s
 count=10,000,000 DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2
  crc32c int  grow   slots=63.2MB col=28.6M curcol=6.4M 67%  add 2.3M/s find 1.5M/s
  crc32c int  setcap slots=79.7MB col=4.5M curcol=4.5M 47%  add 5.2M/s find 1.5M/s
  crc32c guid grow   slots=63.2MB col=32.5M curcol=7.2M 75%  add 1.4M/s find 1.4M/s
  crc32c guid setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 3.9M/s find 1.5M/s
  aesni  int  grow   slots=63.2MB col=32.5M curcol=7.2M 75%  add 1.5M/s find 1.5M/s
  aesni  int  setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 4.1M/s find 1.5M/s
  aesni  guid grow   slots=63.2MB col=32.5M curcol=7.2M 75%  add 1.4M/s find 1.4M/s
  aesni  guid setcap slots=79.7MB col=4.3M curcol=4.3M 45%  add 3.9M/s find 1.5M/s

  comments:
   1) r[i]=i is faster than r[i]=Random32() - up to 3x for count>100,000
     -> naive tests with simple loops are pointless - and we won't use a
        dictionary for a lookup from first to last item, anyway
   2) SetCapacity() makes Add() up to twice faster, but not affects Find() much
   3) Only default DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2 settings are shown,
      since we found out that this combination was a good balance,
      but you can recompile the tests to compare with other algorithms
   => CPU cache size seems to have a bigger impact than our TSynDictionary :)
}

{.$define DYNARRAYHASHCOLLISIONCOUNT}
// should also be defined in mormot.core.data.pas to have detailed information

procedure TTestCoreBase.TSynDictionarySlow(Context: TObject);
type
  tvalue = variant;
  tvalues = TVariantDynArray;
const
  MAX = 10000;
var
  dict: TSynDictionary;
  rnd: PLecuyer; // local per-thread instance

  procedure TestSpeed(Count: integer; SetCapacity, DoText: boolean;
    Hasher: THasher; const Msg: RawUtf8);
  var
    timer: TPrecisionTimer;
    i: PtrInt;
    v: integer;
    dic: TSynDictionary;
    a: TRawUtf8DynArray;
    r: TIntegerDynArray;
  begin
    if not Assigned(Hasher) then
      exit; // AesNiHash32 not available on this platform
    SetLength(a, Count);
    SetLength(r, Count);
    for i := 0 to High(a) do // pre-computed values and indexes for fairness
    begin
      v := rnd.Next(Count shr 2) shl 2; // realistic 25% coverage
      Check(v < Count, 'random32 overflow');
      r[i] := v;
      if DoText then
        rnd.FillAscii(38, a[i])
      else
        UInt32ToUtf8(i, a[i]);
    end;
    dic := TSynDictionary.Create(TypeInfo(TRawUtf8DynArray),
      TypeInfo(TIntegerDynArray), false, 0, nil, Hasher);
    dic.ThreadUse := uNoLock; // faster without locking
    if SetCapacity then
      dic.Capacity := Length(a);
    timer.Start;
    for i := 0 to High(a) do
    begin
      v := i;
      dic.Add(a[i], v);
    end;
    NotifyTestSpeed('add  %', [Msg], Count, 0, @timer, {onlylog=}
    {$ifdef DYNARRAYHASHCOLLISIONCOUNT} false);
    write(' ', Msg, ' slots=', KBNoSpace(dic.Keys.Hasher.HashTableSize * 4),
      ' col=', K(dic.Keys.Hasher.CountCollisions), ' curcol=',
      K(dic.Keys.Hasher.CountCollisionsCurrent),
      ' ', (dic.Keys.Hasher.CountCollisionsCurrent * 100) div Count,
      '%  add ', K(timer.PerSec(count)), '/s');
    {AddConsole(FormatString('collisions: total=% current=% %%',
      [dic.Keys.Hasher.CountCollisions, dic.Keys.Hasher.CountCollisionsCurrent,
       (dic.Keys.Hasher.CountCollisionsCurrent * 100) div Count, '%']));}
    {$else} true); {$endif DYNARRAYHASHCOLLISIONCOUNT}
    timer.Start;
    for i := 0 to High(a) do
    begin
      // FindAndCopy + random index from 25% of the content
      Check(dic.FindAndCopy(a[r[i]], v));
      Check(v = r[i]);
    end;
    NotifyTestSpeed('find %', [Msg], Count, 0, @timer, {onlylog=}
    {$ifdef DYNARRAYHASHCOLLISIONCOUNT} false);
    writeln(' find ', K(timer.PerSec(count)), '/s');
    {$else} true); {$endif DYNARRAYHASHCOLLISIONCOUNT}
    dic.Free;
  end;

  procedure Test;
  var
    k: RawUtf8;
    v: tvalue;
    i: integer;
  begin
    check(dict.Count = MAX);
    for i := 1 to MAX do
    begin
      UInt32ToUtf8(i, k);
      v := 0;
      check(dict.Exists(k));
      check(dict.FindAndCopy(k, v));
      check(v = i);
    end;
  end;

  procedure SetDict;
  begin
    {$ifdef HASGENERICS}
    dict := TSynDictionary.New<RawUtf8, RawUtf8>(True);
    {$else}
    dict := TSynDictionary.Create(TypeInfo(TRawUtf8DynArray), TypeInfo(TRawUtf8DynArray), True);
    {$endif HASGENERICS}
  end;

var
  v, kv: tvalue;
  s, k, key, val, u, json: RawUtf8;
  i, n: integer;
  i64: Int64;
  exists: boolean;
  b: byte;
  sdk: TSDKey;
begin
  rnd := ThreadRandom; // use the TLecuyer of this thread
  SetDict;
  try
    CheckEqual(dict.Count, 0);
    CheckEqual(dict.Capacity, 0);
  finally
    dict.Free;
  end;
  dict := TSynDictionary.Create(TypeInfo(TRawUtf8DynArray), TypeInfo(TRawUtf8DynArray), True);
  try
    CheckEqual(dict.Count, 0);
    CheckEqual(dict.Capacity, 0);
    dict.Capacity := 64;
    CheckEqual(dict.Count, 0);
    CheckEqual(dict.Capacity, 64);
  finally
    dict.Free;
  end;
  SetDict;
  try
    CheckEqual(dict.Count, 0);
    CheckEqual(dict.Capacity, 0);
    key := 'Foobar';
    val := 'lol';
    Check(dict.AddOrUpdate(key, val) >= 0);
    CheckEqual(dict.Count, 1);
    json := dict.SaveToJson;
    CheckEqual(json, '{"Foobar":"lol"}');
    key := 'foobar';
    val := 'xxx';
    dict.AddOrUpdate(key, val);
    json := dict.SaveToJson;
    CheckEqual(json, '{"Foobar":"xxx"}');
    CheckEqual(dict.Count, 1);
    key := 'FooBar';
    dict.FindAndCopy(key, val, False);
    CheckEqual(val, 'xxx');
  finally
    dict.Free;
  end;
  {$ifdef DYNARRAYHASHCOLLISIONCOUNT}
  n := 1000;
  for i := 1 to 5 do
  {$else}
  n := 100;
  for i := 1 to 3 do
  {$endif DYNARRAYHASHCOLLISIONCOUNT}
  begin
    {$ifdef DYNARRAYHASHCOLLISIONCOUNT}
    writeln('count=', IntToThousandString(n), ' DYNARRAYHASH_LEMIRE + DYNARRAYHASH_PO2');
    {$endif DYNARRAYHASHCOLLISIONCOUNT}
    TestSpeed(n, false, false, crc32c, 'crc32c int  grow  ');
    TestSpeed(n, true,  false, crc32c, 'crc32c int  setcap');
    TestSpeed(n, false, true,  crc32c, 'crc32c guid grow  ');
    TestSpeed(n, true,  true,  crc32c, 'crc32c guid setcap');
    TestSpeed(n, false, false, AesNiHash32, 'aesni  int  grow  ');
    TestSpeed(n, true,  false, AesNiHash32, 'aesni  int  setcap');
    TestSpeed(n, false, true,  AesNiHash32, 'aesni  guid grow  ');
    TestSpeed(n, true,  true,  AesNiHash32, 'aesni  guid setcap');
    n := n * 10;
  end;
  dict := TSynDictionary.Create(TypeInfo(TRawUtf8DynArray), TypeInfo(tvalues));
  try
    for i := 1 to MAX do
    begin
      UInt32ToUtf8(i, k);
      v := i;
      check(dict.Add(k, v) = i - 1);
    end;
    Test;
    json := dict.SaveToJson;
    check(dict.Exists(k));
    dict.DeleteAll;
    check(dict.Count = 0);
    check(not dict.Exists(k));
    check(dict.LoadFromJson(json));
    Test;
    s := dict.SaveToBinary;
    u := '{"a":1,"b":2}';
    check(dict.LoadFromJson(u));
    CheckEqual(dict.SaveToJson, u);
    check(dict.LoadFromJson('{a:1,b:2}'), 'extended syntax');
    CheckEqual(dict.SaveToJson, u);
    check(dict.LoadFromJson('{a:1,2:{b:3,c:4}}'));
    CheckEqual(dict.SaveToJson, '{"a":1,"2":{"b":3,"c":4}}');
  finally
    dict.Free;
  end;
  dict := TSynDictionary.Create(TypeInfo(TRawUtf8DynArray), TypeInfo(tvalues));
  try
    check(dict.LoadFromBinary(s));
    Test;
    for i := MAX downto 1 do
      if i and 127 = 0 then
      begin
        UInt32ToUtf8(i, k);
        check(dict.Delete(k) = i - 1);
        check(dict.Exists(k) = false);
      end;
    for i := 1 to MAX do
    begin
      exists := (i and 127) <> 0;
      UInt32ToUtf8(i, k);
      check(dict.Exists(k) = exists);
      if exists then
      begin
        v := 0;
        check(dict.FindAndCopy(k, v));
        check(v = i);
        if i < 10000 then
        begin
          // FindKeyFromValue() brute force is slow
          k := '';
          check(dict.FindKeyFromValue(v, k));
          check(GetInteger(pointer(k)) = i);
        end;
      end;
    end;
  finally
    dict.Free;
  end;
  // keys which are not serialized as JSON string
  dict := TSynDictionary.Create(TypeInfo(TInt64DynArray), TypeInfo(tvalues));
  try
    for i := 1 to MAX do
    begin
      i64 := i;
      v := i;
      check(dict.Add(i64, v) = i - 1);
    end;
    json := dict.SaveToJson;
    Check(IsValidUtf8(json));
    Check(IsValidJson(json));
    if MAX = 10000 then
      CheckHash(json, $F67B5FA8, 'dict.savetojson');
    for i := 1 to MAX do
    begin
      i64 := i;
      check(dict.FindAndCopy(i64, v));
      check(v = i);
    end;
  finally
    dict.Free;
  end;
  dict := TSynDictionary.Create(TypeInfo(TInt64DynArray), TypeInfo(tvalues));
  try
    check(dict.LoadFromJson(json));
    if MAX = 10000 then
      CheckHash(json, $F67B5FA8, 'untouched after loadfromjson');
    checkEqual(json, dict.SaveToJson);
    for i := 1 to MAX do
    begin
      i64 := i;
      check(dict.FindAndCopy(i64, v));
      check(v = i);
    end;
  finally
    dict.Free;
  end;
  // keys with no standard RTTI: fallback to binary hash/compare
  FillCharFast(sdk, SizeOf(sdk), 0);
  v := 10;
  dict := TSynDictionary.Create(TypeInfo(TSDKeys), TypeInfo(tvalues));
  try
    CheckEqual(dict.Count, 0);
    CheckEqual(dict.Capacity, 0);
    Check(not dict.FindAndCopy(sdk, v));
    Check(dict.Add(sdk, v) = 0);
    v := 1;
    Check(v = 1);
    Check(dict.FindAndCopy(sdk, v));
    Check(v = 10);
    sdk.j := 1;
    Check(not dict.FindAndCopy(sdk, v));
    sdk.j := 0;
    CheckEqual(dict.Count, 1);
    Check(dict.Capacity > 0);
  finally
    dict.Free;
  end;
  dict := TSynDictionary.Create(TypeInfo(TSDKeys), TypeInfo(tvalues), false,
    0, nil, nil, ptInteger);
  try
    Check(not dict.FindAndCopy(sdk, v));
    Check(dict.Add(sdk, v) = 0);
    v := 1;
    Check(dict.FindAndCopy(sdk, v));
    Check(v = 10);
    v := 1;
    sdk.j := 1;
    Check(dict.FindAndCopy(sdk, v), 'ptInteger=search i only');
    Check(v = 10);
  finally
    dict.Free;
  end;
  // validate variant as keys, with proper hashing of simple or complex types
  {$ifdef HASGENERICS}
  dict := TSynDictionary.New<variant, byte>;
  {$else}
  dict := TSynDictionary.Create(TypeInfo(TVariantDynArray), TypeInfo(TByteDynArray));
  {$endif HASGENERICS}
  try
    kv := byte(1);
    CheckEqual(TVarData(kv).VType, varByte);
    b := 0;
    Check(not dict.FindAndCopy(kv, b));
    b := 255;
    CheckEqual(dict.Add(kv, b), 0);
    b := 0;
    Check(dict.FindAndCopy(kv, b));
    CheckEqual(b, 255);
    kv := integer(1);
    CheckEqual(TVarData(kv).VType, varInteger);
    b := 0;
    Check(dict.FindAndCopy(kv, b));
    CheckEqual(b, 255);
    RawUtf8ToVariant('toto', kv);
    b := 0;
    Check(not dict.FindAndCopy(kv, b));
    b := 254;
    CheckEqual(dict.Add(kv, b), 1);
    b := 0;
    Check(dict.FindAndCopy(kv, b));
    CheckEqual(b, 254);
    kv := word(1);
    CheckEqual(TVarData(kv).VType, varWord);
    Check(dict.FindAndCopy(kv, b));
    CheckEqual(b, 255);
    kv := _JsonFast('[1,2,{a:3}]');
    b := 0;
    Check(not dict.FindAndCopy(kv, b));
    b := 253;
    CheckEqual(dict.Add(kv, b), 2);
    kv := WideString('toto');
    CheckEqual(TVarData(kv).VType, varOleStr);
    Check(dict.FindAndCopy(kv, b));
    CheckEqual(b, 254);
    kv := _JsonFast('[ 1, 2, {"a":3} ]');
    Check(dict.FindAndCopy(kv, b), 'json should not matter');
    CheckEqual(b, 253);
finally
    dict.Free;
  end;
end;

procedure TTestCoreBase.DeltaCompression;
var
  o, n, d, s: RawByteString;
  i, j, size, diff, percent: integer;
  comp, extr: TPrecisionTimer;
  res: TDeltaError;
begin
  n := RandomTextParagraph(100);
  d := DeltaCompress(n, o{%H-});
  check(DeltaExtract(d, o, s) = dsSuccess, 'delta0');
  Check(s = n);{%H-}
  d := DeltaCompress(n, s);
  check(d = '=');
  check(DeltaExtract(d, n, s) = dsSuccess, 'delta=');
  Check(s = n);
  comp.Init;
  extr.Init;
  size := 0;
  for i := 1 to 20 do
  begin
    o := n;
    s := RandomTextParagraph(200 + i shr 3);
    for j := 1 to (i shr 2) + 1 do
      case Random32 and 7 of
        2:
          Append(n, s);
        5:
          delete(n, i * ord(s[j]), j * 3);
        7:
          Prepend(n, s);
      else
        insert(s, n, i * ord(s[j]));
      end;
    inc(size, length(n));
    comp.Resume;
    d := DeltaCompress(n, o);
    comp.Pause;
    diff := length(n) - length(o);
    percent := (100 * length(d)) div diff;
    //ConsoleWrite('%k delta=% diff=% %%', [length(n) shr 10, length(d), diff, percent, '%']);
    check(d <> '=');
    if diff > 100 then
      check(percent < 200, 'delta compressed');
    s := '';
    extr.Resume;
    res := DeltaExtract(d, o, s);
    {if res <> dsSuccess then begin
      d := DeltaCompress(n, o);
      res := DeltaExtract(d, o, s);
    end;}
    checkUtf8(res = dsSuccess, '%', [ToText(res)^]);
    extr.Pause;
    CheckEqual(s, n);
  end;
  NotifyTestSpeed('DeltaCompress', 1, size, @comp);
  NotifyTestSpeed('DeltaExtract', 1, size, @extr);
  o := n;
  delete(n, 100, 100);
  d := DeltaCompress(n, o);
  check(DeltaExtract(d, o, s) = dsSuccess, 'delta-');
  Check(s = n);
  o := n;
  delete(n, 1000, 100);
  insert(RandomIdentifier(50), n, 200);
  d := DeltaCompress(n, o);
  check(DeltaExtract(d, o, s) = dsSuccess, 'delta-+');
  CheckEqual(s, n, 'delta extract');
end;

procedure TTestCoreBase.BloomFilters;
const
  SIZ = 200000;
var
  b: TSynBloomFilter;
  d1, d2: TSynBloomFilterDiff;
  i, j, n: integer;
  falsepositive: double;
  sav1000, savSIZ: RawByteString;
begin
  b := TSynBloomFilter.Create(SIZ + 5000);
  try
    CheckSame(b.FalsePositivePercent, 1);
    Check(b.Size = SIZ + 5000);
    Check(b.Bits > b.Size shl 3);
    Check(b.HashFunctions = 7);
    Check(b.Inserted = 0);
    CheckLogTimeStart;
    for i := 1 to SIZ do
      Check(not b.MayExist(@i, SizeOf(i)));
    CheckLogTime(b.Inserted = 0, 'MayExists(%)=false', [SIZ]);
    for i := 1 to 1000 do
      b.Insert(@i, SizeOf(i));
    CheckLogTime(b.Inserted = 1000, 'Insert(%)', [b.Inserted]);
    sav1000 := b.SaveTo;
    CheckLogTime(sav1000 <> '', 'b.SaveTo(%) len=%', [b.Inserted, kb(sav1000)]);
    for i := 1001 to SIZ do
      b.Insert(@i, SizeOf(i));
    CheckLogTime(b.Inserted = SIZ, 'Insert(%)', [SIZ - 1000]);
    savSIZ := b.SaveTo;
    CheckLogTime(length(savSIZ) > length(sav1000), 'b.SaveTo(%) len=%',
      [SIZ, kb (savSIZ)]);
    for i := 1 to SIZ do
      Check(b.MayExist(@i, SizeOf(i)));
    CheckLogTime(b.Inserted = SIZ, 'MayExists(%)=true', [SIZ]);
    n := 0;
    for i := SIZ + 1 to SIZ + SIZ shr 5 do
      if b.MayExist(@i, SizeOf(i)) then
        inc(n);
    falsepositive := (n * 100) / (SIZ shr 5); // always 0.704 for crc32c
    // 0.9 with crc, 0.7-1.3 with AesNiHash32 depending on its seed
    CheckLogTime(falsepositive < 1.5, 'falsepositive=%', [falsepositive]);
    b.Reset;
    CheckLogTime(b.Inserted = 0, 'b.Reset', []);
    for i := 1 to SIZ do
      Check(not b.MayExist(@i, SizeOf(i)));
    CheckLogTime(b.Inserted = 0, 'MayExists(%)=false', [SIZ]);
    CheckLogTime(b.LoadFrom(sav1000), 'b.LoadFrom(%)', [1000]);
    for i := 1 to 1000 do
      Check(b.MayExist(@i, SizeOf(i)));
    CheckLogTime(b.Inserted = 1000, 'MayExists(%)=true', [1000]);
  finally
    b.Free;
  end;
  CheckLogTime(true, 'b.Free', []);
  d1 := TSynBloomFilterDiff.Create(savSIZ);
  try
    CheckLogTime(true, 'd1 := TSynBloomFilterDiff.Create(%)', [SIZ]);
    CheckSame(d1.FalsePositivePercent, 1);
    Check(d1.Size = SIZ + 5000);
    Check(d1.Bits > d1.Size shl 3);
    Check(d1.HashFunctions = 7);
    for i := 1 to SIZ do
      Check(d1.MayExist(@i, SizeOf(i)));
    CheckLogTime(d1.Inserted = SIZ, 'MayExists(%)=true', [SIZ]);
    d2 := TSynBloomFilterDiff.Create;
    try
      Check(d2.Revision = 0);
      n := SIZ;
      for j := 1 to 3 do
      begin
        savSIZ := d1.SaveToDiff(d2.Revision);
        CheckLogTime(savSIZ <> '', 'd1.SaveToDiff(%) len=%', [d2.Revision, KB(savSIZ)]);
        Check(d1.DiffKnownRevision(savSIZ) = d1.Revision);
        Check((d2.Revision = d1.Revision) = (j > 1));
        CheckLogTime(d2.LoadFromDiff(savSIZ), 'd2.LoadFromDiff(%)', [n]);
        Check(d2.Revision = d1.Revision);
        Check(d2.Size = d1.Size);
        for i := 1 to n do
          Check(d2.MayExist(@i, SizeOf(i)));
        CheckLogTime(d2.Inserted = cardinal(n), 'MayExists(%)=true', [n]);
        for i := n + 1 to n + 1000 do
          d1.Insert(@i, SizeOf(i));
        CheckLogTime(d2.Revision <> d1.Revision, 'd1.Insert(%)', [1000]);
        savSIZ := d1.SaveToDiff(d2.Revision);
        CheckLogTime(savSIZ <> '', 'd1.SaveToDiff(%) len=%', [d2.Revision, kb(savSIZ)]);
        Check(d1.DiffKnownRevision(savSIZ) = d1.Revision);
        Check(d2.Revision <> d1.Revision);
        CheckLogTime(d2.LoadFromDiff(savSIZ), 'd2.LoadFromDiff(%)', [n]);
        Check(d2.Revision = d1.Revision);
        inc(n, 1000);
        for i := 1 to n do
          Check(d2.MayExist(@i, SizeOf(i)));
        CheckLogTime(d2.Inserted = cardinal(n), 'MayExists(%)=true', [n]);
        Check(d2.Inserted = cardinal(n));
        if j = 2 then
        begin
          d1.DiffSnapshot;
          CheckLogTime(d2.Revision = d1.Revision, 'd1.DiffSnapshot', []);
        end;
      end;
    finally
      d2.Free;
      CheckLogTime(true, 'd2.Free', []);
    end;
  finally
    d1.Free;
    CheckLogTime(true, 'd1.Free', []);
  end;
end;

procedure TTestCoreBase._TObjArray;
const
  MAX = 200;
var
  i: integer;
  arr: TPersistentAutoCreateFieldsTestObjArray;
  test, test2: TObjArrayTest;
  p: TPersistentAutoCreateFieldsTest;
  r1, r2: TOrmArrayTest;
  tmp: RawUtf8;
  valid: boolean;

  procedure CheckValues(test: TComplexNumberObjArray);
  var
    i: integer;
  begin
    CheckEqual(length(test), MAX + 1);
    for i := 0 to MAX do
    begin
      CheckSame(test[i].Real, 0.5 + i);
      CheckSame(test[i].Imaginary, 0.2 + i);
    end;
  end;

begin
  {$ifndef HASDYNARRAYTYPE}
  Rtti.RegisterObjArray(TypeInfo(TPersistentAutoCreateFieldsTestObjArray),
    TPersistentAutoCreateFieldsTest);
  {$endif HASDYNARRAYTYPE}
  try
    tmp := DynArraySaveJson(arr{%H-}, TypeInfo(TPersistentAutoCreateFieldsTestObjArray));
    check(tmp = '[]');
    p := TPersistentAutoCreateFieldsTest.CreateFake;
    ObjArrayAdd(arr, p);
    tmp := DynArraySaveJson(arr, TypeInfo(TPersistentAutoCreateFieldsTestObjArray));
    checkEqual(tmp, '[{"Text":"text","Value1":{"Real":1.5,"Imaginary":2.5},' +
      '"Value2":{"Real":1.7,"Imaginary":2.7}}]');
    for i := 1 to MAX do
    begin
      p := TPersistentAutoCreateFieldsTest.CreateFake;
      p.Value1.Real := p.Value1.Real + i * 1.0;
      Check(ObjArrayAdd(arr, p) = i);
    end;
    tmp := DynArraySaveJson(arr, TypeInfo(TPersistentAutoCreateFieldsTestObjArray));
    ObjArrayClear(arr);
    CheckEqual(length(arr), 0);
    DynArrayLoadJsonInPlace(arr, pointer(tmp), TypeInfo(TPersistentAutoCreateFieldsTestObjArray));
    CheckEqual(length(arr), MAX + 1);
    for i := 0 to MAX do
    begin
      Check(arr[i].text = 'text');
      CheckSame(arr[i].Value1.Real, 1.5 + i);
      CheckSame(arr[i].Value1.Imaginary, 2.5);
      CheckSame(arr[i].Value2.Real, 1.7);
      CheckSame(arr[i].Value2.Imaginary, 2.7);
    end;
  finally
    ObjArrayClear(arr);
  end;
  r1 := TOrmArrayTest.Create;
  r2 := TOrmArrayTest.Create;
  try
    check(r1.SameValues(r2));
  finally
    r2.Free;
    r1.Free;
  end;
  {$ifndef HASDYNARRAYTYPE}
  Rtti.RegisterObjArray(TypeInfo(TComplexNumberObjArray), TComplexNumber);
  {$endif HASDYNARRAYTYPE}
  test := TObjArrayTest.CreateFake;
  try
    for i := 0 to max do
      ObjArrayAdd(test.fValues, TComplexNumber.Create(0.5 + i, 0.2 + i));
    CheckValues(test.Values);
    tmp := ObjectToJson(test);
  finally
    test.Free;
  end;
  r1 := TOrmArrayTest.CreateFrom(tmp);
  r2 := TOrmArrayTest.CreateFrom(tmp);
  try
    CheckEqual(r1.IDValue, 0);
    CheckEqual(r2.IDValue, 0);
    CheckValues(r1.Values);
    CheckValues(r2.Values);
    check(r1.SameValues(r2));
  finally
    r2.Free;
    r1.Free;
  end;
  test := TObjArrayTest.CreateFake;
  test2 := TObjArrayTest.CreateFake;
  try
    check(ObjectLoadJson(test, tmp));
    CheckValues(test.Values);
    JsonToObject(test2, pointer(tmp), valid);
    Check(valid);
    CheckValues(test2.Values);
    check(ObjectEquals(test, test2));
  finally
    test2.Free;
    test.Free;
  end;
end;

function TOrmPeopleCompareByFirstName(const A, B): integer;
begin
  result := StrIComp(
    pointer(TOrmPeople(A).FirstName), pointer(TOrmPeople(B).FirstName));
end;

{$ifdef OSWINDOWS}

procedure TTestCoreBase.WindowsSpecificApi;

  procedure Win32DotNetException(code: cardinal; const expected: RawUtf8);
  var
    s: ShortString;
  begin
    s[0] := #0;
    Check(Win32DotNetExceptions(code, s) = (expected <> ''));
    CheckEqual(ShortStringToAnsi7String(s), expected);
  end;

var
  nfo: TWinProcessInfo;
begin
  // validate Windows API error code recognition
  CheckEqualShort(WinApiErrorShort(122), 'ERROR_INSUFFICIENT_BUFFER');
  CheckEqualShort(WinApiErrorShort(1246), 'ERROR__CONTINUE');
  CheckEqual(WinApiErrorUtf8(122), 'ERROR_INSUFFICIENT_BUFFER');
  Check(WinApiErrorString(122) = 'ERROR_INSUFFICIENT_BUFFER');
  Check(WinApiErrorString(1246) = 'ERROR__CONTINUE');
  // validate DotNet exceptions error code recognition
  Win32DotNetException(0, '');
  Win32DotNetException(9234, '');
  Win32DotNetException($800703E9, ' [.NET/CLR unhandled StackOverflowException]');
  Win32DotNetException($80131500,
    ' [.NET/CLR unhandled Exception SUDSGeneratorException SUDSParserException]');
  // validate UAC specific functions
  Check(IsSystemFolder('c:\program files'));
  Check(IsSystemFolder('c:\program Files\toto'));
  Check(IsSystemFolder('c:\Program files (x86)'));
  Check(IsSystemFolder('d:\Program Files (X86)\toto'));
  Check(IsSystemFolder('c:\windows'));
  Check(IsSystemFolder('c:\windows\toto'));
  Check(not IsSystemFolder('c:\program file'));
  Check(not IsSystemFolder('c:\program files other\toto'));
  Check(not IsSystemFolder('c:\windowstorage'));
  if IsUacVirtualizationEnabled then
  begin
    Check(IsUacVirtualFolder('c:\program files'));
    Check(IsUacVirtualFolder('c:\program Files\toto'));
    Check(IsUacVirtualFolder('c:\Program files (x86)'));
    Check(IsUacVirtualFolder('d:\Program Files (X86)\toto'));
    Check(IsUacVirtualFolder('c:\windows'));
    Check(IsUacVirtualFolder('c:\windows\toto'));
    Check(not IsUacVirtualFolder('c:\program file'));
    Check(not IsUacVirtualFolder('c:\program files other\toto'));
    Check(not IsUacVirtualFolder('c:\windowstorage'));
  end
  else
    Check(not IsUacVirtualFolder('c:\program files'));
  // validate raw Windows process access
  FillCharFast(nfo, SizeOf(nfo), 0);
  GetProcessInfo(GetCurrentProcessId, nfo);
  Check(nfo.CommandLine <> '', 'Cmd0');
  Check(PosEx(Executable.ProgramName, SynUnicodeToUtf8(nfo.CommandLine)) > 0, 'Cmd1');
  Check(nfo.AvailableInfo = [wpaiPID..wpaiImagePath], 'AvailableInfo');
  CheckEqual(nfo.PID, GetCurrentProcessId, 'PID');
  Check(nfo.AffinityMask <> 0, 'AffinityMask');
end;

{$endif OSWINDOWS}


initialization
  {$ifndef HASDYNARRAYTYPE}
  Rtti.RegisterObjArray(TypeInfo(TOrmPeopleObjArray), TOrmPeople);
  {$endif HASDYNARRAYTYPE}
  Rtti.RegisterFromText([TypeInfo(TRecordPeopleDynArray),
    'RowID:TID FirstName,LastName:RawUtf8 Data:RawBlob YearOfBirth:integer YearOfDeath:word'
  ]);

end.