2187 lines
72 KiB
ObjectPascal
2187 lines
72 KiB
ObjectPascal
{*****************************************************************************
|
||
The DEC team (see file NOTICE.txt) licenses this file
|
||
to you under the Apache License, Version 2.0 (the
|
||
"License"); you may not use this file except in compliance
|
||
with the License. A copy of this licence is found in the root directory of
|
||
this project in the file LICENCE.txt or alternatively at
|
||
|
||
http://www.apache.org/licenses/LICENSE-2.0
|
||
|
||
Unless required by applicable law or agreed to in writing,
|
||
software distributed under the License is distributed on an
|
||
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||
KIND, either express or implied. See the License for the
|
||
specific language governing permissions and limitations
|
||
under the License.
|
||
*****************************************************************************}
|
||
|
||
{$M+} // DUnitX would add it anyway
|
||
unit TestDECFormat;
|
||
|
||
interface
|
||
|
||
// Needs to be included before any other statements
|
||
{$INCLUDE TestDefines.inc}
|
||
|
||
uses
|
||
System.SysUtils, System.Classes,
|
||
{$IFDEF DUnitX}
|
||
DUnitX.TestFramework,DUnitX.DUnitCompatibility,
|
||
{$ELSE}
|
||
TestFramework,
|
||
{$ENDIF}
|
||
DECBaseClass, DECUtil, DECFormat, DECFormatBase;
|
||
|
||
type
|
||
/// <summary>
|
||
/// Type needed for the EncodeBytes und DecodeBytes test data definition
|
||
/// </summary>
|
||
TestRecRawByteString = record
|
||
Input, Output: RawByteString;
|
||
end;
|
||
|
||
/// <summary>
|
||
/// Type used for some IsValid test data lists
|
||
/// </summary>
|
||
TestRecIsValidRawByteString = record
|
||
Input : RawByteString;
|
||
Result : Boolean;
|
||
end;
|
||
|
||
/// <summary>
|
||
/// Type needed for passing the right encode or decode method to the
|
||
/// generic encode/decode test
|
||
/// </summary>
|
||
TEncodeDecodeProc = function(const data: TBytes):TBytes of Object;
|
||
/// <summary>
|
||
/// Type needed for passing the right encode or decode method to the
|
||
/// generic encode/decode test
|
||
/// </summary>
|
||
TEncodeDecodeProcRawByteString = function(const data: RawByteString):RawByteString of Object;
|
||
/// <summary>
|
||
/// Type needed for passing the right encode or decode method to the
|
||
/// generic encode/decode test
|
||
/// </summary>
|
||
TEncodeDecodeProcTypeless = function(const Data; Size: Integer): RawByteString of Object;
|
||
|
||
// Basic test implementations to be shared by the individual formatting class
|
||
// test classes to enable easier DUnit and DUnitX compatibility
|
||
TFormatTestsBase = class(TTestCase)
|
||
strict protected
|
||
procedure DoTestEncodeDecodeTypeless(
|
||
EncodeDecodeProc: TEncodeDecodeProcTypeless;
|
||
TestData: array of TestRecRawByteString);
|
||
|
||
procedure DoTestEncodeDecode(EncodeDecodeProc: TEncodeDecodeProc;
|
||
TestData: array of TestRecRawByteString);
|
||
|
||
procedure DoTestEncodeDecodeRawByteString(
|
||
EncodeDecodeProc: TEncodeDecodeProcRawByteString;
|
||
TestData: array of TestRecRawByteString);
|
||
end;
|
||
|
||
// Test methods for class TFormat_HEX
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_HEX = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_HEX: TFormat_HEX;
|
||
|
||
const
|
||
cTestDataEncode : array[1..2] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test'+#10+#9+#$AA+#$55+#$AB+#$CD+#$EF);
|
||
Output: '546573740A09AA55ABCDEF'));
|
||
|
||
cTestDataDecode : array[1..2] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: '546573740A09AA55ABCDEF';
|
||
Output: RawByteString('Test'+#10+#9+#$AA+#$55+#$AB+#$CD+#$EF)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_HEXL
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_HEXL = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_HEXL: TFormat_HEXL;
|
||
|
||
const
|
||
cTestDataEncode : array[1..2] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test'+#10+#9+#$AA+#$55+#$AB+#$CD+#$EF);
|
||
Output: '546573740a09aa55abcdef'));
|
||
|
||
cTestDataDecode : array[1..2] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: '546573740a09aa55abcdef';
|
||
Output: RawByteString('Test'+#10+#9+#$AA+#$55+#$AB+#$CD+#$EF)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_DECMIME32
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_DECMIME32 = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_DECMIME32: TFormat_DECMIME32;
|
||
|
||
const
|
||
cTestDataEncode : array[1..6] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55);
|
||
Output: 'xk3gh4jbjsklf'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA);
|
||
Output: 'xk3gh4jbjsklfyc'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55);
|
||
Output: 'xk3gh4jbjsklfyzk'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA);
|
||
Output: 'xk3gh4jbjsklfyzkkf'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55);
|
||
Output: 'xk3gh4jbjsklfyzkkpya')); // als letzter Buchstabe kommt manchmal oft ,u statt a heraus?
|
||
// scheint etwas zuf<75>llig? Was ist da faul?
|
||
// lt. DECTest.vec ist a richtig
|
||
|
||
cTestDataDecode : array[1..6] of TestRecRawByteString = (
|
||
(Input: '';
|
||
Output: RawByteString('')),
|
||
(Input: 'xk3gh4jbjsklf'; // lt. alter DECTest.vec aber xk3gh4jbjsklf f statt y ???
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55)),
|
||
(Input: 'xk3gh4jbjsklfyc';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA)),
|
||
(Input: 'xk3gh4jbjsklfyzk';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55)),
|
||
(Input: 'xk3gh4jbjsklfyzkkf';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA)),
|
||
(Input: 'xk3gh4jbjsklfyzkkpya';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_Base64
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_Base64 = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_Base64: TFormat_Base64;
|
||
const
|
||
cTestDataEncode : array[1..12] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55);
|
||
Output: 'VGVzdAoJqlU='),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA);
|
||
Output: 'VGVzdAoJqlWq'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55);
|
||
Output: 'VGVzdAoJqlWqVQ=='),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA);
|
||
Output: 'VGVzdAoJqlWqVao='),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55);
|
||
Output: 'VGVzdAoJqlWqVapV'),
|
||
(Input: RawByteString('f');
|
||
Output: 'Zg=='),
|
||
(Input: RawByteString('fo');
|
||
Output: 'Zm8='),
|
||
(Input: RawByteString('foo');
|
||
Output: 'Zm9v'),
|
||
(Input: RawByteString('foob');
|
||
Output: 'Zm9vYg=='),
|
||
(Input: RawByteString('fooba');
|
||
Output: 'Zm9vYmE='),
|
||
(Input: RawByteString('foobar');
|
||
Output: 'Zm9vYmFy'));
|
||
|
||
cTestDataDecode : array[1..12] of TestRecRawByteString = (
|
||
(Input: '';
|
||
Output: RawByteString('')),
|
||
(Input: 'VGVzdAoJqlU=';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55)),
|
||
(Input: 'VGVzdAoJqlWq';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA)),
|
||
(Input: 'VGVzdAoJqlWqVQ==';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55)),
|
||
(Input: 'VGVzdAoJqlWqVao=';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA)),
|
||
(Input: 'VGVzdAoJqlWqVapV';
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55)),
|
||
(Input: 'Zg==';
|
||
Output: RawByteString('f')),
|
||
(Input: 'Zm8=';
|
||
Output: RawByteString('fo')),
|
||
(Input: 'Zm9v';
|
||
Output: RawByteString('foo')),
|
||
(Input: 'Zm9vYg==';
|
||
Output: RawByteString('foob')),
|
||
(Input: 'Zm9vYmE=';
|
||
Output: RawByteString('fooba')),
|
||
(Input: 'Zm9vYmFy';
|
||
Output: RawByteString('foobar')));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_Radix64
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_Radix64 = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_Radix64: TFormat_Radix64;
|
||
|
||
const
|
||
cTestDataEncode : array[1..6] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: RawByteString('')),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55);
|
||
Output: RawByteString('VGVzdAoJqlU=' + #13 + #10 +'=XtiM')),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA);
|
||
Output: RawByteString('VGVzdAoJqlWq' + #13 + #10 + '=qBH3')),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55);
|
||
Output: RawByteString('VGVzdAoJqlWqVQ==' + #13 + #10 + '=Rqc1')),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA);
|
||
Output: RawByteString('VGVzdAoJqlWqVao=' + #13 + #10 +'=s2dH')),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55);
|
||
Output: RawByteString('VGVzdAoJqlWqVapV' + #13 + #10 +'=WEFz')));
|
||
|
||
cTestDataDecode : array[1..6] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: RawByteString('')),
|
||
(Input: RawByteString('VGVzdAoJqlU=' + #13 + #10 +'=XtiM');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55)),
|
||
(Input: RawByteString('VGVzdAoJqlWq' + #13 + #10 + '=qBH3');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA)),
|
||
(Input: RawByteString('VGVzdAoJqlWqVQ==' + #13 + #10 + '=Rqc1');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55)),
|
||
(Input: RawByteString('VGVzdAoJqlWqVao=' + #13 + #10 +'=s2dH');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA)),
|
||
(Input: RawByteString('VGVzdAoJqlWqVapV' + #13 + #10 +'=WEFz');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestEncodeRawByteStringWithCharsPerLine;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_UU
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_UU = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_UU: TFormat_UU;
|
||
|
||
const
|
||
cTestDataEncode : array[1..6] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55);
|
||
Output: '(5&5S=`H)JE4`'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA);
|
||
Output: ')5&5S=`H)JE6J'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55);
|
||
Output: '*5&5S=`H)JE6J50``'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA);
|
||
Output: '+5&5S=`H)JE6J5:H`'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55);
|
||
Output: ',5&5S=`H)JE6J5:I5'));
|
||
|
||
cTestDataDecode : array[1..6] of TestRecRawByteString = (
|
||
(Input: '';
|
||
Output: RawByteString('')),
|
||
(Input: RawByteString('(5&5S=`H)JE4`');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55)),
|
||
(Input: RawByteString(')5&5S=`H)JE6J');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA)),
|
||
(Input: RawByteString('*5&5S=`H)JE6J50``');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55)),
|
||
(Input: RawByteString('+5&5S=`H)JE6J5:H`');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA)),
|
||
(Input: RawByteString(',5&5S=`H)JE6J5:I5');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_XX
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_XX = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_XX: TFormat_XX;
|
||
|
||
const
|
||
cTestDataEncode : array[1..6] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55);
|
||
Output: '6J4JnR+c7eZI+'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA);
|
||
Output: '7J4JnR+c7eZKe'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55);
|
||
Output: '8J4JnR+c7eZKeJE++'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA);
|
||
Output: '9J4JnR+c7eZKeJOc+'),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55);
|
||
Output: 'AJ4JnR+c7eZKeJOdJ'));
|
||
|
||
cTestDataDecode : array[1..6] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('6J4JnR+c7eZI+');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55)),
|
||
(Input: RawByteString('7J4JnR+c7eZKe');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA)),
|
||
(Input: RawByteString('8J4JnR+c7eZKeJE++');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55)),
|
||
(Input: RawByteString('9J4JnR+c7eZKeJOc+');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA)),
|
||
(Input: RawByteString('AJ4JnR+c7eZKeJOdJ');
|
||
Output: RawByteString('Test' + #10 +#9 + #$AA + #$55 + #$AA + #$55 + #$AA + #$55)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_ESCAPE
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_ESCAPE = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_ESCAPE: TFormat_ESCAPE;
|
||
|
||
const
|
||
cTestDataEncode : array[1..9] of TestRecRawByteString = (
|
||
(Input: '';
|
||
Output: RawByteString('')),
|
||
(Input: RawByteString('Test' + #$AA + #$55);
|
||
Output: RawByteString('Test\xAAU')),
|
||
(Input: RawByteString('Test' + #$80 + #$55);
|
||
Output: RawByteString('Test\x80U')),
|
||
(Input: RawByteString('Test' + #$20 + #$55);
|
||
Output: RawByteString('Test U')),
|
||
(Input: RawByteString('Test' + #$19 + #$55);
|
||
Output: RawByteString('Test\x19U')),
|
||
(Input: RawByteString('Test' + #$07 + #$08 + #$09 + #$0A + #$0B + #$0C + #$0D + #$55);
|
||
Output: RawByteString('Test\a\b\t\n\v\f\rU')),
|
||
(Input: RawByteString('Test\U');
|
||
Output: RawByteString('Test\\U')),
|
||
(Input: RawByteString('Test\'+#$07 +'U');
|
||
Output: RawByteString('Test\\\aU')),
|
||
(Input: RawByteString('Test"hello"U');
|
||
Output: RawByteString('Test\"hello\"U')));
|
||
|
||
cTestDataDecode : array[1..9] of TestRecRawByteString = (
|
||
(Input: '';
|
||
Output: RawByteString('')),
|
||
(Input: RawByteString('Test\xAAU');
|
||
Output: RawByteString('Test' + #$AA + #$55)),
|
||
(Input: RawByteString('Test\x80U');
|
||
Output: RawByteString('Test' + #$80 + #$55)),
|
||
(Input: RawByteString('Test U');
|
||
Output: RawByteString('Test' + #$20 + #$55)),
|
||
(Input: RawByteString('Test\x19U');
|
||
Output: RawByteString('Test' + #$19 + #$55)),
|
||
(Input: RawByteString('Test\a\b\t\n\v\f\rU');
|
||
Output: RawByteString('Test' + #$07 + #$08 + #$09 + #$0A + #$0B + #$0C + #$0D + #$55)),
|
||
(Input: RawByteString('Test\\U');
|
||
Output: RawByteString('Test\U')),
|
||
(Input: RawByteString('Test\\\aU');
|
||
Output: RawByteString('Test\'+#$07 +'U')),
|
||
(Input: RawByteString('Test\"hello\"U');
|
||
Output: RawByteString('Test"hello"U')));
|
||
|
||
cTestDataIsValid : array[1..18] of TestRecIsValidRawByteString = (
|
||
(Input : 'abcABC123';
|
||
Result : true),
|
||
(Input : '\a';
|
||
Result : true),
|
||
(Input : '\b';
|
||
Result : true),
|
||
(Input : '\t';
|
||
Result : true),
|
||
(Input : '\n';
|
||
Result : true),
|
||
(Input : '\r';
|
||
Result : true),
|
||
(Input : '\v';
|
||
Result : true),
|
||
(Input : '\f';
|
||
Result : true),
|
||
(Input : '\r\n';
|
||
Result : true),
|
||
(Input : 'Data\tvalue';
|
||
Result : true),
|
||
(Input : '\';
|
||
Result : false),
|
||
(Input : '\q';
|
||
Result : false),
|
||
(Input : '\X41';
|
||
Result : true),
|
||
(Input : '\X';
|
||
Result : false),
|
||
(Input : '\X9';
|
||
Result : false),
|
||
(Input : '\XZZ';
|
||
Result : false),
|
||
(Input : chr(6);
|
||
Result : false),
|
||
(Input : chr(31);
|
||
Result : false));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_BigEndian16
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_BigEndian16 = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_BigEndian16: TFormat_BigEndian16;
|
||
|
||
const
|
||
cTestDataEncode : array[1..2] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test'+#10+#9+#$AA+#$55+#$AB+#$CD+#$EF+'1');
|
||
Output: RawByteString('eTts'+#9+#10+#$55+#$AA+#$CD+#$AB+'1'+#$EF)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_BigEndian32
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_BigEndian32 = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_BigEndian32: TFormat_BigEndian32;
|
||
|
||
const
|
||
cTestDataEncode : array[1..2] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test'+#10+#9+#$AA+#$55+#$AB+#$CD+#$EF+'1');
|
||
Output: RawByteString('tseT'+#$55+#$AA+#9+#10+'1'+#$EF+#$CD+#$AB)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
// Test methods for class TFormat_BigEndian64
|
||
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
||
TestTFormat_BigEndian64 = class(TFormatTestsBase)
|
||
strict private
|
||
FFormat_BigEndian64: TFormat_BigEndian64;
|
||
|
||
const
|
||
cTestDataEncode : array[1..2] of TestRecRawByteString = (
|
||
(Input: RawByteString('');
|
||
Output: ''),
|
||
(Input: RawByteString('Test'+#10+#9+#$AA+#$55+#$AB+#$CD+#$EF+'1ABCD');
|
||
Output: RawByteString(#$55+#$AA+#9+#10+'tseTDCBA1'+#$EF+#$CD+#$AB)));
|
||
public
|
||
procedure SetUp; override;
|
||
procedure TearDown; override;
|
||
published
|
||
procedure TestEncodeBytes;
|
||
procedure TestEncodeRawByteString;
|
||
procedure TestEncodeTypeless;
|
||
procedure TestDecodeBytes;
|
||
procedure TestDecodeRawByteString;
|
||
procedure TestDecodeTypeless;
|
||
procedure TestIsValidTypeless;
|
||
procedure TestIsValidTBytes;
|
||
procedure TestIsValidRawByteString;
|
||
procedure TestClassByName;
|
||
procedure TestIdentity;
|
||
end;
|
||
|
||
|
||
implementation
|
||
|
||
procedure TestTFormat_HEX.SetUp;
|
||
begin
|
||
FFormat_HEX := TFormat_HEX.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TearDown;
|
||
begin
|
||
FFormat_HEX.Free;
|
||
FFormat_HEX := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_HEX.ClassByName('TFormat_HEX');
|
||
CheckEquals(TFormat_HEX, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_HEX.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_HEX.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_HEX.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_HEX.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_HEX.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_HEX.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestIdentity;
|
||
begin
|
||
CheckEquals($E1B35EAB, FFormat_HEX.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestIsValidRawByteString;
|
||
begin
|
||
CheckEquals(true, TFormat_HEX.IsValid(BytesOf('')));
|
||
CheckEquals(true, TFormat_HEX.IsValid(BytesOf('0123456789abcdefABCDEF')));
|
||
// Invalid character: q is not a hex char
|
||
CheckEquals(false, TFormat_HEX.IsValid(BytesOf('1q')));
|
||
// Hex input length needs to be a multiple of 2, if input is not empty
|
||
CheckEquals(false, TFormat_HEX.IsValid(BytesOf('6')));
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestIsValidTBytes;
|
||
var
|
||
SrcBuf: TBytes;
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(''));
|
||
CheckEquals(true, TFormat_HEX.IsValid(SrcBuf));
|
||
|
||
SrcBuf := BytesOf(RawByteString('0123456789abcdefABCDEF'));
|
||
CheckEquals(true, TFormat_HEX.IsValid(SrcBuf));
|
||
|
||
SrcBuf := BytesOf(RawByteString('q'));
|
||
CheckEquals(false, TFormat_HEX.IsValid(SrcBuf));
|
||
end;
|
||
|
||
procedure TestTFormat_HEX.TestIsValidTypeless;
|
||
var
|
||
SrcBuf: TBytes;
|
||
p : Pointer;
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(''));
|
||
CheckEquals(true, TFormat_HEX.IsValid(SrcBuf, 0));
|
||
|
||
SrcBuf := BytesOf(RawByteString('0123456789abcdefABCDEF'));
|
||
p := @SrcBuf[0];
|
||
CheckEquals(true, TFormat_HEX.IsValid(p^, length(SrcBuf)));
|
||
|
||
SrcBuf := BytesOf(RawByteString('q'));
|
||
p := @SrcBuf[0];
|
||
CheckEquals(false, TFormat_HEX.IsValid(p^, length(SrcBuf)));
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.SetUp;
|
||
begin
|
||
FFormat_HEXL := TFormat_HEXL.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TearDown;
|
||
begin
|
||
FFormat_HEXL.Free;
|
||
FFormat_HEXL := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_HEXL.ClassByName('TFormat_HEXL');
|
||
CheckEquals(TFormat_HEXL, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_HEXL.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_HEXL.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_HEXL.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_HEXL.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_HEXL.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_HEXL.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestIdentity;
|
||
begin
|
||
CheckEquals($39D2D18D, FFormat_HEXL.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestIsValidRawByteString;
|
||
begin
|
||
CheckEquals(true, TFormat_HEXL.IsValid(BytesOf('')));
|
||
CheckEquals(true, TFormat_HEXL.IsValid(BytesOf('0123456789abcdefABCDEF')));
|
||
// Invalid character: q is not a hex char
|
||
CheckEquals(false, TFormat_HEX.IsValid(BytesOf('1q')));
|
||
// Hex input length needs to be a multiple of 2, if input is not empty
|
||
CheckEquals(false, TFormat_HEX.IsValid(BytesOf('6')));
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestIsValidTBytes;
|
||
var
|
||
SrcBuf: TBytes;
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(''));
|
||
CheckEquals(true, TFormat_HEXL.IsValid(SrcBuf));
|
||
|
||
SrcBuf := BytesOf(RawByteString('0123456789abcdefABCDEF'));
|
||
CheckEquals(true, TFormat_HEXL.IsValid(SrcBuf));
|
||
|
||
SrcBuf := BytesOf(RawByteString('q'));
|
||
CheckEquals(false, TFormat_HEXL.IsValid(SrcBuf));
|
||
end;
|
||
|
||
procedure TestTFormat_HEXL.TestIsValidTypeless;
|
||
var
|
||
SrcBuf: TBytes;
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(''));
|
||
CheckEquals(true, TFormat_HEXL.IsValid(SrcBuf, 0));
|
||
|
||
SrcBuf := BytesOf(RawByteString('0123456789abcdefABCDEF'));
|
||
CheckEquals(true, TFormat_HEXL.IsValid(SrcBuf[0], length(SrcBuf)));
|
||
|
||
SrcBuf := BytesOf(RawByteString('q'));
|
||
CheckEquals(false, TFormat_HEXL.IsValid(SrcBuf[0], length(SrcBuf)));
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.SetUp;
|
||
begin
|
||
FFormat_DECMIME32 := TFormat_DECMIME32.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TearDown;
|
||
begin
|
||
FFormat_DECMIME32.Free;
|
||
FFormat_DECMIME32 := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_DECMIME32.ClassByName('TFormat_DECMIME32');
|
||
CheckEquals(TFormat_DECMIME32, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_DECMIME32.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_DECMIME32.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_DECMIME32.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_DECMIME32.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_DECMIME32.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_DECMIME32.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestIdentity;
|
||
begin
|
||
CheckEquals($A7072340, FFormat_DECMIME32.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestIsValidRawByteString;
|
||
begin
|
||
CheckEquals(true, TFormat_DECMIME32.IsValid(BytesOf('')));
|
||
|
||
CheckEquals(true, TFormat_DECMIME32.IsValid(BytesOf('abcdefghijklnpqrstuwxyz123456789')));
|
||
CheckEquals(false, TFormat_DECMIME32.IsValid(BytesOf('1Q')));
|
||
CheckEquals(true, TFormat_DECMIME32.IsValid(BytesOf('6')));
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestIsValidTBytes;
|
||
var
|
||
SrcBuf: TBytes;
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(''));
|
||
CheckEquals(true, TFormat_DECMIME32.IsValid(SrcBuf));
|
||
|
||
SrcBuf := BytesOf(cTestDataEncode[3].Output);
|
||
CheckEquals(true, TFormat_DECMIME32.IsValid(SrcBuf));
|
||
|
||
SrcBuf := BytesOf(RawByteString('Q'));
|
||
CheckEquals(false, TFormat_DECMIME32.IsValid(SrcBuf));
|
||
end;
|
||
|
||
procedure TestTFormat_DECMIME32.TestIsValidTypeless;
|
||
var
|
||
SrcBuf: TBytes;
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(''));
|
||
CheckEquals(true, TFormat_DECMIME32.IsValid(SrcBuf, 0));
|
||
|
||
SrcBuf := BytesOf(cTestDataEncode[3].Output);
|
||
CheckEquals(true, TFormat_DECMIME32.IsValid(SrcBuf[0], length(SrcBuf)));
|
||
|
||
SrcBuf := BytesOf(RawByteString('Q'));
|
||
CheckEquals(false, TFormat_DECMIME32.IsValid(SrcBuf[0], length(SrcBuf)));
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.SetUp;
|
||
begin
|
||
FFormat_Base64 := TFormat_Base64.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TearDown;
|
||
begin
|
||
FFormat_Base64.Free;
|
||
FFormat_Base64 := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_Base64.ClassByName('TFormat_Base64');
|
||
CheckEquals(TFormat_Base64, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_Base64.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_Base64.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_Base64.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_Base64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_Base64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_Base64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestIdentity;
|
||
begin
|
||
CheckEquals($521BA151, FFormat_BASE64.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestIsValidRawByteString;
|
||
var
|
||
i : Integer;
|
||
begin
|
||
CheckEquals(true, TFormat_Base64.IsValid(BytesOf('')));
|
||
|
||
CheckEquals(true, TFormat_Base64.IsValid(
|
||
BytesOf('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='#$0D#$0A)));
|
||
CheckEquals(false, TFormat_Base64.IsValid(BytesOf('abc"')));
|
||
CheckEquals(true, TFormat_Base64.IsValid(BytesOf('6')));
|
||
|
||
for i := low(cTestDataDecode) to high(cTestDataDecode) do
|
||
begin
|
||
// skip empty test data
|
||
if (cTestDataDecode[i].Input = '') then
|
||
Continue;
|
||
|
||
CheckEquals(true, TFormat_Base64.IsValid(RawByteString(cTestDataDecode[i].Input)),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestIsValidTBytes;
|
||
const
|
||
Data = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='#$0D#$0A;
|
||
var
|
||
SrcBuf: TBytes;
|
||
i : Integer;
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(''));
|
||
CheckEquals(true, TFormat_Base64.IsValid(SrcBuf));
|
||
|
||
SetLength(SrcBuf, 1);
|
||
for i := 0 to 255 do
|
||
begin
|
||
SrcBuf[0] := i;
|
||
|
||
if (pos(chr(i), Data) > 0) then
|
||
CheckEquals(true, TFormat_Base64.IsValid(SrcBuf),
|
||
'Failure at char: ' + Chr(i) + ' ')
|
||
else
|
||
CheckEquals(false, TFormat_Base64.IsValid(SrcBuf),
|
||
'Failure at char nr: ' + IntToHex(i, 8) + ' ');
|
||
end;
|
||
|
||
SrcBuf := BytesOf('abc"');
|
||
CheckEquals(false, TFormat_Base64.IsValid(SrcBuf), 'Data: abc" ');
|
||
|
||
SrcBuf := BytesOf(cTestDataDecode[3].Input);
|
||
CheckEquals(true, TFormat_Base64.IsValid(SrcBuf),
|
||
'Data: ' + string(cTestDataDecode[3].Input));
|
||
|
||
for i := low(cTestDataDecode) to high(cTestDataDecode) do
|
||
begin
|
||
// skip empty test data
|
||
if (cTestDataDecode[i].Input = '') then
|
||
Continue;
|
||
|
||
SrcBuf := BytesOf(RawByteString(cTestDataDecode[i].Input));
|
||
CheckEquals(true, TFormat_Base64.IsValid(SrcBuf),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
end;
|
||
|
||
procedure TestTFormat_Base64.TestIsValidTypeless;
|
||
const
|
||
Data = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='#$0D#$0A;
|
||
var
|
||
SrcBuf: TBytes;
|
||
i : Integer;
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(''));
|
||
CheckEquals(true, TFormat_Base64.IsValid(SrcBuf, 0));
|
||
|
||
SetLength(SrcBuf, 1);
|
||
for i := 0 to 255 do
|
||
begin
|
||
SrcBuf[0] := i;
|
||
|
||
if (pos(chr(i), Data) > 0) then
|
||
CheckEquals(true, TFormat_Base64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'Failure at char: ' + Chr(i) + ' ')
|
||
else
|
||
CheckEquals(false, TFormat_Base64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'Failure at char nr: ' + IntToHex(i, 8) + ' ');
|
||
end;
|
||
|
||
|
||
SrcBuf := BytesOf('abc"');
|
||
CheckEquals(false, TFormat_Base64.IsValid(SrcBuf[0], length(SrcBuf)), 'Data: abc" ');
|
||
|
||
SrcBuf := BytesOf(cTestDataDecode[3].Input);
|
||
CheckEquals(true, TFormat_Base64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'Data: ' + string(cTestDataDecode[3].Input));
|
||
|
||
for i := low(cTestDataDecode) to high(cTestDataDecode) do
|
||
begin
|
||
// skip empty test data
|
||
if (cTestDataDecode[i].Input = '') then
|
||
Continue;
|
||
|
||
SrcBuf := BytesOf(RawByteString(cTestDataDecode[i].Input));
|
||
CheckEquals(true, TFormat_Base64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.SetUp;
|
||
begin
|
||
FFormat_Radix64 := TFormat_Radix64.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TearDown;
|
||
begin
|
||
FFormat_Radix64.Free;
|
||
FFormat_Radix64 := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestEncodeRawByteStringWithCharsPerLine;
|
||
type
|
||
/// <summary>
|
||
/// Type needed for the EncodeBytes und DecodeBytes test data definition
|
||
/// </summary>
|
||
TestRecCharsPerLine = record
|
||
Input, Output: RawByteString;
|
||
CharsPerLine : Byte;
|
||
end;
|
||
|
||
const
|
||
cTestDataEncode : array[1..2] of TestRecCharsPerLine = (
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55);
|
||
Output: RawByteString('VGVzdAoJqlU=' + #13 + #10 +'=XtiM');
|
||
CharsPerLine: 20),
|
||
(Input: RawByteString('Test' + #10 +#9 + #$AA + #$55);
|
||
Output: RawByteString('VGVz' + #13 + #10 + 'dAoJ' + #13 + #10 + 'qlU=' +
|
||
#13 + #10 + '=Xti' + #13 + #10 + 'M');
|
||
CharsPerLine: 4));
|
||
var
|
||
i : Integer;
|
||
SrcBuf,
|
||
DestBuf : TBytes;
|
||
OldCharsPerLineValue : Cardinal;
|
||
begin
|
||
OldCharsPerLineValue := FFormat_Radix64.GetCharsPerLine;
|
||
for i := Low(cTestDataEncode) to High(cTestDataEncode) do
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(cTestDataEncode[i].Input));
|
||
FFormat_Radix64.SetCharsPerLine(cTestDataEncode[i].CharsPerLine);
|
||
|
||
DestBuf := FFormat_Radix64.Encode(SrcBuf);
|
||
|
||
CheckEquals(cTestDataEncode[i].Output,
|
||
BytesToRawString(DestBuf));
|
||
end;
|
||
FFormat_Radix64.SetCharsPerLine(OldCharsPerLineValue);
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_Radix64.ClassByName('TFormat_Radix64');
|
||
CheckEquals(TFormat_Radix64, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_Radix64.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_Radix64.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_Radix64.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_Radix64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_Radix64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_Radix64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestIdentity;
|
||
begin
|
||
CheckEquals($B5607732, FFormat_Radix64.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestIsValidRawByteString;
|
||
var
|
||
i : Integer;
|
||
begin
|
||
for i := low(cTestDataDecode) to high(cTestDataDecode) do
|
||
begin
|
||
// skip empty test data
|
||
if (cTestDataDecode[i].Input = '') then
|
||
Continue;
|
||
|
||
CheckEquals(true, TFormat_Radix64.IsValid(cTestDataDecode[i].Input),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
// Check if wrong CRC is not being detected
|
||
CheckEquals(false, TFormat_Radix64.IsValid('VGVzdAoJqlU=' + #13 + #10 +'=XtiN'),
|
||
'CRC-failure not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'=XtiN' + ' ');
|
||
|
||
CheckEquals(false, TFormat_Radix64.IsValid('VGVzdAoJqlU=' + #13 + #10 +'=YtiM'),
|
||
'CRC-failure not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'=YtiM' + ' ');
|
||
|
||
// No CRC present due to missing =
|
||
CheckEquals(false, TFormat_Radix64.IsValid('VGVzdAoJqlU=' + #13 + #10 +'XtiM'),
|
||
'CRC not present not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'XtiM' + ' ');
|
||
|
||
// CRC has double =
|
||
CheckEquals(false, TFormat_Radix64.IsValid('VGVzdAoJqlU=' + #13 + #10 +'XtiM'),
|
||
'CRC not present not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'==XtiM' + ' ');
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestIsValidTBytes;
|
||
var
|
||
SrcBuf: TBytes;
|
||
i : Integer;
|
||
begin
|
||
for i := low(cTestDataDecode) to high(cTestDataDecode) do
|
||
begin
|
||
// skip empty test data
|
||
if (cTestDataDecode[i].Input = '') then
|
||
Continue;
|
||
|
||
SrcBuf := BytesOf(RawByteString(cTestDataDecode[i].Input));
|
||
CheckEquals(true, TFormat_Radix64.IsValid(SrcBuf),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
// Check if wrong CRC is not being detected
|
||
CheckEquals(false, TFormat_Radix64.IsValid(BytesOf(RawByteString('VGVzdAoJqlU=' + #13 + #10 +'=XtiN'))),
|
||
'CRC-failure not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'=XtiN' + ' ');
|
||
|
||
CheckEquals(false, TFormat_Radix64.IsValid(BytesOf(RawByteString('VGVzdAoJqlU=' + #13 + #10 +'=YtiM'))),
|
||
'CRC-failure not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'=YtiM' + ' ');
|
||
|
||
// No CRC present due to missing =
|
||
CheckEquals(false, TFormat_Radix64.IsValid(BytesOf(RawByteString('VGVzdAoJqlU=' + #13 + #10 +'XtiM'))),
|
||
'CRC not present not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'XtiM' + ' ');
|
||
|
||
// CRC has double =
|
||
CheckEquals(false, TFormat_Radix64.IsValid(BytesOf(RawByteString('VGVzdAoJqlU=' + #13 + #10 +'XtiM'))),
|
||
'CRC not present not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'==XtiM' + ' ');
|
||
end;
|
||
|
||
procedure TestTFormat_Radix64.TestIsValidTypeless;
|
||
var
|
||
SrcBuf: TBytes;
|
||
i : Integer;
|
||
begin
|
||
for i := low(cTestDataDecode) to high(cTestDataDecode) do
|
||
begin
|
||
// skip empty test data
|
||
if (cTestDataDecode[i].Input = '') then
|
||
Continue;
|
||
|
||
SrcBuf := BytesOf(RawByteString(cTestDataDecode[i].Input));
|
||
CheckEquals(true, TFormat_Radix64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
// Check if wrong CRC is not being detected
|
||
SrcBuf := BytesOf(RawByteString('VGVzdAoJqlU=' + #13 + #10 +'=XtiN'));
|
||
CheckEquals(false, TFormat_Radix64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'CRC-failure not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'=XtiN' + ' ');
|
||
|
||
SrcBuf := BytesOf(RawByteString('VGVzdAoJqlU=' + #13 + #10 +'=YtiM'));
|
||
CheckEquals(false, TFormat_Radix64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'CRC-failure not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'=YtiM' + ' ');
|
||
|
||
// No CRC present due to missing =
|
||
SrcBuf := BytesOf(RawByteString('VGVzdAoJqlU=' + #13 + #10 +'XtiM'));
|
||
CheckEquals(false, TFormat_Radix64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'CRC not present not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'XtiM' + ' ');
|
||
|
||
// CRC has double =
|
||
SrcBuf := BytesOf(RawByteString('VGVzdAoJqlU=' + #13 + #10 +'XtiM'));
|
||
CheckEquals(false, TFormat_Radix64.IsValid(SrcBuf[0], length(SrcBuf)),
|
||
'CRC not present not detected on ' + 'VGVzdAoJqlU=' + #13 + #10 +'==XtiM' + ' ');
|
||
end;
|
||
|
||
procedure TestTFormat_UU.SetUp;
|
||
begin
|
||
FFormat_UU := TFormat_UU.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TearDown;
|
||
begin
|
||
FFormat_UU.Free;
|
||
FFormat_UU := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_UU.ClassByName('TFormat_UU');
|
||
CheckEquals(TFormat_UU, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_UU.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_UU.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_UU.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_UU.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_UU.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_UU.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestIdentity;
|
||
begin
|
||
CheckEquals($6FCCDE6F, FFormat_UU.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestIsValidRawByteString;
|
||
var
|
||
i : Integer;
|
||
begin
|
||
CheckEquals(true, TFormat_UU.IsValid(RawByteString('')),'Failure on empty string ');
|
||
|
||
for i := Low(cTestDataDecode) to High(cTestDataDecode) do
|
||
begin
|
||
if cTestDataDecode[i].Input = '' then
|
||
Continue;
|
||
|
||
CheckEquals(true, TFormat_UU.IsValid(cTestDataDecode[i].Input),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
CheckEquals(false, TFormat_UU.IsValid(RawByteString('#$61')), 'Failure on char $61 ');
|
||
CheckEquals(false, TFormat_UU.IsValid('(5&5S' + #$61 + '=`H)JE4`'), 'Failure on char $61 inbetween ');
|
||
CheckEquals(false, TFormat_UU.IsValid(#$61 + '(5&5S=`H)JE4`'), 'Failure on char $61 at the beginning ');
|
||
CheckEquals(false, TFormat_UU.IsValid('(5&5S=`H)JE4`' + #$61), 'Failure on char $61 at the end ');
|
||
|
||
for i := $61 to $FF do
|
||
CheckEquals(false, TFormat_UU.IsValid(RawByteString(chr(i))),
|
||
'Failure on char #' + IntToHex(i, 8) + ' ');
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestIsValidTBytes;
|
||
var
|
||
SrcBuf: TBytes;
|
||
i : Integer;
|
||
begin
|
||
SetLength(SrcBuf, 0);
|
||
CheckEquals(true, TFormat_UU.IsValid(SrcBuf, length(SrcBuf)),
|
||
'Failure on empty buffer ');
|
||
|
||
for i := Low(cTestDataDecode) to High(cTestDataDecode) do
|
||
begin
|
||
if cTestDataDecode[i].Input = '' then
|
||
Continue;
|
||
|
||
CheckEquals(true, TFormat_UU.IsValid(BytesOf(cTestDataDecode[i].Input)),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
CheckEquals(false, TFormat_UU.IsValid(BytesOf(RawByteString('#$61'))), 'Failure on char $61 ');
|
||
CheckEquals(false, TFormat_UU.IsValid(BytesOf('(5&5S' + #$61 + '=`H)JE4`')), 'Failure on char $61 inbetween ');
|
||
CheckEquals(false, TFormat_UU.IsValid(BytesOf(#$61 + '(5&5S=`H)JE4`')), 'Failure on char $61 at the beginning ');
|
||
CheckEquals(false, TFormat_UU.IsValid(BytesOf('(5&5S=`H)JE4`' + #$61)), 'Failure on char $61 at the end ');
|
||
|
||
for i := $61 to $FF do
|
||
CheckEquals(false, TFormat_UU.IsValid(BytesOf(RawByteString(chr(i)))),
|
||
'Failure on char #' + IntToHex(i, 8) + ' ');
|
||
end;
|
||
|
||
procedure TestTFormat_UU.TestIsValidTypeless;
|
||
var
|
||
SrcBuf: TBytes;
|
||
i : Integer;
|
||
p : Pointer;
|
||
begin
|
||
SetLength(SrcBuf, 0);
|
||
p := @SrcBuf;
|
||
CheckEquals(true, TFormat_UU.IsValid(p^, length(SrcBuf)),
|
||
'Failure on empty buffer ');
|
||
|
||
for i := Low(cTestDataDecode) to High(cTestDataDecode) do
|
||
begin
|
||
if cTestDataDecode[i].Input = '' then
|
||
Continue;
|
||
|
||
SrcBuf := BytesOf(cTestDataDecode[i].Input);
|
||
p := @SrcBuf[0];
|
||
CheckEquals(true, TFormat_UU.IsValid(p^, length(SrcBuf)),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
SrcBuf := BytesOf(RawByteString('#$61'));
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_UU.IsValid(p^, length(SrcBuf)), 'Failure on char $61 ');
|
||
SrcBuf := BytesOf('(5&5S' + #$61 + '=`H)JE4`');
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_UU.IsValid(p^, length(SrcBuf)), 'Failure on char $61 inbetween ');
|
||
SrcBuf := BytesOf(#$61 + '(5&5S=`H)JE4`');
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_UU.IsValid(p^, length(SrcBuf)), 'Failure on char $61 at the beginning ');
|
||
SrcBuf := BytesOf('(5&5S=`H)JE4`' + #$61);
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_UU.IsValid(p^, length(SrcBuf)), 'Failure on char $61 at the end ');
|
||
|
||
SetLength(SrcBuf, 1);
|
||
for i := $61 to $FF do
|
||
begin
|
||
SrcBuf[0] := i;
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_UU.IsValid(p^, length(SrcBuf)),
|
||
'Failure on char #' + IntToHex(i, 8) + ' ');
|
||
end;
|
||
end;
|
||
|
||
procedure TestTFormat_XX.SetUp;
|
||
begin
|
||
FFormat_XX := TFormat_XX.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TearDown;
|
||
begin
|
||
FFormat_XX.Free;
|
||
FFormat_XX := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_XX.ClassByName('TFormat_XX');
|
||
CheckEquals(TFormat_XX, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_XX.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_XX.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_XX.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_XX.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_XX.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_XX.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestIdentity;
|
||
begin
|
||
CheckEquals($A4D3DC9F, FFormat_XX.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestIsValidRawByteString;
|
||
var
|
||
i : Integer;
|
||
begin
|
||
CheckEquals(true, TFormat_XX.IsValid(RawByteString('')),'Failure on empty string ');
|
||
|
||
for i := Low(cTestDataDecode) to High(cTestDataDecode) do
|
||
begin
|
||
if cTestDataDecode[i].Input = '' then
|
||
Continue;
|
||
|
||
CheckEquals(true, TFormat_XX.IsValid(cTestDataDecode[i].Input),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
CheckEquals(false, TFormat_XX.IsValid(RawByteString('#$2A')), 'Failure on char $2A ');
|
||
CheckEquals(false, TFormat_XX.IsValid('6J4Jn' + #$2A + 'R+c7eZI+'), 'Failure on char $2A inbetween ');
|
||
CheckEquals(false, TFormat_XX.IsValid(#$2A +'6J4JnR+c7eZI+'), 'Failure on char $2A at the beginning ');
|
||
CheckEquals(false, TFormat_XX.IsValid('6J4JnR+c7eZI+' + #$2A), 'Failure on char $2A at the end ');
|
||
|
||
CheckEquals(false, TFormat_XX.IsValid(RawByteString('#$23')), 'Failure on char $23 ');
|
||
CheckEquals(false, TFormat_XX.IsValid('6J4Jn' + #$23 + 'R+c7eZI+'), 'Failure on char $23 inbetween ');
|
||
CheckEquals(false, TFormat_XX.IsValid(#$23 +'6J4JnR+c7eZI+'), 'Failure on char $23 at the beginning ');
|
||
CheckEquals(false, TFormat_XX.IsValid('6J4JnR+c7eZI+' + #$23), 'Failure on char $23 at the end ');
|
||
|
||
for i := $7B to $FF do
|
||
CheckEquals(false, TFormat_XX.IsValid(RawByteString(chr(i))),
|
||
'Failure on char #' + IntToHex(i, 8) + ' ');
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestIsValidTBytes;
|
||
var
|
||
SrcBuf: TBytes;
|
||
i : Integer;
|
||
begin
|
||
SetLength(SrcBuf, 0);
|
||
CheckEquals(true, TFormat_XX.IsValid(SrcBuf, length(SrcBuf)),
|
||
'Failure on empty buffer ');
|
||
|
||
for i := Low(cTestDataDecode) to High(cTestDataDecode) do
|
||
begin
|
||
if cTestDataDecode[i].Input = '' then
|
||
Continue;
|
||
|
||
CheckEquals(true, TFormat_XX.IsValid(BytesOf(cTestDataDecode[i].Input)),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
CheckEquals(false, TFormat_XX.IsValid(BytesOf(RawByteString('#$2A'))), 'Failure on char $2A ');
|
||
CheckEquals(false, TFormat_XX.IsValid(BytesOf('6J4Jn' + #$2A + 'R+c7eZI+')), 'Failure on char $2A inbetween ');
|
||
CheckEquals(false, TFormat_XX.IsValid(BytesOf(#$2A +'6J4JnR+c7eZI+')), 'Failure on char $2A at the beginning ');
|
||
CheckEquals(false, TFormat_XX.IsValid(BytesOf('6J4JnR+c7eZI+' + #$2A)), 'Failure on char $2A at the end ');
|
||
|
||
CheckEquals(false, TFormat_XX.IsValid(BytesOf(RawByteString('#$23'))), 'Failure on char $23 ');
|
||
CheckEquals(false, TFormat_XX.IsValid(BytesOf('6J4Jn' + #$23 + 'R+c7eZI+')), 'Failure on char $23 inbetween ');
|
||
CheckEquals(false, TFormat_XX.IsValid(BytesOf(#$23 +'6J4JnR+c7eZI+')), 'Failure on char $23 at the beginning ');
|
||
CheckEquals(false, TFormat_XX.IsValid(BytesOf('6J4JnR+c7eZI+' + #$23)), 'Failure on char $23 at the end ');
|
||
|
||
for i := $7B to $FF do
|
||
CheckEquals(false, TFormat_XX.IsValid(RawByteString(chr(i))),
|
||
'Failure on char #' + IntToHex(i, 8) + ' ');
|
||
end;
|
||
|
||
procedure TestTFormat_XX.TestIsValidTypeless;
|
||
var
|
||
SrcBuf: TBytes;
|
||
i : Integer;
|
||
p : Pointer;
|
||
begin
|
||
SetLength(SrcBuf, 0);
|
||
p := @SrcBuf;
|
||
CheckEquals(true, TFormat_XX.IsValid(p^, length(SrcBuf)),
|
||
'Failure on empty buffer ');
|
||
|
||
for i := Low(cTestDataDecode) to High(cTestDataDecode) do
|
||
begin
|
||
if cTestDataDecode[i].Input = '' then
|
||
Continue;
|
||
|
||
SrcBuf := BytesOf(cTestDataDecode[i].Input);
|
||
p := @SrcBuf[0];
|
||
CheckEquals(true, TFormat_XX.IsValid(p^, length(SrcBuf)),
|
||
'Failure on ' + string(cTestDataDecode[i].Input) + ' ');
|
||
end;
|
||
|
||
Srcbuf := BytesOf(RawByteString('#$2A'));
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)), 'Failure on char $2A ');
|
||
Srcbuf := BytesOf('6J4Jn' + #$2A + 'R+c7eZI+');
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)), 'Failure on char $2A inbetween ');
|
||
Srcbuf := BytesOf(#$2A +'6J4JnR+c7eZI+');
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)), 'Failure on char $2A at the beginning ');
|
||
Srcbuf := BytesOf('6J4JnR+c7eZI+' + #$2A);
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)), 'Failure on char $2A at the end ');
|
||
|
||
Srcbuf := BytesOf(RawByteString('#$23'));
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)), 'Failure on char $23 ');
|
||
Srcbuf := BytesOf('6J4Jn' + #$23 + 'R+c7eZI+');
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)), 'Failure on char $23 inbetween ');
|
||
Srcbuf := BytesOf(#$23 +'6J4JnR+c7eZI+');
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)), 'Failure on char $23 at the beginning ');
|
||
Srcbuf := BytesOf('6J4JnR+c7eZI+' + #$23);
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)), 'Failure on char $23 at the end ');
|
||
|
||
SetLength(SrcBuf, 1);
|
||
for i := $61 to $FF do
|
||
begin
|
||
SrcBuf[0] := i;
|
||
p := @SrcBuf;
|
||
CheckEquals(false, TFormat_XX.IsValid(p^, length(SrcBuf)),
|
||
'Failure on char #' + IntToHex(i, 8) + ' ');
|
||
end;
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.SetUp;
|
||
begin
|
||
FFormat_ESCAPE := TFormat_ESCAPE.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TearDown;
|
||
begin
|
||
FFormat_ESCAPE.Free;
|
||
FFormat_ESCAPE := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_ESCAPE.ClassByName('TFormat_ESCAPE');
|
||
CheckEquals(TFormat_ESCAPE, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_ESCAPE.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_ESCAPE.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_ESCAPE.Decode, cTestDataDecode);
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_ESCAPE.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_ESCAPE.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_ESCAPE.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestIdentity;
|
||
begin
|
||
CheckEquals($168B27C3, FFormat_ESCAPE.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestIsValidRawByteString;
|
||
var
|
||
i : Integer;
|
||
Str : RawByteString;
|
||
p : ^Byte;
|
||
begin
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(RawByteString('')),'Failure on empty string ');
|
||
|
||
// check all chars in allowed range
|
||
for i := 32 to 127 do
|
||
begin
|
||
// skip backslash
|
||
if i = $5C then
|
||
Continue;
|
||
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(RawByteString(chr(i))),
|
||
IntToStr(i) + ': Failure on ' + chr(i) + ' ');
|
||
end;
|
||
|
||
// check hex chars
|
||
for i := 128 to 255 do
|
||
begin
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(RawByteString('\X' + IntToHex(i, 2))),
|
||
IntToStr(i) + ': Failure on \X' + IntToHex(i, 2));
|
||
end;
|
||
|
||
// check hex chars
|
||
for i := 0 to 31 do
|
||
begin
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(RawByteString('\X' + IntToHex(i, 2))),
|
||
IntToStr(i) + ': Failure on \X' + IntToHex(i, 2));
|
||
end;
|
||
|
||
for i := Low(cTestDataIsValid) to High(cTestDataIsValid) do
|
||
begin
|
||
CheckEquals(cTestDataIsValid[i].Result,
|
||
TFormat_ESCAPE.IsValid(cTestDataIsValid[i].Input),
|
||
IntToStr(i) + ': Failure on ' + string(cTestDataIsValid[i].Input));
|
||
end;
|
||
|
||
Str := 'A';
|
||
p := @Str[1];
|
||
p^ := $80;
|
||
|
||
CheckEquals(false,
|
||
TFormat_ESCAPE.IsValid(Str),
|
||
'Failure on ' + string(Str));
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestIsValidTBytes;
|
||
var
|
||
i : Integer;
|
||
b : TBytes;
|
||
begin
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(BytesOf(RawByteString(''))),'Failure on empty string ');
|
||
|
||
// check all chars in allowed range
|
||
for i := 32 to 127 do
|
||
begin
|
||
// skip backslash
|
||
if i = $5C then
|
||
Continue;
|
||
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(BytesOf(chr(i))),
|
||
IntToStr(i) + ': Failure on ' + chr(i) + ' ');
|
||
end;
|
||
|
||
// check hex chars
|
||
for i := 128 to 255 do
|
||
begin
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(BytesOf('\X' + IntToHex(i, 2))),
|
||
IntToStr(i) + ': Failure on \X' + IntToHex(i, 2));
|
||
end;
|
||
|
||
// check hex chars
|
||
for i := 0 to 31 do
|
||
begin
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(BytesOf('\X' + IntToHex(i, 2))),
|
||
IntToStr(i) + ': Failure on \X' + IntToHex(i, 2));
|
||
end;
|
||
|
||
for i := Low(cTestDataIsValid) to High(cTestDataIsValid) do
|
||
begin
|
||
CheckEquals(cTestDataIsValid[i].Result,
|
||
TFormat_ESCAPE.IsValid(BytesOf(cTestDataIsValid[i].Input)),
|
||
IntToStr(i) + ': Failure on ' + string(cTestDataIsValid[i].Input));
|
||
end;
|
||
|
||
// Chars outside the range 32..$7F need to be hex encoded e.g. \X80
|
||
SetLength(b, 1);
|
||
b[0] := $80;
|
||
CheckEquals(false, TFormat_ESCAPE.IsValid(b), 'Failure on: #$80 ');
|
||
end;
|
||
|
||
procedure TestTFormat_ESCAPE.TestIsValidTypeless;
|
||
var
|
||
i : Integer;
|
||
Bytes : TBytes;
|
||
begin
|
||
SetLength(Bytes, 0);
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(Bytes, 0),'Failure on empty string ');
|
||
|
||
// check all chars in allowed range
|
||
for i := 32 to 127 do
|
||
begin
|
||
// skip backslash
|
||
if i = $5C then
|
||
Continue;
|
||
|
||
{$IF CompilerVersion >= 24.0}
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(RawByteString(chr(i))[low(RawByteString)], 1),
|
||
'Failure on ' + chr(i) + ' ');
|
||
{$ELSE}
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(RawByteString(chr(i))[1], 1),
|
||
'Failure on ' + chr(i) + ' ');
|
||
{$IFEND}
|
||
end;
|
||
|
||
// check hex chars
|
||
for i := 128 to 255 do
|
||
begin
|
||
Bytes := BytesOf('\X' + IntToHex(i, 2));
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(Bytes[0], length(Bytes)),
|
||
IntToStr(i) + ': Failure on \X' + IntToHex(i, 2));
|
||
end;
|
||
|
||
// check hex chars
|
||
for i := 0 to 31 do
|
||
begin
|
||
Bytes := BytesOf('\X' + IntToHex(i, 2));
|
||
CheckEquals(true, TFormat_ESCAPE.IsValid(Bytes[0], length(Bytes)),
|
||
IntToStr(i) + ': Failure on \X' + IntToHex(i, 2));
|
||
end;
|
||
|
||
for i := Low(cTestDataIsValid) to High(cTestDataIsValid) do
|
||
begin
|
||
Bytes := BytesOf(cTestDataIsValid[i].Input);
|
||
CheckEquals(cTestDataIsValid[i].Result,
|
||
TFormat_ESCAPE.IsValid(Bytes[0], length(Bytes)),
|
||
IntToStr(i) + ': Failure on ' + string(cTestDataIsValid[i].Input));
|
||
end;
|
||
|
||
// Chars outside the range 32..$7F need to be hex encoded e.g. \X80
|
||
SetLength(Bytes, 1);
|
||
Bytes[0] := $80;
|
||
CheckEquals(false, TFormat_ESCAPE.IsValid(Bytes[0], 1), 'Failure on: #$80 ');
|
||
end;
|
||
|
||
{ TFormatTestsBase }
|
||
|
||
procedure TFormatTestsBase.DoTestEncodeDecode(EncodeDecodeProc: TEncodeDecodeProc;
|
||
TestData: array of TestRecRawByteString);
|
||
var
|
||
i : Integer;
|
||
SrcBuf,
|
||
DestBuf : TBytes;
|
||
begin
|
||
for i := Low(TestData) to High(TestData) do
|
||
begin
|
||
SrcBuf := BytesOf(RawByteString(TestData[i].Input));
|
||
DestBuf := EncodeDecodeProc(SrcBuf);
|
||
|
||
CheckEquals(TestData[i].Output,
|
||
BytesToRawString(DestBuf));
|
||
end;
|
||
end;
|
||
|
||
procedure TFormatTestsBase.DoTestEncodeDecodeRawByteString(EncodeDecodeProc: TEncodeDecodeProcRawByteString;
|
||
TestData: array of TestRecRawByteString);
|
||
var
|
||
i : Integer;
|
||
result : RawByteString;
|
||
begin
|
||
for i := Low(TestData) to High(TestData) do
|
||
begin
|
||
result := EncodeDecodeProc(TestData[i].Input);
|
||
|
||
CheckEquals(TestData[i].Output, result);
|
||
end;
|
||
end;
|
||
|
||
procedure TFormatTestsBase.DoTestEncodeDecodeTypeless(EncodeDecodeProc: TEncodeDecodeProcTypeless;
|
||
TestData: array of TestRecRawByteString);
|
||
var
|
||
i : Integer;
|
||
result : RawByteString;
|
||
pdata : PByte;
|
||
len : Integer;
|
||
begin
|
||
for i := Low(TestData) to High(TestData) do
|
||
begin
|
||
if length(TestData[i].Input) > 0 then
|
||
begin
|
||
{$IF CompilerVersion >= 24.0}
|
||
pdata := @TestData[i].Input[low(TestData[i].Input)];
|
||
|
||
len := length(TestData[i].Input) * SizeOf(TestData[i].Input[low(TestData[i].Input)]);
|
||
{$ELSE}
|
||
pdata := @TestData[i].Input[1];
|
||
|
||
len := length(TestData[i].Input) * SizeOf(TestData[i].Input[1]);
|
||
{$IFEND}
|
||
end
|
||
else
|
||
begin
|
||
pdata := nil;
|
||
len := 0;
|
||
end;
|
||
|
||
result := EncodeDecodeProc(pdata^, len);
|
||
|
||
CheckEquals(TestData[i].Output, result);
|
||
end;
|
||
end;
|
||
|
||
{ TestTFormat_BigEndian16 }
|
||
|
||
procedure TestTFormat_BigEndian16.SetUp;
|
||
begin
|
||
FFormat_BigEndian16 := TFormat_BigEndian16.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TearDown;
|
||
begin
|
||
FFormat_BigEndian16.Free;
|
||
FFormat_BigEndian16 := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_BigEndian16.ClassByName('TFormat_BigEndian16');
|
||
CheckEquals(TFormat_BigEndian16, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_BigEndian16.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_BigEndian16.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_BigEndian16.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_BigEndian16.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_BigEndian16.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_BigEndian16.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestIdentity;
|
||
begin
|
||
CheckEquals($957DD064, FFormat_BigEndian16.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestIsValidRawByteString;
|
||
begin
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(RawByteString('')),'Failure on empty string');
|
||
CheckEquals(false, TFormat_BigEndian16.IsValid(RawByteString('1')),'Failure on odd length string');
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(RawByteString('12')),'Failure on 2-byte string');
|
||
CheckEquals(false, TFormat_BigEndian16.IsValid(RawByteString('123')),'Failure on 1-byte string');
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(RawByteString('1234')),'Failure on 4-byte string');
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(RawByteString('1234abCdeFghijkl')),'Failure on 16-byte string');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestIsValidTBytes;
|
||
begin
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(BytesOf(RawByteString(''))),'Failure on empty string ');
|
||
|
||
CheckEquals(false, TFormat_BigEndian16.IsValid(BytesOf(RawByteString('1'))),'Failure on 1-byte string');
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(BytesOf(RawByteString('12'))),'Failure on 2-byte string');
|
||
CheckEquals(false, TFormat_BigEndian16.IsValid(BytesOf(RawByteString('123'))),'Failure on 3-byte string');
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(BytesOf(RawByteString('1234'))),'Failure on 4-byte string');
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(BytesOf(RawByteString('1234abCdeFghijkl'))),'Failure on 16-byte string');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian16.TestIsValidTypeless;
|
||
var
|
||
Bytes : TBytes;
|
||
begin
|
||
SetLength(Bytes, 0);
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(Bytes, 0),'Failure on empty data');
|
||
|
||
Bytes := TBytes.Create(1);
|
||
CheckEquals(false, TFormat_BigEndian16.IsValid(Bytes, length(Bytes)),'Failure on 1-byte data');
|
||
|
||
Bytes := TBytes.Create(254, 255);
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(Bytes, length(Bytes)),'Failure on 2-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3);
|
||
CheckEquals(false, TFormat_BigEndian16.IsValid(Bytes, length(Bytes)),'Failure on 3-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3, 4);
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(Bytes, length(Bytes)),'Failure on 4-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||
CheckEquals(true, TFormat_BigEndian16.IsValid(Bytes, length(Bytes)),'Failure on 16-byte data');
|
||
end;
|
||
|
||
{ TestTFormat_BigEndian32 }
|
||
|
||
procedure TestTFormat_BigEndian32.SetUp;
|
||
begin
|
||
FFormat_BigEndian32 := TFormat_BigEndian32.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TearDown;
|
||
begin
|
||
FFormat_BigEndian32.Free;
|
||
FFormat_BigEndian32 := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_BigEndian32.ClassByName('TFormat_BigEndian32');
|
||
CheckEquals(TFormat_BigEndian32, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_BigEndian32.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_BigEndian32.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_BigEndian32.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_BigEndian32.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_BigEndian32.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_BigEndian32.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestIdentity;
|
||
begin
|
||
CheckEquals($A02676FF, FFormat_BigEndian32.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestIsValidRawByteString;
|
||
begin
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(RawByteString('')),'Failure on empty string');
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(RawByteString('1')),'Failure on odd length string');
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(RawByteString('12')),'Failure on 2-byte string');
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(RawByteString('123')),'Failure on 1-byte string');
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(RawByteString('1234')),'Failure on 4-byte string');
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(RawByteString('1234abCdeFghijkl')),'Failure on 16-byte string');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestIsValidTBytes;
|
||
begin
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(BytesOf(RawByteString(''))),'Failure on empty string ');
|
||
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(BytesOf(RawByteString('1'))),'Failure on 1-byte string');
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(BytesOf(RawByteString('12'))),'Failure on 2-byte string');
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(BytesOf(RawByteString('123'))),'Failure on 3-byte string');
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(BytesOf(RawByteString('1234'))),'Failure on 4-byte string');
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(BytesOf(RawByteString('1234abCdeFghijkl'))),'Failure on 16-byte string');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian32.TestIsValidTypeless;
|
||
var
|
||
Bytes : TBytes;
|
||
begin
|
||
SetLength(Bytes, 0);
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(Bytes, 0),'Failure on empty data');
|
||
|
||
Bytes := TBytes.Create(1);
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(Bytes, length(Bytes)),'Failure on 1-byte data');
|
||
|
||
Bytes := TBytes.Create(254, 255);
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(Bytes, length(Bytes)),'Failure on 2-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3);
|
||
CheckEquals(false, TFormat_BigEndian32.IsValid(Bytes, length(Bytes)),'Failure on 3-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3, 4);
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(Bytes, length(Bytes)),'Failure on 4-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||
CheckEquals(true, TFormat_BigEndian32.IsValid(Bytes, length(Bytes)),'Failure on 16-byte data');
|
||
end;
|
||
|
||
{ TestTFormat_BigEndian64 }
|
||
|
||
procedure TestTFormat_BigEndian64.SetUp;
|
||
begin
|
||
FFormat_BigEndian64 := TFormat_BigEndian64.Create;
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TearDown;
|
||
begin
|
||
FFormat_BigEndian64.Free;
|
||
FFormat_BigEndian64 := nil;
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestClassByName;
|
||
var
|
||
ReturnValue : TDECFormatClass;
|
||
begin
|
||
ReturnValue := FFormat_BigEndian64.ClassByName('TFormat_BigEndian64');
|
||
CheckEquals(TFormat_BigEndian64, ReturnValue, 'Class is not registered');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestDecodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_BigEndian64.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestDecodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_BigEndian64.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestDecodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_BigEndian64.Decode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestEncodeBytes;
|
||
begin
|
||
DoTestEncodeDecode(FFormat_BigEndian64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestEncodeRawByteString;
|
||
begin
|
||
DoTestEncodeDecodeRawByteString(FFormat_BigEndian64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestEncodeTypeless;
|
||
begin
|
||
DoTestEncodeDecodeTypeless(FFormat_BigEndian64.Encode, cTestDataEncode);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestIdentity;
|
||
begin
|
||
CheckEquals($3432278F, FFormat_BigEndian64.Identity);
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestIsValidRawByteString;
|
||
begin
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(RawByteString('')),'Failure on empty string');
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(RawByteString('1')),'Failure on odd length string');
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(RawByteString('12')),'Failure on 2-byte string');
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(RawByteString('123')),'Failure on 1-byte string');
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(RawByteString('1234')),'Failure on 4-byte string');
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(RawByteString('1234abCd')),'Failure on 8-byte string');
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(RawByteString('1234abCdeFghijkl')),'Failure on 16-byte string');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestIsValidTBytes;
|
||
begin
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(BytesOf(RawByteString(''))),'Failure on empty string ');
|
||
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(BytesOf(RawByteString('1'))),'Failure on 1-byte string');
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(BytesOf(RawByteString('12'))),'Failure on 2-byte string');
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(BytesOf(RawByteString('123'))),'Failure on 3-byte string');
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(BytesOf(RawByteString('1234'))),'Failure on 4-byte string');
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(BytesOf(RawByteString('1234abCd'))),'Failure on 8-byte string');
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(BytesOf(RawByteString('1234abCdeFghijkl'))),'Failure on 16-byte string');
|
||
end;
|
||
|
||
procedure TestTFormat_BigEndian64.TestIsValidTypeless;
|
||
var
|
||
Bytes : TBytes;
|
||
begin
|
||
SetLength(Bytes, 0);
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(Bytes, 0),'Failure on empty data');
|
||
|
||
Bytes := TBytes.Create(1);
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(Bytes, length(Bytes)),'Failure on 1-byte data');
|
||
|
||
Bytes := TBytes.Create(254, 255);
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(Bytes, length(Bytes)),'Failure on 2-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3);
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(Bytes, length(Bytes)),'Failure on 3-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3, 4);
|
||
CheckEquals(false, TFormat_BigEndian64.IsValid(Bytes, length(Bytes)),'Failure on 4-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3, 4, 5, 6, 7, 8);
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(Bytes, length(Bytes)),'Failure on 8-byte data');
|
||
|
||
Bytes := TBytes.Create(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||
CheckEquals(true, TFormat_BigEndian64.IsValid(Bytes, length(Bytes)),'Failure on 16-byte data');
|
||
end;
|
||
|
||
initialization
|
||
// Register any test cases with the test runner
|
||
{$IFDEF DUnitX}
|
||
// TDUnitX.RegisterTestFixture(TestTFormat);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_HEX);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_HEXL);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_DECMIME32);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_Base64);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_Radix64);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_UU);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_XX);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_ESCAPE);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_BigEndian16);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_BigEndian32);
|
||
TDUnitX.RegisterTestFixture(TestTFormat_BigEndian64);
|
||
{$ELSE}
|
||
RegisterTests('DECFormat', [//TestTFormat,
|
||
TestTFormat_HEX.Suite,
|
||
TestTFormat_HEXL.Suite, TestTFormat_DECMIME32.Suite,
|
||
TestTFormat_Base64.Suite, TestTFormat_Radix64.Suite,
|
||
TestTFormat_UU.Suite, TestTFormat_XX.Suite,
|
||
TestTFormat_ESCAPE.Suite,
|
||
TestTFormat_BigEndian16.Suite,
|
||
TestTFormat_BigEndian32.Suite,
|
||
TestTFormat_BigEndian64.Suite]);
|
||
{$ENDIF}
|
||
|
||
finalization
|
||
end.
|
||
|
||
|