From 873fc46418af0fe97046a4a6917ec7bcf61dcdd3 Mon Sep 17 00:00:00 2001 From: Matthias Date: Sun, 31 Dec 2023 20:58:03 +0100 Subject: [PATCH 01/12] Add test/test cases for sdl2 unit (fptest) --- tests/sdl2forpascaltests.pas | 35 +++++++++++ tests/sdl2testcases.pas | 115 +++++++++++++++++++++++++++++++++++ 2 files changed, 150 insertions(+) create mode 100644 tests/sdl2forpascaltests.pas create mode 100644 tests/sdl2testcases.pas diff --git a/tests/sdl2forpascaltests.pas b/tests/sdl2forpascaltests.pas new file mode 100644 index 00000000..764f7f99 --- /dev/null +++ b/tests/sdl2forpascaltests.pas @@ -0,0 +1,35 @@ +program sdl2forpascaltests; + +{ + + sdl2forpascaltests - Testing SDL2-for-Pascal units + + These tests are meant to check if the SDL2-for-Pascal units/bindings + are working as expected and - especially - according to the + original SDL2 functions. These tests are not meant to pose + as test cases for original SDL2. + + This file is part of + + SDL2-for-Pascal + Copyright (C) 2020-2023 PGD Community + Visit: https://github.com/PascalGameDevelopment/SDL2-for-Pascal + + Compile this file by + + fpc -Fu"fptest/src;fptest/3rdparty/epiktimer;../units" sdl2forpascaltests.pas +} + +{$mode objfpc}{$H+} + +uses + Classes, + TextTestRunner, + sdl2testcases; + +begin + sdl2testcases.RegisterTests; + + RunRegisteredTests; +end. + diff --git a/tests/sdl2testcases.pas b/tests/sdl2testcases.pas new file mode 100644 index 00000000..6b0f7e1b --- /dev/null +++ b/tests/sdl2testcases.pas @@ -0,0 +1,115 @@ +unit sdl2testcases; + +{ + + sdl2testcases - Test cases for the SDL2-for-Pascal units + + Implementation of the test cases. + + This file is part of + + SDL2-for-Pascal + Copyright (C) 2020-2023 PGD Community + Visit: https://github.com/PascalGameDevelopment/SDL2-for-Pascal + +} + +{$mode ObjFPC}{$H+} + +interface + +uses + TestFramework; + +type + TTestCaseInit = class(TTestCase) + published + { Test initilization of SDL2 system with a sample of flags. } + procedure TestInit; + end; + +type + + { TTestCaseBasic } + + TTestCaseBasic = class(TTestCase) + protected + procedure SetUpOnce; override; + procedure TeardownOnce; override; + published + { Test version macros/functions of SDL2 system. } + procedure TestVersion; + end; + + +procedure RegisterTests; + + +implementation + +uses + Classes, + SysUtils, + SDL2; + +{ here we register all our test classes } +procedure RegisterTests; +begin + TestFramework.RegisterTest(TTestCaseInit.Suite); + TestFrameWork.RegisterTest(TTestCaseBasic.Suite); +end; + +procedure TTestCaseInit.TestInit; +const + Flags: array[0..12] of TSDL_Init = ( + { single flags } + SDL_INIT_TIMER, SDL_INIT_AUDIO, SDL_INIT_VIDEO, + SDL_INIT_JOYSTICK, SDL_INIT_HAPTIC, SDL_INIT_GAMECONTROLLER, + SDL_INIT_EVENTS, SDL_INIT_SENSOR, SDL_INIT_NOPARACHUTE, + SDL_INIT_EVERYTHING, + { typically combined flags } + SDL_INIT_AUDIO or SDL_INIT_VIDEO, + SDL_INIT_VIDEO or SDL_INIT_JOYSTICK, + SDL_INIT_VIDEO or SDL_INIT_GAMECONTROLLER or SDL_INIT_AUDIO); +var + Flag: TSDL_Init; +begin + for Flag in Flags do + begin + CheckEquals(0, SDL_Init(Flag), 'SDL_Init failed: Flag = ' + IntToStr(Flag)); + SDL_Quit; + end; +end; + +procedure TTestCaseBasic.SetUpOnce; +begin + inherited SetUpOnce; + SDL_Init(SDL_INIT_EVERYTHING); +end; + +procedure TTestCaseBasic.TeardownOnce; +begin + SDL_Quit; + inherited TeardownOnce; +end; + +procedure TTestCaseBasic.TestVersion; +var + CompiledVersion: TSDL_Version = (major: 0; minor: 0; patch: 0); + LinkedVersion: TSDL_Version = (major: 0; minor: 0; patch: 0); +begin + CheckEquals(1203, SDL_VERSIONNUM(1,2,3), 'SDL_VERSIONNUM failed: 1203 expected, found: ' + IntToStr(SDL_VERSIONNUM(1,2,3))); + + SDL_VERSION(CompiledVersion); + CheckEquals(SDL_COMPILEDVERSION, SDL_VERSIONNUM(CompiledVersion.major, CompiledVersion.minor, CompiledVersion.patch), 'SDL_VERSION or SDL_COMPILEDVERSION failed: Version results do not match!'); + + CheckTrue(SDL_VERSION_ATLEAST(2,0,0), 'SDL_VERSION_ATLEAST failed: Version at least 2.0.0 should be true!'); + + CheckFalse(SDL_VERSION_ATLEAST(3,0,0), 'SDL_VERSION_ATLEAST failed: Version at least 3.0.0 should be false!'); + + SDL_GetVersion(@LinkedVersion); + CheckNotNull(@LinkedVersion, 'SDL_GetVersion failed'); +end; + +end. + From b5b5d420c03ff7c4369b0ba57bf057d6dd05b2ba Mon Sep 17 00:00:00 2001 From: Matthias Date: Sun, 31 Dec 2023 21:08:47 +0100 Subject: [PATCH 02/12] Add fptest testing framework sources - incl. 3rd party epiktimer unit - fptest sources slightly modified --- tests/fptest/3rdparty/epiktimer/README.txt | 128 + tests/fptest/3rdparty/epiktimer/epiktimer.pas | 816 ++++ tests/fptest/LICENSE_MPL-1.1.txt | 470 ++ tests/fptest/README.adoc | 70 + .../fptest/src/FPCUnitCompatibleInterface.inc | 189 + tests/fptest/src/ProjectsManager.pas | 549 +++ tests/fptest/src/ProjectsManagerIface.pas | 78 + tests/fptest/src/TestExtensions.pas | 81 + tests/fptest/src/TestFramework.pas | 4149 +++++++++++++++++ tests/fptest/src/TestFrameworkIfaces.pas | 540 +++ tests/fptest/src/TestFrameworkProxy.pas | 1394 ++++++ tests/fptest/src/TestFrameworkProxyIfaces.pas | 262 ++ tests/fptest/src/TestListenerIface.pas | 86 + tests/fptest/src/TestModules.pas | 133 + tests/fptest/src/TextTestRunner.pas | 500 ++ tests/fptest/src/XMLListener.pas | 505 ++ tests/fptest/src/fpchelper.pas | 74 + tests/fptest/src/timemanager.pas | 72 + 18 files changed, 10096 insertions(+) create mode 100644 tests/fptest/3rdparty/epiktimer/README.txt create mode 100644 tests/fptest/3rdparty/epiktimer/epiktimer.pas create mode 100644 tests/fptest/LICENSE_MPL-1.1.txt create mode 100644 tests/fptest/README.adoc create mode 100644 tests/fptest/src/FPCUnitCompatibleInterface.inc create mode 100644 tests/fptest/src/ProjectsManager.pas create mode 100644 tests/fptest/src/ProjectsManagerIface.pas create mode 100644 tests/fptest/src/TestExtensions.pas create mode 100644 tests/fptest/src/TestFramework.pas create mode 100644 tests/fptest/src/TestFrameworkIfaces.pas create mode 100644 tests/fptest/src/TestFrameworkProxy.pas create mode 100644 tests/fptest/src/TestFrameworkProxyIfaces.pas create mode 100644 tests/fptest/src/TestListenerIface.pas create mode 100644 tests/fptest/src/TestModules.pas create mode 100644 tests/fptest/src/TextTestRunner.pas create mode 100644 tests/fptest/src/XMLListener.pas create mode 100644 tests/fptest/src/fpchelper.pas create mode 100644 tests/fptest/src/timemanager.pas diff --git a/tests/fptest/3rdparty/epiktimer/README.txt b/tests/fptest/3rdparty/epiktimer/README.txt new file mode 100644 index 00000000..eba2f29b --- /dev/null +++ b/tests/fptest/3rdparty/epiktimer/README.txt @@ -0,0 +1,128 @@ + + + Description: Precision timer/stopwatch component for Lazarus/FPC + Author: Tom Lisjac + Contributors: + * Felipe Monteiro de Carvalho + * Marcel Minderhoud + License: Modifyed LGPL (The same as Free Pascal RTL and LCL) + Copyright (C) 2003-2006 by Tom Lisjac, Felipe Monteiro de Carvalho and Marcel Minderhoud + Latest version can be obtained at: http://wiki.lazarus.freepascal.org/EpikTimer + + Contents: + + 1. The EpikTimer.pas component and palette icon + 2. ETPackage.lpk package for installation + 3. ETDemo demonstration app and host system clock evaluator + + ----------------------------------------------------------------- + + The EpikTimer Component + + Documentation: + See epiktimer.pas for detailed discussion of timebase sources, timing + accuracy and clock correlation techniques that can provide traceable + precision during long term measurements. + + Installation: + - In Components/Open Package File, open etpackage.lpk. + - Compile the component to verify that everything is there. + - Install and let Lazarus rebuild + - Component will be in the System Palette (stopwatch-ruler icon) + + Usage: + Drop the component on a form. The component contains a single timer + instance and parameterless calls to start, stop, elapsed and clear + will implicitly reference it. If the timer is named ET: + + Procedure InstrumentedCall; + Begin + ET.Clear; // optional... timer is cleared at creation + ET.Start; + ExecuteFirstTimedSection; + ET.Stop; // the timer is actually paused and can be restarted later + TimedSection1:=ET.Elapsed; // store the elapsed in a global + MakeAnUntimedOverheadCall; // not counted in the timer + ET.Start; //resume the timer... continue accumulating ticks + CallTimedSection2; + TimedSection2:=ET.Elapsed; //timer keeps running... we've just sample it. + CallTimedSection3; + CallSomethingElse; + TimedSection3:=ET.Elapsed; //keep counting... tap the elapsed + CallTimedSection4; + TimedSection4:=ET.Elapsed; //keep counting... tap the elapsed + ET.clear // done... timer is stopped and zeroed + end; + + You can also create any number of timers from a single component on + the form by declaring a TimerData record and passing it as a parameter + to start, stop, elapsed and clear using the overloaded methods in the + component. An example would be: + + Function TimedExecution:Extended; + Var DiskAccessTime:TimerData; + Begin + ET.Clear(DiskAccessTimer); // Declared timers *must* be cleared before use. + ET.Start(DiskAccessTimer); + ExecuteTheTimedSection; + Result:=ET.Elapsed(DiskAccessTimer); // the timer keeps running... + etc... + + See etdemo.pas for additional examples of component usage + + The ETDemo Application + + The ETDemo application does not require EpikTimer to be installed in order + to compile and operate. I never liked having to install a palette full of + components only to find out that I didn't like any of them! :) + + Installation + + Open etdemo.lpi and compile it. + + Operation + + As the program comes up, it will create and initialize 10 invisible timer + forms that can be spawned from the main program's Stopwatch group box. A + progress bar is supposed to reduce the boredom. + + Host Hardware Information + + This group evaluates the host system and reports if it finds hardware + support for the Pentium Time Stamp Counter. If so, you'll be able to get + a snapshot of it's value along with the microsecond ticks from your + OS clock. The sizes of the hardware and system ticks isn't as important + as the rates that they change. On a Linux system, the system ticks value + represent microseconds of Epoch time. + + Timebase Calibration + + If your system lacks the TSC or a microsecond resolution system clock, + EpikTimer falls back to using gated measurements for setting the + internal tick frequencies. Timing is non-deterministic when calling + the Linux kernel so some averaging and smoothing of the resulting jitter + is helpful. If EpikTimer is in this mode, long term accuracy isn't + guaranteed... but short term comparitive measurements can still be made. + + Pressing "Calibrate" performs overhead extraction and gates the selected + timebase against the best timebase gate available on a given host. The + results are displayed in the memo boxes. + + Timebase Correlation + + This is the default mode for measuring the TSC frequency and provides a + reliable mechanism for synchronizing the TSC ticks to the system clock. + If the system clock is maintained via NTP and the CorrelateTimebases + method is called at regular intervals, the TSC stream can display the + same long term accuracy (at very high resolutions) as the quality of + the system's synchronizing time source. + + Timer/Stopwatch Functions + + This section implements a single stopwatch using the component's internal + timer data record. The Spawn Timers group box will bring up the 10 timers + that were created and initialized during program startup. + + + ----------------- End of EpikTimer Release Documentation ------------------ + diff --git a/tests/fptest/3rdparty/epiktimer/epiktimer.pas b/tests/fptest/3rdparty/epiktimer/epiktimer.pas new file mode 100644 index 00000000..ac29d34c --- /dev/null +++ b/tests/fptest/3rdparty/epiktimer/epiktimer.pas @@ -0,0 +1,816 @@ +unit EpikTimer; + +{ Name: EpikTimer + Description: Precision timer/stopwatch component for Lazarus/FPC + Author: Tom Lisjac + Started on: June 24, 2003 + Features: + Dual selectable timebases: Default:System (uSec timeofday or "now" in Win32) + Optional: Pentium Time Stamp Counter. + Default timebase should work on most Unix systems of any architecture. + Timebase correlation locks time stamp counter accuracy to system clock. + Timers can be started, stopped, paused and resumed. + Unlimited number of timers can be implemented with one component. + Low resources required: 25 bytes per timer; No CPU overhead. + Internal call overhead compensation. + System sleep function + Designed to support multiple operating systems and Architectures + Designed to support other hardware tick sources + + Credits: Thanks to Martin Waldenburg for a lot of great ideas for using + the Pentium's RDTSC instruction in wmFastTime and QwmFastTime. +} + +{ Copyright (C) 2003-2014 by Tom Lisjac , + Felipe Monteiro de Carvalho and Marcel Minderhoud + + This library is licensed on the same Modified LGPL as Free Pascal RTL and LCL are + + Please contact the author if you'd like to use this component but the Modified LGPL + doesn't work with your project licensing. + + This program is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + Contributor(s): + + * Felipe Monteiro de Carvalho (felipemonteiro.carvalho@gmail.com) + * Marcel Minderhoud + * Graeme Geldenhuys + +} +{ + Known Issues + + - If system doesn't have microsecond system clock resolution, the component + falls back to a single gated measurement of the hardware tick frequency via + nanosleep. This usually results in poor absolute accuracy due large amounts + of jitter in nanosleep... but for typical short term measurements, this + shouldn't be a problem. + +} + +{$IFDEF FPC} + {$MODE DELPHI}{$H+} +{$ENDIF} + +{$IFNDEF FPC} + {$DEFINE Windows} +{$ENDIF} + +{$IFDEF Win32} + {$DEFINE Windows} +{$ENDIF} + +interface + +uses +{$IFDEF Windows} + Windows, MMSystem, +{$ELSE} + unix, unixutil, baseunix, + {$IFDEF LINUX} + Linux, // for clock_gettime() access + {$ENDIF} + {$IFDEF FreeBSD} + FreeBSD, // for clock_gettime() access + {$ENDIF} +{$ENDIF} + Classes, SysUtils, dateutils; + +Const + DefaultSystemTicksPerSecond = 1000000; //Divisor for microsecond resolution + { HW Tick frequency falls back to gated measurement if the initial system + clock measurement is outside this range plus or minus.} + SystemTicksNormalRangeLimit = 100000; + +type + + TickType = Int64; // Global declaration for all tick processing routines + + FormatPrecision = 1..12; // Number of decimal places in elapsed text format + + // Component powers up in System mode to provide some cross-platform safety. + TickSources = (SystemTimebase, HardwareTimebase); // add others if desired + + (* * * * * * * * * * * Timebase declarations * * * * * * * * * * *) + + { There are two timebases currently implemented in this component but others + can be added by declaring them as "TickSources", adding a TimebaseData + variable to the Private area of TEpikTimer and providing a "Ticks" routine + that returns the current counter value. + + Timebases are "calibrated" during initialization by taking samples of the + execution times of the SystemSleep and Ticks functions measured with in the + tick period of the selected timebase. At runtime, these values are retrieved + and used to remove the call overhead to the best degree possible. + + System latency is always present and contributes "jitter" to the edges of + the sample measurements. This is especially true if a microsecond system + clock isn't detected on the host system and a fallback gated measurement + (based on nanosleep in Linux and sleep in Win32) is used to determine the + timebase frequency. This is sufficient for short term measurements where + high resolution comparisons are desired... but over a long measurement + period, the hardware and system wall clock will diverge significantly. + + If a microsecond system clock is found, timebase correlation is used to + synchronize the hardware counter and system clock. This is described below. + } + + TickCallFunc = function: Ticktype; // Ticks interface function + + // Contains timebase overhead compensation factors in ticks for each timebase + TimebaseCalibrationParameters = record + FreqCalibrated: Boolean; // Indicates that the tickfrequency has been calibrated + OverheadCalibrated: Boolean; // Indicates that all call overheads have been calibrated + TicksIterations: Integer; // number of iterations to use when measuring ticks overhead + SleepIterations: Integer; // number of iterations to use when measuring SystemSleep overhead + FreqIterations: Integer; // number of iterations to use when measuring ticks frequency + FrequencyGateTimeMS: Integer; // gate time to use when measuring ticks frequency + end; + + // This record defines the Timebase context + TimebaseData = record + CalibrationParms: TimebaseCalibrationParameters; // Calibration data for this timebase + TicksFrequency: TickType; // Tick frequency of this timebase + TicksOverhead: Ticktype; // Ticks call overhead in TicksFrequency for this timebase + SleepOverhead: Ticktype; // SystemSleep all overhead in TicksFrequency for this timebase + Ticks: TickCallFunc; // all methods get their ticks from this function when selected + end; + + TimeBaseSelector = ^TimebaseData; + + (* * * * * * * * * * * Timebase Correlation * * * * * * * * * * *) + + { The TimeBaseCorrelation record stores snapshot samples of both the system + ticks (the source of known accuracy) and the hardware tick source (the + source of high measurement resolution). An initial sample is taken at power + up. The CorrelationMode property sets where and when updates are acquired. + + When an update snapshot is acquired, the differences between it and the + startup value can be used to calculate the hardware clock frequency with + high precision from the accuracy of the accumulated system clocks. The + longer time that elapses between startup and a call to "CorrelateTimebases", + the better the accuracy will be. On a 1.6 Ghz P4, it only takes a few + seconds to achieve measurement certainty down to a few Hertz. + + Of course this system is only as good as your system clock accuracy, so + it's a good idea to periodically sync it with NTP or against another source + of known accuracy if you want to maximize the long term of the timers. } + + TimebaseCorrelationData = record + SystemTicks: TickType; + HWTicks: TickType; + end; + + // If the Correlation property is set to automatic, an update sample is taken + // anytime the user calls Start or Elapsed. If in manual, the correlation + // update is only done when "CorrelateTimebases" is called. Doing updates + // with every call adds a small amount of overhead... and after the first few + // minutes of operation, there won't be very much correcting to do! + + CorrelationModes=(Manual, OnTimebaseSelect, OnGetElapsed); + + (* * * * * * * * * * * Timer Data record structure * * * * * * * * * * *) + + // This is the timer data context. There is an internal declaration of this + // record and overloaded methods if you only want to use the component for a + // single timer... or you can declare multiple TimerData records in your + // program and create as many instances as you want with only a single + // component on the form. See the "Stopwatch" methods in the TEpikTimer class. + + // Each timers points to the timebase that started it... so you can mix system + // and hardware timers in the same application. + + TimerData = record + Running:Boolean; // Timer is currently running + TimebaseUsed:TimeBaseSelector; // keeps timer aligned with the source that started it. + StartTime:TickType; // Ticks sample when timer was started + TotalTicks:TickType; // Total ticks... for snapshotting and pausing + end; + + TEpikTimer= class(TComponent) + private + BuiltInTimer:TimerData; // Used to provide a single built-in timer; + FHWTickSupportAvailable:Boolean; // True if hardware tick support is available + FHWCapabilityDataAvailable:Boolean; // True if hardware tick support is available + FHWTicks:TimeBaseData; // The hardware timebase + FSystemTicks:TimeBaseData; // The system timebase + FSelectedTimebase:TimeBaseSelector; // Pointer to selected database + + FTimeBaseSource: TickSources; // use hardware or system timebase + FWantDays: Boolean; // true if days are to be displayed in string returns + FWantMS: Boolean; // True to display milliseconds in string formatted calls + FSPrecision: FormatPrecision; // number of digits to display in string calls + FMicrosecondSystemClockAvailable:Boolean; // true if system has microsecond clock + + StartupCorrelationSample:TimebaseCorrelationData; // Starting ticks correlation snapshot + UpdatedCorrelationSample:TimebaseCorrelationData; // Snapshot of last correlation sample + FCorrelationMode: CorrelationModes; // mode to control when correlation updates are performed + protected + function GetSelectedTimebase: TimebaseData; + procedure SetSelectedTimebase(const AValue: TimebaseData); + procedure SetTimebaseSource(const AValue: TickSources); //setter for TB + Procedure GetCorrelationSample(Var CorrelationData:TimeBaseCorrelationData); + public + { Stopwatch emulation routines + These routines behave exactly like a conventional stopwatch with start, + stop, elapsed (lap) and clear methods. The timers can be started, + stopped and resumed. The Elapsed routines provide a "lap" time analog. + + The methods are overloaded to make it easy to simply use the component's + BuiltInTimer as a single timer... or to declare your own TimerData records + in order to implement unlimited numbers of timers using a single component + on the form. The timers are very resource efficient because they consume + no CPU overhead and only require about 25 bytes of memory. + } + + // Stops and resets the timer + procedure Clear; overload;// Call this routine to use the built-in timer record + procedure Clear(Var T:TimerData); overload; // pass your TimerData record to this one + + //Start or resume a stopped timer + procedure Start; overload; + procedure Start(Var T:TimerData); overload; + + //Stop or pause a timer + procedure Stop; overload; + procedure Stop(Var T:TimerData); overload; + + //Return elapsed time in seconds as an extended type + function Elapsed:Extended; overload; + function Elapsed(var T: TimerData):Extended; overload; + + //Return a string in Day:Hour:Minute:Second format. Milliseconds can be + //optionally appended via the WantMilliseconds property + function ElapsedDHMS:String; overload; + function ElapsedDHMS(var T: TimerData):String; overload; + + //Return a string in the format of seconds.milliseconds + function ElapsedStr:String; overload; + function ElapsedStr(var T:TimerData):String; overload; + + function WallClockTime:String; // Return time of day string from system time + + //Overhead compensated system sleep to provide a best possible precision delay + function SystemSleep(Milliseconds: Integer):integer; Virtual; + + //Diagnostic taps for development and fine grained timebase adjustment + property HWTimebase: TimeBaseData read FHWTicks write FHWTicks; // The hardware timebase + property SysTimebase: TimebaseData read FSystemTicks write FSystemTicks; + function GetHardwareTicks:TickType; // return raw tick value from hardware source + function GetSystemTicks:Ticktype; // Return system tick value(in microseconds of Epoch time) + function GetTimebaseCorrelation:TickType; + function CalibrateCallOverheads(Var TimeBase:TimebaseData) : Integer; Virtual; + function CalibrateTickFrequency(Var TimeBase:TimebaseData): Integer; Virtual; + + property MicrosecondSystemClockAvailable:Boolean read FMicrosecondSystemClockAvailable; + property SelectedTimebase:TimebaseSelector read FSelectedTimebase write FSelectedTimebase; + property HWTickSupportAvailable:Boolean read FHWTickSupportAvailable; + property HWCapabilityDataAvailable:Boolean read FHWCapabilityDataAvailable; + procedure CorrelateTimebases; // Manually call to do timebase correlation snapshot and update + + constructor Create(AOwner:TComponent); Override; + destructor Destroy; Override; + Published + property StringPrecision: FormatPrecision read FSPrecision write FSPrecision; + property WantMilliseconds: Boolean read FWantMS write FWantMS default True; + property WantDays: Boolean read FWantDays write FWantDays default False; + property TimebaseSource: TickSources read FTimeBaseSource write SetTimebaseSource; + property CorrelationMode:CorrelationModes read FCorrelationMode write FCorrelationMode; + end; + + +implementation + +(* * * * * * * * * * * * * * Timebase Section * * * * * * * * * * * * *) +{ + There are two tick sources defined in this section. The first uses a hardware + source which, in this case, is the Pentium's internal 64 Time Stamp Counter. + The second source (the default) uses the given environment's most precision + "timeofday" system call so it can work across OS platforms and architectures. + + The hardware timer's accuracy depends on the frequency of the timebase tick + source that drives it... in other words, how many of the timebase's ticks + there are in a second. This frequency is measured by capturing a sample of the + timebase ticks for a known period against a source of known accuracy. There + are two ways to do this. + + The first is to capture a large sample of ticks from both the unknown and + known timing sources. Then the frequency of the unknown tick stream can be + calculated by: UnknownSampleTicks / (KnownSampleTicks / KnownTickFrequency). + Over a short period of time, this can provide a precise synchronization + mechanism that effectively locks the measurements taken with the high + resolution source to the known accuracy of the system clock. + + The first method depends on the existance of an accurate system time source of + microsecond resolution. If the host system doesn't provide this, the second + fallback method is to gate the unknown tick stream by a known time. This isn't + as good because it usually involves calling a system "delay" routine that + usually has a lot of overhead "jitter" and non-deterministic behavior. This + approach is usable, however, for short term, high resolution comparisons where + absolute accuracy isn't important. +} + +const + NanoPerSec = 1000000000; // 1 billionth of a second + NanoPerMilli = 1000000; // 1 millionth of a millisecond + MilliPerSec = 1000; + USecPerSec = 1000000; // Microsecond. 1 millionth of a second + + +(* * * * * * * * Start of i386 Hardware specific code * * * * * * *) + +{$IFDEF CPUI386} +{ Some references for this section can be found at: + http://www.sandpile.org/ia32/cpuid.htm + http://www.sandpile.org/ia32/opc_2.htm + http://www.sandpile.org/ia32/msr.htm +} + +// Pentium specific... push and pop the flags and check for CPUID availability +function HasHardwareCapabilityData: Boolean; +begin + asm + PUSHFD + POP EAX + MOV EDX,EAX + XOR EAX,$200000 + PUSH EAX + POPFD + PUSHFD + POP EAX + XOR EAX,EDX + JZ @EXIT + MOV AL,TRUE + @EXIT: + end; +end; + +function HasHardwareTickCounter: Boolean; + var FeatureFlags: Longword; + begin + FeatureFlags:=0; + asm + PUSH EBX + XOR EAX,EAX + DW $A20F + POP EBX + CMP EAX,1 + JL @EXIT + XOR EAX,EAX + MOV EAX,1 + PUSH EBX + DW $A20F + MOV FEATUREFLAGS,EDX + POP EBX + @EXIT: + end; + Result := (FeatureFlags and $10) <> 0; + end; + +// Execute the Pentium's RDTSC instruction to access the counter value. +function HardwareTicks: TickType; assembler; asm DW 0310FH end; + +(* * * * * * * * End of i386 Hardware specific code * * * * * * *) + + +// These are here for architectures that don't have a precision hardware +// timing source. They'll return zeros for overhead values. The timers +// will work but there won't be any error compensation for long +// term accuracy. +{$ELSE} // add other architectures and hardware specific tick sources here +function HasHardwareCapabilityData: Boolean; begin Result:=False end; +function HasHardwareTickCounter: Boolean; begin Result:=false end; +function HardwareTicks:TickType; begin result:=0 end; +{$ENDIF} + +function NullHardwareTicks:TickType; begin Result:=0 end; + +// Return microsecond normalized time source for a given platform. +// This should be sync'able to an external time standard (via NTP, for example). +function SystemTicks: TickType; +{$IFDEF WINDOWS} +begin + QueryPerformanceCounter(Result); +{$ELSE} + {$IF defined(LINUX) or defined(FreeBSD)} + // This is essentially the same as FPC 3.0.4's GetTickCount64() call + function _GetTickCount: QWord; + var + ts: TTimeSpec; + t: timeval; + begin + // use the Posix clock_gettime() call + if clock_gettime(CLOCK_MONOTONIC, @ts)=0 then + begin + Result := (TickType(ts.tv_sec) * MilliPerSec) + (ts.tv_nsec div NanoPerMilli); + Exit; + end; + // Use the FPC fallback + fpgettimeofday(@t,nil); + Result := (TickType(t.tv_sec) * MilliPerSec) + (t.tv_usec div 1000 { microsecond to millisecond }); + end; + +begin + Result := _GetTickCount; + {$ELSE} + Result := GetTickCount64; + {$ENDIF} +{$ENDIF} +end; + +function TEpikTimer.SystemSleep(Milliseconds: Integer): integer; +begin + Sleep(Milliseconds); + Result := 0; +end; + +function TEpikTimer.GetHardwareTicks: TickType; +begin + Result:=FHWTicks.Ticks(); +end; + +function TEpikTimer.GetSystemTicks: Ticktype; +begin + Result:=FSystemTicks.Ticks(); +end; + +procedure TEpikTimer.SetTimebaseSource(const AValue: TickSources); + + procedure UseSystemTimer; + begin + FTimeBaseSource := SystemTimebase; + SelectedTimebase := @FSystemTicks; + end; + +begin + case AValue of + HardwareTimebase: + try + if HWTickSupportAvailable then + begin + SelectedTimebase:=@FHWTicks; + FTimeBaseSource:=HardwareTimebase; + If CorrelationMode<>Manual then CorrelateTimebases + end + except // If HW init fails, fall back to system tick source + UseSystemTimer + end; + SystemTimeBase: UseSystemTimer + end +end; + +function TEpikTimer.GetSelectedTimebase: TimebaseData; +begin + Result := FSelectedTimebase^; +end; + +procedure TEpikTimer.SetSelectedTimebase(const AValue: TimebaseData); +begin + FSelectedTimebase^ := AValue; +end; + +(* * * * * * * * * * Time measurement core routines * * * * * * * * * *) + +procedure TEpikTimer.Clear(var T: TimerData); +begin + with T do + begin + Running:=False; StartTime:=0; TotalTicks:=0; TimeBaseUsed:=FSelectedTimebase + end; +end; + +procedure TEpikTimer.Start(var T: TimerData); +begin + if not T.running then + With FSelectedTimebase^ do + begin + T.StartTime:=Ticks()-TicksOverhead; + T.TimebaseUsed:=FSelectedTimebase; + T.Running:=True + end +end; + +procedure TEpikTimer.Stop(var T: TimerData); + Var CurTicks:TickType; +Begin + if T.Running then + With T.TimebaseUsed^ do + Begin + CurTicks:=Ticks()-TicksOverhead; // Back out the call overhead + T.TotalTicks:=(CurTicks - T.Starttime)+T.TotalTicks; T.Running:=false + end +end; + +function TEpikTimer.Elapsed(var T: TimerData): Extended; +var + CurTicks: TickType; +begin + With T.TimebaseUsed^ do + if T.Running then + Begin + + CurTicks:=Ticks()-TicksOverhead; // Back out the call overhead + If CorrelationMode>OnTimebaseSelect then CorrelateTimebases; + + Result := ((CurTicks - T.Starttime)+T.TotalTicks) / TicksFrequency + End + Else Result := T.TotalTicks / TicksFrequency; +end; + +(* * * * * * * * * * Output formatting routines * * * * * * * * * *) + +function TEpikTimer.ElapsedDHMS(var T: TimerData): String; +var + Tmp, MS: extended; + D, H, M, S: Integer; + P, SM: string; +begin + Tmp := Elapsed(T); + P := inttostr(FSPrecision); + MS := frac(Tmp); SM := format('%0.'+P+'f',[MS]); delete(SM,1,1); + D := trunc(Tmp / 86400); Tmp := Trunc(tmp) mod 86400; + H := trunc(Tmp / 3600); Tmp := Trunc(Tmp) mod 3600; + M := Trunc(Tmp / 60); S := (trunc(Tmp) mod 60); + + if FWantDays then + Result := format('%2.3d:%2.2d:%2.2d:%2.2d',[D,H,M,S]) + else + Result := format('%2.2d:%2.2d:%2.2d',[H,M,S]); + + if FWantMS then + Result := Result+SM; +end; + +function TEpikTimer.ElapsedStr(var T: TimerData): String; +begin + Result := format('%.'+inttostr(FSPrecision)+'f',[Elapsed(T)]); +end; + +function TEpikTimer.WallClockTime: String; +var + Y, D, M, hour, min, sec, ms, us: Word; +{$IFNDEF Windows} + t: timeval; +{$ENDIF} +begin +{$IFDEF Windows} + DecodeDatetime(Now, Y, D, M, Hour, min, Sec, ms); + us:=0; +{$ELSE} + // "Now" doesn't report milliseconds on Linux... appears to be broken. + // I opted for this approach which also provides microsecond precision. + fpgettimeofday(@t,nil); + EpochToLocal(t.tv_sec, Y, M, D, hour, min, sec); + ms:=t.tv_usec div MilliPerSec; + us:=t.tv_usec mod MilliPerSec; +{$ENDIF} + Result:=''; + If FWantDays then + Result := Format('%4.4d/%2.2d/%2.2d-',[Y,M,D]); + Result := Result + Format('%2.2d:%2.2d:%2.2d',[hour,min,sec]); + If FWantMS then + Result := Result + Format('.%3.3d%3.3d',[ms,us]) +end; + +(* * * Overloaded methods to use the component's internal timer data * * *) + +procedure TEpikTimer.Clear; +begin + Clear(BuiltInTimer); +end; + +procedure TEpikTimer.Start; +begin + Start(BuiltInTimer); +end; + +procedure TEpikTimer.Stop; +begin + Stop(BuiltInTimer); +end; + +function TEpikTimer.Elapsed: Extended; +begin + Result := Elapsed(BuiltInTimer); +end; + +function TEpikTimer.ElapsedStr: String; +begin + Result := ElapsedStr(BuiltInTimer); +end; + +function TEpikTimer.ElapsedDHMS: String; +begin + Result := ElapsedDHMS(BuiltInTimer); +end; + +(* * * * * * * * * * Timebase calibration section * * * * * * * * * *) + +// Set up compensation for call overhead to the Ticks and SystemSleep functions. +// The Timebase record contains Calibration parameters to be used for each +// timebase source. These have to be unique as the output of this measurement +// is measured in "ticks"... which are different periods for each timebase. + +function TEpikTimer.CalibrateCallOverheads(var TimeBase: TimebaseData): Integer; +var i:Integer; St,Fin,Total:TickType; +begin + with Timebase, Timebase.CalibrationParms do + begin + Total:=0; Result:=1; + for I:=1 to TicksIterations do // First get the base tick getting overhead + begin + St:=Ticks(); Fin:=Ticks(); + Total:=Total+(Fin-St); // dump the first sample + end; + TicksOverhead:=Total div TicksIterations; + Total:=0; + For I:=1 to SleepIterations do + Begin + St:=Ticks(); + if SystemSleep(0)<>0 then exit; + Fin:=Ticks(); + Total:=Total+((Fin-St)-TicksOverhead); + End; + SleepOverhead:=Total div SleepIterations; + OverheadCalibrated:=True; Result:=0 + End +end; + +// CalibrateTickFrequency is a fallback in case a microsecond resolution system +// clock isn't found. It's still important because the long term accuracy of the +// timers will depend on the determination of the tick frequency... in other words, +// the number of ticks it takes to make a second. If this measurement isn't +// accurate, the counters will proportionately drift over time. +// +// The technique used here is to gate a sample of the tick stream with a known +// time reference which, in this case, is nanosleep. There is a *lot* of jitter +// in a nanosleep call so an attempt is made to compensate for some of it here. + +function TEpikTimer.CalibrateTickFrequency(var TimeBase: TimebaseData): Integer; +var + i: Integer; + Total, SS, SE: TickType; + ElapsedTicks, SampleTime: Extended; +begin + With Timebase, Timebase.CalibrationParms do + Begin + Result:=1; //maintain unitialized default in case something goes wrong. + Total:=0; + For i:=1 to FreqIterations do + begin + SS:=Ticks(); + SystemSleep(FrequencyGateTimeMS); + SE:=Ticks(); + Total:=Total+((SE-SS)-(SleepOverhead+TicksOverhead)) + End; + //doing the floating point conversion allows SampleTime parms of < 1 second + ElapsedTicks:=Total div FreqIterations; + SampleTime:=FrequencyGateTimeMS; + + TicksFrequency:=Trunc( ElapsedTicks / (SampleTime / MilliPerSec)); + + FreqCalibrated:=True; + end; +end; + +// Grab a snapshot of the system and hardware tick sources... as quickly as +// possible and with overhead compensation. These samples will be used to +// correct the accuracy of the hardware tick frequency source when precision +// long term measurements are desired. +procedure TEpikTimer.GetCorrelationSample(var CorrelationData: TimeBaseCorrelationData); +Var + TicksHW, TicksSys: TickType; + THW, TSYS: TickCallFunc; +begin + THW:=FHWTicks.Ticks; TSYS:=FSystemTicks.Ticks; + TicksHW:=THW(); TicksSys:=TSYS(); + With CorrelationData do + Begin + SystemTicks:= TicksSys-FSystemTicks.TicksOverhead; + HWTicks:=TicksHW-FHWTicks.TicksOverhead; + End +end; + +(* * * * * * * * * * Timebase correlation section * * * * * * * * * *) + +{ Get another snapshot of the system and hardware tick sources and compute a + corrected value for the hardware frequency. In a short amount of time, the + microsecond system clock accumulates enough ticks to perform a *very* + accurate frequency measurement of the typically picosecond time stamp counter. } + +function TEpikTimer.GetTimebaseCorrelation: TickType; +Var + HWDiff, SysDiff, Corrected: Extended; +begin + If HWtickSupportAvailable then + Begin + GetCorrelationSample(UpdatedCorrelationSample); + HWDiff:=UpdatedCorrelationSample.HWTicks-StartupCorrelationSample.HWTicks; + SysDiff:=UpdatedCorrelationSample.SystemTicks-StartupCorrelationSample.SystemTicks; + Corrected:=HWDiff / (SysDiff / DefaultSystemTicksPerSecond); + Result:=trunc(Corrected) + End + else result:=0 +end; + +{ If an accurate reference is available, update the TicksFrequency of the + hardware timebase. } +procedure TEpikTimer.CorrelateTimebases; +begin + If MicrosecondSystemClockAvailable and HWTickSupportAvailable then + FHWTicks.TicksFrequency:=GetTimebaseCorrelation +end; + +(* * * * * * * * Initialization: Constructor and Destructor * * * * * * *) + +constructor TEpikTimer.Create(AOwner: TComponent); + + Procedure InitTimebases; + Begin + + { Tick frequency rates are different for the system and HW timebases so we + need to store calibration data in the period format of each one. } + FSystemTicks.Ticks:=@SystemTicks; // Point to Ticks routine + With FSystemTicks.CalibrationParms do + Begin + FreqCalibrated:=False; + OverheadCalibrated:=False; + TicksIterations:=5; + SleepIterations:=10; + FrequencyGateTimeMS:=100; + FreqIterations:=1; + End; + + // Initialize the HW tick source data + FHWCapabilityDataAvailable:=False; + FHWTickSupportAvailable:=False; + FHWTicks.Ticks:=@NullHardwareTicks; // returns a zero if no HW support + FHWTicks.TicksFrequency:=1; + With FHWTicks.CalibrationParms do + Begin + FreqCalibrated:=False; + OverheadCalibrated:=False; + TicksIterations:=10; + SleepIterations:=20; + FrequencyGateTimeMS:=150; + FreqIterations:=1; + End; + + if HasHardwareCapabilityData then + Begin + FHWCapabilityDataAvailable:=True; + If HasHardwareTickCounter then + Begin + FHWTicks.Ticks:=@HardwareTicks; + FHWTickSupportAvailable:=CalibrateCallOverheads(FHWTicks)=0 + End + end; + + CalibrateCallOverheads(FSystemTicks); + CalibrateTickFrequency(FSystemTicks); + + // Overheads are set... get starting timestamps for long term calibration runs + GetCorrelationSample(StartupCorrelationSample); + With FSystemTicks do + If (TicksFrequency>(DefaultSystemTicksPerSecond-SystemTicksNormalRangeLimit)) and + (TicksFrequency<(DefaultSystemTicksPerSecond+SystemTicksNormalRangeLimit)) then + Begin // We've got a good microsecond system clock + FSystemTicks.TicksFrequency:=DefaultSystemTicksPerSecond; // assume it's pure + FMicrosecondSystemClockAvailable:=True; + If FHWTickSupportAvailable then + Begin + SystemSleep(FHWTicks.CalibrationParms.FrequencyGateTimeMS); // rough gate + CorrelateTimebases + End + end + else + Begin + FMicrosecondSystemClockAvailable:=False; + If FHWTickSupportAvailable then + CalibrateTickFrequency(FHWTicks) // sloppy but usable fallback calibration + End; + End; + +begin + inherited Create(AOwner); + StringPrecision := 6; + FWantMS := True; + FWantDays := False; + InitTimebases; + CorrelationMode := OnTimebaseSelect; + // Default is the safe, cross-platform but less precise system timebase + TimebaseSource := SystemTimebase; + Clear(BuiltInTimer) +end; + +destructor TEpikTimer.Destroy; +begin + inherited Destroy; + // here in case we need to clean something up in a later version +end; + +end. + diff --git a/tests/fptest/LICENSE_MPL-1.1.txt b/tests/fptest/LICENSE_MPL-1.1.txt new file mode 100644 index 00000000..7714141d --- /dev/null +++ b/tests/fptest/LICENSE_MPL-1.1.txt @@ -0,0 +1,470 @@ + MOZILLA PUBLIC LICENSE + Version 1.1 + + --------------- + +1. Definitions. + + 1.0.1. "Commercial Use" means distribution or otherwise making the + Covered Code available to a third party. + + 1.1. "Contributor" means each entity that creates or contributes to + the creation of Modifications. + + 1.2. "Contributor Version" means the combination of the Original + Code, prior Modifications used by a Contributor, and the Modifications + made by that particular Contributor. + + 1.3. "Covered Code" means the Original Code or Modifications or the + combination of the Original Code and Modifications, in each case + including portions thereof. + + 1.4. "Electronic Distribution Mechanism" means a mechanism generally + accepted in the software development community for the electronic + transfer of data. + + 1.5. "Executable" means Covered Code in any form other than Source + Code. + + 1.6. "Initial Developer" means the individual or entity identified + as the Initial Developer in the Source Code notice required by Exhibit + A. + + 1.7. "Larger Work" means a work which combines Covered Code or + portions thereof with code not governed by the terms of this License. + + 1.8. "License" means this document. + + 1.8.1. "Licensable" means having the right to grant, to the maximum + extent possible, whether at the time of the initial grant or + subsequently acquired, any and all of the rights conveyed herein. + + 1.9. "Modifications" means any addition to or deletion from the + substance or structure of either the Original Code or any previous + Modifications. When Covered Code is released as a series of files, a + Modification is: + A. Any addition to or deletion from the contents of a file + containing Original Code or previous Modifications. + + B. Any new file that contains any part of the Original Code or + previous Modifications. + + 1.10. "Original Code" means Source Code of computer software code + which is described in the Source Code notice required by Exhibit A as + Original Code, and which, at the time of its release under this + License is not already Covered Code governed by this License. + + 1.10.1. "Patent Claims" means any patent claim(s), now owned or + hereafter acquired, including without limitation, method, process, + and apparatus claims, in any patent Licensable by grantor. + + 1.11. "Source Code" means the preferred form of the Covered Code for + making modifications to it, including all modules it contains, plus + any associated interface definition files, scripts used to control + compilation and installation of an Executable, or source code + differential comparisons against either the Original Code or another + well known, available Covered Code of the Contributor's choice. The + Source Code can be in a compressed or archival form, provided the + appropriate decompression or de-archiving software is widely available + for no charge. + + 1.12. "You" (or "Your") means an individual or a legal entity + exercising rights under, and complying with all of the terms of, this + License or a future version of this License issued under Section 6.1. + For legal entities, "You" includes any entity which controls, is + controlled by, or is under common control with You. For purposes of + this definition, "control" means (a) the power, direct or indirect, + to cause the direction or management of such entity, whether by + contract or otherwise, or (b) ownership of more than fifty percent + (50%) of the outstanding shares or beneficial ownership of such + entity. + +2. Source Code License. + + 2.1. The Initial Developer Grant. + The Initial Developer hereby grants You a world-wide, royalty-free, + non-exclusive license, subject to third party intellectual property + claims: + (a) under intellectual property rights (other than patent or + trademark) Licensable by Initial Developer to use, reproduce, + modify, display, perform, sublicense and distribute the Original + Code (or portions thereof) with or without Modifications, and/or + as part of a Larger Work; and + + (b) under Patents Claims infringed by the making, using or + selling of Original Code, to make, have made, use, practice, + sell, and offer for sale, and/or otherwise dispose of the + Original Code (or portions thereof). + + (c) the licenses granted in this Section 2.1(a) and (b) are + effective on the date Initial Developer first distributes + Original Code under the terms of this License. + + (d) Notwithstanding Section 2.1(b) above, no patent license is + granted: 1) for code that You delete from the Original Code; 2) + separate from the Original Code; or 3) for infringements caused + by: i) the modification of the Original Code or ii) the + combination of the Original Code with other software or devices. + + 2.2. Contributor Grant. + Subject to third party intellectual property claims, each Contributor + hereby grants You a world-wide, royalty-free, non-exclusive license + + (a) under intellectual property rights (other than patent or + trademark) Licensable by Contributor, to use, reproduce, modify, + display, perform, sublicense and distribute the Modifications + created by such Contributor (or portions thereof) either on an + unmodified basis, with other Modifications, as Covered Code + and/or as part of a Larger Work; and + + (b) under Patent Claims infringed by the making, using, or + selling of Modifications made by that Contributor either alone + and/or in combination with its Contributor Version (or portions + of such combination), to make, use, sell, offer for sale, have + made, and/or otherwise dispose of: 1) Modifications made by that + Contributor (or portions thereof); and 2) the combination of + Modifications made by that Contributor with its Contributor + Version (or portions of such combination). + + (c) the licenses granted in Sections 2.2(a) and 2.2(b) are + effective on the date Contributor first makes Commercial Use of + the Covered Code. + + (d) Notwithstanding Section 2.2(b) above, no patent license is + granted: 1) for any code that Contributor has deleted from the + Contributor Version; 2) separate from the Contributor Version; + 3) for infringements caused by: i) third party modifications of + Contributor Version or ii) the combination of Modifications made + by that Contributor with other software (except as part of the + Contributor Version) or other devices; or 4) under Patent Claims + infringed by Covered Code in the absence of Modifications made by + that Contributor. + +3. Distribution Obligations. + + 3.1. Application of License. + The Modifications which You create or to which You contribute are + governed by the terms of this License, including without limitation + Section 2.2. The Source Code version of Covered Code may be + distributed only under the terms of this License or a future version + of this License released under Section 6.1, and You must include a + copy of this License with every copy of the Source Code You + distribute. You may not offer or impose any terms on any Source Code + version that alters or restricts the applicable version of this + License or the recipients' rights hereunder. However, You may include + an additional document offering the additional rights described in + Section 3.5. + + 3.2. Availability of Source Code. + Any Modification which You create or to which You contribute must be + made available in Source Code form under the terms of this License + either on the same media as an Executable version or via an accepted + Electronic Distribution Mechanism to anyone to whom you made an + Executable version available; and if made available via Electronic + Distribution Mechanism, must remain available for at least twelve (12) + months after the date it initially became available, or at least six + (6) months after a subsequent version of that particular Modification + has been made available to such recipients. You are responsible for + ensuring that the Source Code version remains available even if the + Electronic Distribution Mechanism is maintained by a third party. + + 3.3. Description of Modifications. + You must cause all Covered Code to which You contribute to contain a + file documenting the changes You made to create that Covered Code and + the date of any change. You must include a prominent statement that + the Modification is derived, directly or indirectly, from Original + Code provided by the Initial Developer and including the name of the + Initial Developer in (a) the Source Code, and (b) in any notice in an + Executable version or related documentation in which You describe the + origin or ownership of the Covered Code. + + 3.4. Intellectual Property Matters + (a) Third Party Claims. + If Contributor has knowledge that a license under a third party's + intellectual property rights is required to exercise the rights + granted by such Contributor under Sections 2.1 or 2.2, + Contributor must include a text file with the Source Code + distribution titled "LEGAL" which describes the claim and the + party making the claim in sufficient detail that a recipient will + know whom to contact. If Contributor obtains such knowledge after + the Modification is made available as described in Section 3.2, + Contributor shall promptly modify the LEGAL file in all copies + Contributor makes available thereafter and shall take other steps + (such as notifying appropriate mailing lists or newsgroups) + reasonably calculated to inform those who received the Covered + Code that new knowledge has been obtained. + + (b) Contributor APIs. + If Contributor's Modifications include an application programming + interface and Contributor has knowledge of patent licenses which + are reasonably necessary to implement that API, Contributor must + also include this information in the LEGAL file. + + (c) Representations. + Contributor represents that, except as disclosed pursuant to + Section 3.4(a) above, Contributor believes that Contributor's + Modifications are Contributor's original creation(s) and/or + Contributor has sufficient rights to grant the rights conveyed by + this License. + + 3.5. Required Notices. + You must duplicate the notice in Exhibit A in each file of the Source + Code. If it is not possible to put such notice in a particular Source + Code file due to its structure, then You must include such notice in a + location (such as a relevant directory) where a user would be likely + to look for such a notice. If You created one or more Modification(s) + You may add your name as a Contributor to the notice described in + Exhibit A. You must also duplicate this License in any documentation + for the Source Code where You describe recipients' rights or ownership + rights relating to Covered Code. You may choose to offer, and to + charge a fee for, warranty, support, indemnity or liability + obligations to one or more recipients of Covered Code. However, You + may do so only on Your own behalf, and not on behalf of the Initial + Developer or any Contributor. You must make it absolutely clear than + any such warranty, support, indemnity or liability obligation is + offered by You alone, and You hereby agree to indemnify the Initial + Developer and every Contributor for any liability incurred by the + Initial Developer or such Contributor as a result of warranty, + support, indemnity or liability terms You offer. + + 3.6. Distribution of Executable Versions. + You may distribute Covered Code in Executable form only if the + requirements of Section 3.1-3.5 have been met for that Covered Code, + and if You include a notice stating that the Source Code version of + the Covered Code is available under the terms of this License, + including a description of how and where You have fulfilled the + obligations of Section 3.2. The notice must be conspicuously included + in any notice in an Executable version, related documentation or + collateral in which You describe recipients' rights relating to the + Covered Code. You may distribute the Executable version of Covered + Code or ownership rights under a license of Your choice, which may + contain terms different from this License, provided that You are in + compliance with the terms of this License and that the license for the + Executable version does not attempt to limit or alter the recipient's + rights in the Source Code version from the rights set forth in this + License. If You distribute the Executable version under a different + license You must make it absolutely clear that any terms which differ + from this License are offered by You alone, not by the Initial + Developer or any Contributor. You hereby agree to indemnify the + Initial Developer and every Contributor for any liability incurred by + the Initial Developer or such Contributor as a result of any such + terms You offer. + + 3.7. Larger Works. + You may create a Larger Work by combining Covered Code with other code + not governed by the terms of this License and distribute the Larger + Work as a single product. In such a case, You must make sure the + requirements of this License are fulfilled for the Covered Code. + +4. Inability to Comply Due to Statute or Regulation. + + If it is impossible for You to comply with any of the terms of this + License with respect to some or all of the Covered Code due to + statute, judicial order, or regulation then You must: (a) comply with + the terms of this License to the maximum extent possible; and (b) + describe the limitations and the code they affect. Such description + must be included in the LEGAL file described in Section 3.4 and must + be included with all distributions of the Source Code. Except to the + extent prohibited by statute or regulation, such description must be + sufficiently detailed for a recipient of ordinary skill to be able to + understand it. + +5. Application of this License. + + This License applies to code to which the Initial Developer has + attached the notice in Exhibit A and to related Covered Code. + +6. Versions of the License. + + 6.1. New Versions. + Netscape Communications Corporation ("Netscape") may publish revised + and/or new versions of the License from time to time. Each version + will be given a distinguishing version number. + + 6.2. Effect of New Versions. + Once Covered Code has been published under a particular version of the + License, You may always continue to use it under the terms of that + version. You may also choose to use such Covered Code under the terms + of any subsequent version of the License published by Netscape. No one + other than Netscape has the right to modify the terms applicable to + Covered Code created under this License. + + 6.3. Derivative Works. + If You create or use a modified version of this License (which you may + only do in order to apply it to code which is not already Covered Code + governed by this License), You must (a) rename Your license so that + the phrases "Mozilla", "MOZILLAPL", "MOZPL", "Netscape", + "MPL", "NPL" or any confusingly similar phrase do not appear in your + license (except to note that your license differs from this License) + and (b) otherwise make it clear that Your version of the license + contains terms which differ from the Mozilla Public License and + Netscape Public License. (Filling in the name of the Initial + Developer, Original Code or Contributor in the notice described in + Exhibit A shall not of themselves be deemed to be modifications of + this License.) + +7. DISCLAIMER OF WARRANTY. + + COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF + DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. + THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE + IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, + YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE + COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER + OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF + ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER. + +8. TERMINATION. + + 8.1. This License and the rights granted hereunder will terminate + automatically if You fail to comply with terms herein and fail to cure + such breach within 30 days of becoming aware of the breach. All + sublicenses to the Covered Code which are properly granted shall + survive any termination of this License. Provisions which, by their + nature, must remain in effect beyond the termination of this License + shall survive. + + 8.2. If You initiate litigation by asserting a patent infringement + claim (excluding declatory judgment actions) against Initial Developer + or a Contributor (the Initial Developer or Contributor against whom + You file such action is referred to as "Participant") alleging that: + + (a) such Participant's Contributor Version directly or indirectly + infringes any patent, then any and all rights granted by such + Participant to You under Sections 2.1 and/or 2.2 of this License + shall, upon 60 days notice from Participant terminate prospectively, + unless if within 60 days after receipt of notice You either: (i) + agree in writing to pay Participant a mutually agreeable reasonable + royalty for Your past and future use of Modifications made by such + Participant, or (ii) withdraw Your litigation claim with respect to + the Contributor Version against such Participant. If within 60 days + of notice, a reasonable royalty and payment arrangement are not + mutually agreed upon in writing by the parties or the litigation claim + is not withdrawn, the rights granted by Participant to You under + Sections 2.1 and/or 2.2 automatically terminate at the expiration of + the 60 day notice period specified above. + + (b) any software, hardware, or device, other than such Participant's + Contributor Version, directly or indirectly infringes any patent, then + any rights granted to You by such Participant under Sections 2.1(b) + and 2.2(b) are revoked effective as of the date You first made, used, + sold, distributed, or had made, Modifications made by that + Participant. + + 8.3. If You assert a patent infringement claim against Participant + alleging that such Participant's Contributor Version directly or + indirectly infringes any patent where such claim is resolved (such as + by license or settlement) prior to the initiation of patent + infringement litigation, then the reasonable value of the licenses + granted by such Participant under Sections 2.1 or 2.2 shall be taken + into account in determining the amount or value of any payment or + license. + + 8.4. In the event of termination under Sections 8.1 or 8.2 above, + all end user license agreements (excluding distributors and resellers) + which have been validly granted by You or any distributor hereunder + prior to termination shall survive termination. + +9. LIMITATION OF LIABILITY. + + UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT + (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL + DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, + OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR + ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY + CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, + WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER + COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN + INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF + LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY + RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW + PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE + EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO + THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU. + +10. U.S. GOVERNMENT END USERS. + + The Covered Code is a "commercial item," as that term is defined in + 48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer + software" and "commercial computer software documentation," as such + terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 + C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), + all U.S. Government End Users acquire Covered Code with only those + rights set forth herein. + +11. MISCELLANEOUS. + + This License represents the complete agreement concerning subject + matter hereof. If any provision of this License is held to be + unenforceable, such provision shall be reformed only to the extent + necessary to make it enforceable. This License shall be governed by + California law provisions (except to the extent applicable law, if + any, provides otherwise), excluding its conflict-of-law provisions. + With respect to disputes in which at least one party is a citizen of, + or an entity chartered or registered to do business in the United + States of America, any litigation relating to this License shall be + subject to the jurisdiction of the Federal Courts of the Northern + District of California, with venue lying in Santa Clara County, + California, with the losing party responsible for costs, including + without limitation, court costs and reasonable attorneys' fees and + expenses. The application of the United Nations Convention on + Contracts for the International Sale of Goods is expressly excluded. + Any law or regulation which provides that the language of a contract + shall be construed against the drafter shall not apply to this + License. + +12. RESPONSIBILITY FOR CLAIMS. + + As between Initial Developer and the Contributors, each party is + responsible for claims and damages arising, directly or indirectly, + out of its utilization of rights under this License and You agree to + work with Initial Developer and Contributors to distribute such + responsibility on an equitable basis. Nothing herein is intended or + shall be deemed to constitute any admission of liability. + +13. MULTIPLE-LICENSED CODE. + + Initial Developer may designate portions of the Covered Code as + "Multiple-Licensed". "Multiple-Licensed" means that the Initial + Developer permits you to utilize portions of the Covered Code under + Your choice of the NPL or the alternative licenses, if any, specified + by the Initial Developer in the file described in Exhibit A. + +EXHIBIT A -Mozilla Public License. + + ``The contents of this file are subject to the Mozilla Public License + Version 1.1 (the "License"); you may not use this file except in + compliance with the License. You may obtain a copy of the License at + http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS IS" + basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the + License for the specific language governing rights and limitations + under the License. + + The Original Code is ______________________________________. + + The Initial Developer of the Original Code is ________________________. + Portions created by ______________________ are Copyright (C) ______ + _______________________. All Rights Reserved. + + Contributor(s): ______________________________________. + + Alternatively, the contents of this file may be used under the terms + of the _____ license (the "[___] License"), in which case the + provisions of [______] License are applicable instead of those + above. If you wish to allow use of your version of this file only + under the terms of the [____] License and not to allow others to use + your version of this file under the MPL, indicate your decision by + deleting the provisions above and replace them with the notice and + other provisions required by the [___] License. If you do not delete + the provisions above, a recipient may use your version of this file + under either the MPL or the [___] License." + + [NOTE: The text of this Exhibit A may differ slightly from the text of + the notices in the Source Code files of the Original Code. You should + use the text of this Exhibit A rather than the text found in the + Original Code Source Code for Your Modifications.] + diff --git a/tests/fptest/README.adoc b/tests/fptest/README.adoc new file mode 100644 index 00000000..1977e0cb --- /dev/null +++ b/tests/fptest/README.adoc @@ -0,0 +1,70 @@ +Welcome to Free Pascal Testing Framework (FPTest) +================================================= + +This is a fork of the DUnit2 project and further adapted for use +with the Free Pascal Compiler and fpGUI Toolkit. The original code was +created by the late Peter McNab. He single-handedly added some excellent +features to DUnit2 and used the extensive test suite from tiOPF as his +playground. + +FPTest has a Text Test Runner and a GUI Test Runner (fpGUI Toolkit and +Lazarus Component Library versions). + + +Support +------- +Support can be found in the form of a newsgroup (NNTP Server) at: + + Server: geldenhuys.co.uk + Port: 119 + +Those that can't use NNTP news client software for some reason, can +also access the support newsgroup via a web browser using the following +URL: + + http://geldenhuys.co.uk/webnews/ + + +Summary +------- +Unit tests comprise of classes derived from TTestCase, each containing one +or more published test procedures as shown in the example below. TTestCase +is now an interfaced object. + +[code,pascal] +---- +type + TTestMyComms = class(TTestCase) + published + procedure VerifyThatThereIsAnUnAssignedCommPort; + procedure VerifyThatTheCommPortOpens; + procedure VerifyThatTheCommPortCloses; + end; +---- + +Through the magic of RTTI, FPTest is able to execute the published test +procedures in an orderly fashion. Code written into test methods +performs tests on user's code, and calls one or more Check() procedures +to signal pass or fail to the test framework. + +For more information about FPTest, have a look at the various documents +in the 'docs' directory. + + +Brief History +------------- +As of July 2009, I (Graeme Geldenhuys) decided to continue Peter's work +on DUnit2, but renamed the project to prevent confusion with the Delphi +based DUnit2 project hosted on SourceForge [which is a continuation of +Peter's work too]. I applied some of my own ideas listed below: + +* No need for Delphi.NET support. The product doesn't exist anymore + and .NET has its own testing framework anyway, called NUnit. +* Must work with the Free Pascal Compiler (FPC). +* Don't need Delphi support, because FPC is an excellent compiler. +* With FPC support comes the idea that it must be cross-platform + friendly as well. +* Due to the previous item, removing the idea of writing to the Windows + Registry is a logical step. Using something like INI, XML, or JSON config + files will do a great job, are easy to edit, and works for all OSes. + diff --git a/tests/fptest/src/FPCUnitCompatibleInterface.inc b/tests/fptest/src/FPCUnitCompatibleInterface.inc new file mode 100644 index 00000000..1bb3812a --- /dev/null +++ b/tests/fptest/src/FPCUnitCompatibleInterface.inc @@ -0,0 +1,189 @@ +{%MainUnit TestFramework.pas} + +{$IFDEF read_interface} + + procedure AssertTrue(const AMessage: string; ACondition: boolean; AErrorAddrs: Pointer = nil); overload; + procedure AssertTrue(ACondition: boolean); overload; + procedure AssertFalse(const AMessage: string; ACondition: boolean; AErrorAddrs: Pointer = nil); overload; + procedure AssertFalse(ACondition: boolean); overload; + procedure AssertEquals(const AMessage: string; Expected, Actual: string); overload; + procedure AssertEquals(Expected, Actual: string); overload; + {$IFDEF UNICODE} + //procedure AssertEquals(const AMessage: string; Expected, Actual: UnicodeString); overload; + //procedure AssertEquals(Expected, Actual: UnicodeString); overload; + {$ENDIF} + procedure AssertEquals(const AMessage: string; Expected, Actual: integer); overload; + procedure AssertEquals(Expected, Actual: integer); overload; + procedure AssertEquals(const AMessage: string; Expected, Actual: int64); overload; + procedure AssertEquals(Expected, Actual: int64); overload; + procedure AssertEquals(const AMessage: string; Expected, Actual: currency); overload; + procedure AssertEquals(Expected, Actual: currency); overload; + procedure AssertEquals(const AMessage: string; Expected, Actual, Delta: double); overload; + procedure AssertEquals(Expected, Actual, Delta: double); overload; + procedure AssertEquals(const AMessage: string; Expected, Actual: boolean); overload; + procedure AssertEquals(Expected, Actual: boolean); overload; + //procedure AssertEquals(const AMessage: string; Expected, Actual: char); overload; + //procedure AssertEquals(Expected, Actual: char); overload; + procedure AssertEquals(const AMessage: string; Expected, Actual: TClass); overload; + procedure AssertEquals(Expected, Actual: TClass); overload; + procedure AssertSame(const AMessage: string; Expected, Actual: TObject); overload; + //procedure AssertSame(Expected, Actual: TObject); overload; + //procedure AssertSame(const AMessage: string; Expected, Actual: Pointer); overload; + //procedure AssertSame(Expected, Actual: Pointer); overload; + //procedure AssertNotSame(const AMessage: string; Expected, Actual: TObject); overload; + //procedure AssertNotSame(Expected, Actual: TObject); overload; + //procedure AssertNotSame(const AMessage: string; Expected, Actual: Pointer); overload; + //procedure AssertNotSame(Expected, Actual: Pointer); overload; + procedure AssertNotNull(const AMessage: string; AObject: TObject); overload; + procedure AssertNotNull(AObject: TObject); overload; + //procedure AssertNotNullIntf(const AMessage: string; AInterface: IInterface); overload; + //procedure AssertNotNullIntf(AInterface: IInterface); overload; + //procedure AssertNotNull(const AMessage: string; APointer: Pointer); overload; + //procedure AssertNotNull(APointer: Pointer); overload; + procedure AssertNull(const AMessage: string; AObject: TObject); overload; + //procedure AssertNull(AObject: TObject); overload; + //procedure AssertNullIntf(const AMessage: string; AInterface: IInterface); overload; + //procedure AssertNullIntf(AInterface: IInterface); overload; + //procedure AssertNull(const AMessage: string; APointer: Pointer); overload; + //procedure AssertNull(APointer: Pointer); overload; + //procedure AssertNotNull(const AMessage, AString: string); overload; + //procedure AssertNotNull(const AString: string); overload; + procedure AssertException(const AMessage: string; AExceptionClass: ExceptClass; AMethod: TExceptTestMethod; AExceptionMessage : String = ''; AExceptionContext : Integer = 0; AErrorAddr : Pointer = Nil); overload; + //procedure AssertException(AExceptionClass: ExceptClass; AMethod: TRunMethod;AExceptionMessage : String = ''; AExceptionContext : Integer = 0); overload; + +{$ENDIF read_interface} + + +{$IFDEF read_implementation} + +procedure TTestProc.AssertTrue(const AMessage: string; ACondition: boolean; AErrorAddrs: Pointer); +begin + OnCheckCalled; + if (not ACondition) then + FailNotEquals(BoolToStr(true, true), BoolToStr(false, true), AMessage, CallerAddr); +end; + +procedure TTestProc.AssertTrue(ACondition: boolean); +begin + CheckTrue(ACondition); +end; + +procedure TTestProc.AssertFalse(const AMessage: string; ACondition: boolean; AErrorAddrs: Pointer); +begin + CheckFalse(ACondition, AMessage); +end; + +procedure TTestProc.AssertFalse(ACondition: boolean); +begin + CheckFalse(ACondition); +end; + +procedure TTestProc.AssertEquals(const AMessage: string; Expected, Actual: string); overload; +begin + OnCheckCalled; + if expected <> actual then + FailNotEquals(expected, actual, AMessage, CallerAddr); +end; + +procedure TTestProc.AssertEquals(Expected, Actual: string); overload; +begin + OnCheckCalled; + if expected <> actual then + FailNotEquals(expected, actual, '', CallerAddr); +end; + +procedure TTestProc.AssertEquals(const AMessage: string; Expected, Actual: integer); +begin + OnCheckCalled; + if (expected <> actual) then + FailNotEquals(IntToStr(expected), IntToStr(actual), AMessage, CallerAddr); +end; + +procedure TTestProc.AssertEquals(Expected, Actual: integer); +begin + CheckEquals(Expected, Actual); +end; + +procedure TTestProc.AssertEquals(const AMessage: string; Expected, Actual: int64); +begin + CheckEquals(Expected, Actual, AMessage); +end; + +procedure TTestProc.AssertEquals(Expected, Actual: int64); +begin + CheckEquals(Expected, Actual); +end; + +procedure TTestProc.AssertEquals(const AMessage: string; Expected, Actual: currency); +begin + OnCheckCalled; + if (abs(expected-actual) > 0) then + FailNotEquals(FloatToStr(expected), FloatToStr(actual), AMessage, CallerAddr); +end; + +procedure TTestProc.AssertEquals(Expected, Actual: currency); +begin + OnCheckCalled; + if (abs(expected-actual) > 0) then + FailNotEquals(FloatToStr(expected), FloatToStr(actual), '', CallerAddr); +end; + +procedure TTestProc.AssertEquals(const AMessage: string; Expected, Actual, Delta: double); +begin + CheckEquals(Expected, Actual, Delta, AMessage); +end; + +procedure TTestProc.AssertEquals(Expected, Actual, Delta: double); +begin + CheckEquals(Expected, Actual, Delta); +end; + +procedure TTestProc.AssertEquals(const AMessage: string; Expected, Actual: boolean); +begin + CheckEquals(Expected, Actual, AMessage); +end; + +procedure TTestProc.AssertEquals(Expected, Actual: boolean); +begin + CheckEquals(Expected, Actual); +end; + +procedure TTestProc.AssertEquals(const AMessage: string; Expected, Actual: TClass); +begin + CheckEquals(Expected, Actual, AMessage); +end; + +procedure TTestProc.AssertEquals(Expected, Actual: TClass); +begin + CheckEquals(Expected, Actual); +end; + +procedure TTestProc.AssertSame(const AMessage: string; Expected, Actual: TObject); +begin + CheckSame(Expected, Actual, AMessage); +end; + +procedure TTestProc.AssertNotNull(const AMessage: string; AObject: TObject); +begin + CheckNotNull(AObject, AMessage); +end; + +procedure TTestProc.AssertNotNull(AObject: TObject); +begin + CheckNotNull(AObject); +end; + +procedure TTestProc.AssertNull(const AMessage: string; AObject: TObject); +begin + CheckNull(AObject, AMessage); +end; + +procedure TTestProc.AssertException(const AMessage: string; AExceptionClass: ExceptClass; AMethod: TExceptTestMethod; + AExceptionMessage: String; AExceptionContext: Integer; AErrorAddr: Pointer); +begin + CheckException(AMethod, AExceptionClass, AExceptionMessage); +end; + + +{$ENDIF read_implementation} + diff --git a/tests/fptest/src/ProjectsManager.pas b/tests/fptest/src/ProjectsManager.pas new file mode 100644 index 00000000..59f268e7 --- /dev/null +++ b/tests/fptest/src/ProjectsManager.pas @@ -0,0 +1,549 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is DUnit. + + The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + and Juancarlo Añez. + Portions created The Initial Developers are Copyright (C) 1999-2000. + Portions created by The DUnit Group are Copyright (C) 2000-2007. + All rights reserved. + + Contributor(s): + Kent Beck + Erich Gamma + Juanco Añez + Chris Morris + Jeff Moore + Uberto Barbini + Brett Shearer + Kris Golko + The DUnit group at SourceForge + Peter McNab + Graeme Geldenhuys +} + +unit ProjectsManager; + +{$IFDEF FPC} + {$mode delphi}{$H+} +{$ENDIF} + +interface +uses + Classes, + ProjectsManagerIface, + TestFrameworkIfaces, + TestListenerIface, + IniFiles + {$IFNDEF UNIX} + ,Registry + {$ENDIF} + ; + +{ TODO : Remove Registry support - we want clean INI support only } + +type + {$M+} + TProjectManager = class(TInterfacedObject, IProjectManager) + private + FMultiProjectSuite: ITestProject; + FProjectList: IInterfaceList; + FExeName: string; + function SectionName(const AProject: ITestProject): string; + protected + function get_Project(const idx: Integer): ITestProject; + procedure set_Project(const idx: Integer; const AProject: ITestProject); + function get_Projects: ITestProject; + procedure set_Projects(const Value: ITestProject); + function get_Count: Integer; + function FindProjectID(const AName: string): Integer; + procedure SaveConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); virtual; + procedure LoadConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); virtual; + procedure AddListener(const Listener: ITestListenerProxy); overload; + procedure AddListener(const ProjectID: Integer; const Listener: ITestListenerProxy); overload; + procedure RemoveListener(const Listener: ITestListenerProxy); overload; + procedure RemoveListener(const ProjectID: Integer; const Listener: ITestListenerProxy); overload; + procedure ReleaseProject(const AProject: ITestProject); + procedure ReleaseProjects; + function AddProject(const AProject: ITestProject): Integer; + public + constructor Create; virtual; + destructor Destroy; override; + property Project[const index: Integer]: ITestProject read get_Project write set_Project; + published + property Projects: ITestProject read get_Projects write set_Projects; + property Count: Integer read get_Count; + end; + {$M-} + +implementation + +uses + SysUtils, + TestFramework; + +{$IFNDEF UNIX} +var + // SubKey of HKEY_CURRENT_USER for storing configurations in the registry (end with \) + DUnitRegistryKey: string = ''; // How about 'Software\DUnitTests\'; +{$ENDIF} + +type + TMemIniFileTrimmed = class(TMemIniFile) + public + // Override the read string method to trim the string for compatibility with TIniFile + function ReadString(const Section, Ident, DefaultStr: string): string; override; + end; + +function TMemIniFileTrimmed.ReadString(const Section, Ident, + DefaultStr: string): string; +begin + // Trim the result for compatibility with TIniFile + Result := Trim(inherited ReadString(Section, Ident, DefaultStr)); +end; + + +type + IProjectIterator = interface(ITestIterator) + ['{E1D98B08-C97B-42D0-8952-E74CA7F8C73B}'] + function Exists(const AProject: ITestProject): boolean; + end; + + + TProjectIterator = class(TTestIterator, IProjectIterator) + protected + function Exists(const AProject: ITestProject): boolean; + end; + + + TMultiProjectSuite = class(TTestProject) + private + FForceFindFirstTest: boolean; + protected + function FindFirstTest: ITest; override; + function FindNextTest: ITest; override; + function ExecutionControl: ITestExecControl; override; + procedure SaveConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); reintroduce; overload; + procedure LoadConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); reintroduce; overload; + end; + + + +function TProjectIterator.Exists(const AProject: ITestProject): boolean; +begin + Result := FIList.IndexOf(AProject) >= 0; +end; + + +{ TProjectManager } + +constructor TProjectManager.Create; +begin + inherited Create; + FExeName := ExtractFileName(ParamStr(0)); + FProjectList := TInterfaceList.Create; +end; + +destructor TProjectManager.Destroy; +begin + ReleaseProjects; + FProjectList := nil; + inherited; +end; + +procedure TProjectManager.ReleaseProject(const AProject: ITestProject); +var + LEntry: Integer; +begin + if AProject = nil then + Exit; + + if FProjectList.Count > 0 then + begin + LEntry := FProjectList.IndexOf(AProject); + if LEntry >= 0 then + FProjectList.Items[LEntry] := nil; + end; +end; + +procedure TProjectManager.ReleaseProjects; +begin + if Assigned(FProjectList) then + // Prevent crash during shutdown if interfaced object instances in DLLs + // have already been unloaded. + // Note. I'm not convinced this was the real cause, yet! + try + FProjectList.Clear; + except + end; + FProjectList := nil; + FMultiProjectSuite := nil; +end; + +function TProjectManager.get_Count: Integer; +begin + Result := FProjectList.Count; +end; + +function TProjectManager.get_Project(const idx: Integer): ITestProject; +begin + Result := nil; + + if (idx >= 0) and (idx < Count) and + Assigned(FProjectList.Items[idx]) then + Result := (FProjectList.Items[idx] as ITestProject); +end; + +procedure TProjectManager.set_Project(const idx: Integer; const AProject: ITestProject); +begin + if Assigned(AProject) then + begin + if (idx >= 0) then + begin + AProject.Manager := Self as IInterface; + if (idx < Count) then + begin + AProject.ProjectID := idx; + FProjectList.Items[idx] := AProject as IInterface; + end + else + begin + FProjectList.Add(AProject); + AProject.ProjectID := FProjectList.Count; + end; + end; + end; +end; + +function TProjectManager.FindProjectID(const AName: string): Integer; +var + LName: string; + LCount: Integer; +begin + Result := -1; + LName := Trim(AName); + Assert(Pos(',', LName) = 0, 'Project names must not contain a delimiter'); + + for LCount := 0 to FProjectList.Count-1 do + begin + if (FProjectList.Items[LCount] as ITestProject).DisplayedName = LName then + begin + Result := LCount; + Exit; + end + end; + + if ((Result = -1) and (LName = '')) then + begin + Result := FindProjectID(DefaultProject); + if (Result = -1) then + Result := FindProjectID(FExeName); + end; +end; + +// FMultiProjectSuite is nil if there is only one project registered. +// This reduces the layers presented to the user interface. +// When a second project is registered then FMultiProjectSuite is created. +// The second and subsequent projects is still added to the project manager's list. +// The change being introduced here is on creation the fist project and second +// projects are added to FMultiProjectSuite test iterator so inherited +// behaviour of ITestProject can be utilised. +// It may be possible in a second refactoring to change the project manager's +// list to a single entry which gets nil-ed early rather than later to help +// with memory management. + +function TProjectManager.AddProject(const AProject: ITestProject): Integer; +var + idx: Integer; + LProject: ITestProject; + + function AsProject(const NewTests: ITestProject): ITestProject; + begin + if Supports(NewTests, ITestProject) then + Result := NewTests + else + begin // We need the registered instances to be projects not TestSuites. + Result := TTestProject.Create(DefaultProject); + Result.AddTest(NewTests); + end + end; + + function AddToProjectList: Integer; + begin + FProjectList.Add(LProject); + Result := FProjectList.Count -1; + LProject.ProjectID := Result; + end; + + +begin // TProjectManager.AddProject(const AProject: ITestProject): Integer; + Result := -1; + if Assigned(AProject) then + LProject := AsProject(AProject) + else + Exit; + + if (FProjectList.Count = 0) then // Then no projects added yet. + begin + Result := AddToProjectList; + if AProject.DisplayedName = DefaultProject then + LProject.DisplayedName := FExeName; + Exit; + end; + + // See if a project with the same name already exists. + Result := FindProjectID(LProject.DisplayedName); + + if Result = -1 then // This is not the first project and it isn't already registered + begin + Result := AddToProjectList; + if not Assigned( FMultiProjectSuite) and (Result > 0) then + begin // Introduce the project holding object so all projects can be run + FMultiProjectSuite := TMultiProjectSuite.Create; + FMultiProjectSuite.DisplayedName := FExeName; + + // Copy the first project into MultiProjectSuite's Iterator + FMultiProjectSuite.AddTest((FProjectList.Items[0] as ITestProject)); + end; + end + else + if Result = 0 then //i.e. we are adding to an existing pr + begin + raise Exception.Create('Project exists'); + end; + + if (Result > 0) then + begin + // If there are multiple projects and a default unnamed project exists, (i.e. it's been given ExeName) + // then rename it back from ExeName to DefaultProject + for idx := 0 to FProjectList.Count - 1 do + if (FProjectList.Items[idx] as ITestProject).DisplayedName = FExeName then + begin + (FProjectList.Items[idx] as ITestProject).DisplayedName := DefaultProject; + (FProjectList.Items[idx] as ITestProject).ParentPath := FExeName; + end; + + // Add the new project to MultiProjectSuite's Iterator and set it's ParentPath + FMultiProjectSuite.AddTest(LProject); + end; +end; + +procedure TProjectManager.AddListener(const ProjectID: Integer; + const Listener: ITestListenerProxy); +begin + if (ProjectID >= 0) and (ProjectID < FProjectList.Count) then + if Assigned(Project[ProjectID]) then + Project[ProjectID].Listener := Listener as IInterface; +end; + +procedure TProjectManager.AddListener(const Listener: ITestListenerProxy); +var + idx: Integer; +begin + if (TestProject = nil) then + Exit; + + for idx := 0 to Count -1 do + if Assigned(Project[idx]) then + Project[idx].Listener := Listener as IInterface; +end; + +procedure TProjectManager.RemoveListener(const ProjectID: Integer; + const Listener: ITestListenerProxy); +begin + if (ProjectID >= 0) and (ProjectID <= Count) then + Project[ProjectID].Listener := Listener as IInterface; +end; + +procedure TProjectManager.RemoveListener(const Listener: ITestListenerProxy); +var + idx: Integer; +begin + if (TestProject = nil) then + Exit; + + for idx := 0 to Count -1 do + if Assigned(Project[idx]) then + Project[idx].Listener := Listener as IInterface; +end; + +function TProjectManager.SectionName(const AProject: ITestProject): string; +begin + if (not Assigned(AProject)) or (AProject.ParentPath = '') then + Result := 'Test' + else + Result := 'Test.' + AProject.ParentPath; +end; + +procedure TProjectManager.SaveConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); +var + f: TCustomIniFile; + LProject: ITestProject; + LFileName: string; + LFinalPathFileName: string; +begin + if FileName = '' then + LFileName := ExtractFileName(FExeName) + else + LFileName := ExtractFileName(FileName); + + { TODO -cregistry : Remove windows registry references } + LFinalPathFileName := {LocalAppDataPath +} LFileName; +{$IFNDEF UNIX} + if useRegistry then + f := TRegistryIniFile.Create(DUnitRegistryKey + LFileName) + else +{$ENDIF} + if useMemIni then + f := TMemIniFileTrimmed.Create(LFinalPathFileName) + else + f := TIniFile.Create(LFinalPathFileName); + try + LProject := Projects; + if not assigned(LProject) then + LProject := TestProject; + if assigned(LProject) then + LProject.SaveConfiguration(f, SectionName(LProject)); + f.UpdateFile; + finally + f.free + end +end; + +procedure TProjectManager.LoadConfiguration(const FileName: string; + const useRegistry, useMemIni: Boolean); +var + f: TCustomIniFile; + LProject: ITestProject; + LFileName: string; + LFinalPathFileName: string; +begin + if FileName = '' then + LFileName := ExtractFileName(FExeName) + else + LFileName := ExtractFileName(FileName); + + { TODO -cregistry : Remove windows registry references } + LFinalPathFileName := {LocalAppDataPath +} LFileName; +{$IFNDEF UNIX} + if useRegistry then + f := TRegistryIniFile.Create(DUnitRegistryKey + FileName) + else +{$ENDIF} + if useMemIni then + f := TMemIniFileTrimmed.Create(LFinalPathFileName) + else + f := TIniFile.Create(LFinalPathFileName); + + try + LProject := Projects; + if not assigned(LProject) then + LProject := TestProject; + if Assigned(LProject) then + begin + LProject.LoadConfiguration(f, SectionName(LProject)); + try + LProject.FailsOnNoChecksExecuted := f.ReadBool(cnRunners, + 'FailOnNoChecksExecuted', LProject.FailsOnNoChecksExecuted); + LProject.InhibitSummaryLevelChecks := f.ReadBool(cnRunners, + 'InhibitSummaryLevelChecks', LProject.InhibitSummaryLevelChecks); + {$IFDEF FASTMM} + LProject.FailsOnMemoryLeak := f.ReadBool(cnRunners, + 'FailOnMemoryLeaked', LProject.FailsOnMemoryLeak); + LProject.IgnoresMemoryLeakInSetUpTearDown := f.ReadBool(cnRunners, + 'IgnoreSetUpTearDownLeaks', LProject.IgnoresMemoryLeakInSetUpTearDown); + {$ENDIF} + except + end; + end; + finally + f.free + end +end; + +function TProjectManager.get_Projects: ITestProject; +begin + Result := FMultiProjectSuite; +end; + +procedure TProjectManager.set_Projects(const Value: ITestProject); +begin + FMultiProjectSuite := Value; +end; + + +{ TMultiProjectSuite } + +function TMultiProjectSuite.FindFirstTest: ITest; +begin + Result := FTestIterator.FindFirstTest; + FForceFindFirstTest := False; +end; + +function TMultiProjectSuite.FindNextTest: ITest; +var + LProject: ITestProject; +begin + Result := nil; + LProject := FTestIterator.PriorTest as ITestProject; + LProject := FTestIterator.FindNextTest as ITestProject; + if Assigned(LProject) then + begin + if FForceFindFirstTest then + begin + Result := LProject.FindFirstTest; + FForceFindFirstTest := False; + end + else + Result := LProject.FindNextTest; + + if not Assigned(Result) then + begin + Result := FTestIterator.FindNextTest as ITestProject; + FForceFindFirstTest := True; + end; + end; +end; + +function TMultiProjectSuite.ExecutionControl: ITestExecControl; +var + LProjectManager: IProjectManager; +begin + if (FExecControl = nil) then + begin + LProjectManager := Manager as IProjectManager; + FExecControl := LProjectManager.Project[0].ExecutionControl; + end; + Result := FExecControl; +end; + +procedure TMultiProjectSuite.LoadConfiguration(const FileName: string; + const useRegistry, useMemIni: Boolean); +var + LProjectManager: IProjectManager; +begin + LProjectManager := Manager as IProjectManager; + LProjectManager.LoadConfiguration(FileName, useRegistry, useMemIni); +end; + +procedure TMultiProjectSuite.SaveConfiguration(const FileName: string; + const useRegistry, useMemIni: Boolean); +var + LProjectManager: IProjectManager; +begin + LProjectManager := Manager as IProjectManager; + LProjectManager.SaveConfiguration(FileName, useRegistry, useMemIni); +end; + +end. diff --git a/tests/fptest/src/ProjectsManagerIface.pas b/tests/fptest/src/ProjectsManagerIface.pas new file mode 100644 index 00000000..a60747f4 --- /dev/null +++ b/tests/fptest/src/ProjectsManagerIface.pas @@ -0,0 +1,78 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is DUnit. + + The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + and Juancarlo Añez. + Portions created The Initial Developers are Copyright (C) 1999-2000. + Portions created by The DUnit Group are Copyright (C) 2000-2007. + All rights reserved. + + Contributor(s): + Kent Beck + Erich Gamma + Juanco Añez + Chris Morris + Jeff Moore + Uberto Barbini + Brett Shearer + Kris Golko + The DUnit group at SourceForge + Peter McNab + Graeme Geldenhuys +} + +unit ProjectsManagerIface; + +{$IFDEF FPC} + {$mode delphi}{$H+} +{$ENDIF} + +interface + +uses + TestFrameworkIfaces, + TestListenerIface; + +const + DefaultProject = 'Default Project'; // Default project title; + +type + IProjectManager = interface + ['{B059F5CD-64C5-46F1-8E2F-4A9F9CFBB291}'] + + function get_Project(const idx: integer): ITestProject; + procedure set_Project(const idx: integer; const AProject: ITestProject); + property Project[const index: integer]: ITestProject read get_Project write set_Project; + function get_Projects: ITestProject; + procedure set_Projects(const Value: ITestProject); + property Projects: ITestProject read get_Projects write set_Projects; + function get_Count: integer; + property Count: integer read get_Count; + function FindProjectID(const AName: string): integer; + procedure SaveConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); + procedure LoadConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); + + procedure AddListener(const Listener: ITestListenerProxy); overload; + procedure RemoveListener(const ProjectID: integer; const Listener: ITestListenerProxy); overload; + procedure RemoveListener(const Listener: ITestListenerProxy); overload; + procedure AddListener(const ProjectID: integer; const Listener: ITestListenerProxy); overload; + procedure ReleaseProject(const AProject: ITestProject); + procedure ReleaseProjects; + function AddProject(const AProject: ITestProject): integer; + end; + +implementation + +end. diff --git a/tests/fptest/src/TestExtensions.pas b/tests/fptest/src/TestExtensions.pas new file mode 100644 index 00000000..701f36f3 --- /dev/null +++ b/tests/fptest/src/TestExtensions.pas @@ -0,0 +1,81 @@ +{ DUnit: An XTreme testing framework for Delphi programs. } +(* + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is DUnit. + * + * The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + * and Juancarlo Añez. + * Portions created The Initial Developers are Copyright (C) 1999-2000. + * Portions created by The DUnit Group are Copyright (C) 2000-2008. + * All rights reserved. + * + * Contributor(s): + * Kent Beck + * Erich Gamma + * Juanco Añez + * Chris Morris + * Jeff Moore + * Uberto Barbini + * Brett Shearer + * Kris Golko + * The DUnit group at SourceForge + * Peter McNab + * Graeme Geldenhuys + * + ******************************************************************************* +*) +unit TestExtensions; + +{$IFDEF FPC} + {$mode delphi}{$H+} + {$UNDEF FASTMM} +{$ELSE} + // If Delphi 7, turn off UNSAFE_* Warnings + {$IFNDEF VER130} + {$IFNDEF VER140} + {$WARN UNSAFE_CODE OFF} + {$WARN UNSAFE_CAST OFF} + {$ENDIF} + {$ENDIF} +{$ENDIF} + +interface + +uses + TestFrameworkIfaces, + TestFramework, + Classes; + +type + ITestSetup = interface(ITestDecorator) + ['{68B30444-F03D-4F57-A10D-DCC45381B126}'] + end; + + TTestSetup = class(TTestDecorator, ITestSetup) + protected + function GetName: string; override; + end; + + +implementation + +uses + SysUtils; + +{ TTestSetup } + +function TTestSetup.GetName: string; +begin + Result := Format('Setup decorator (%s)', [DisplayedName]); +end; + +end. diff --git a/tests/fptest/src/TestFramework.pas b/tests/fptest/src/TestFramework.pas new file mode 100644 index 00000000..a383d4b9 --- /dev/null +++ b/tests/fptest/src/TestFramework.pas @@ -0,0 +1,4149 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is DUnit. + + The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + and Juancarlo Añez. + Portions created The Initial Developers are Copyright (C) 1999-2000. + Portions created by The DUnit Group are Copyright (C) 2000-2007. + All rights reserved. + + Contributor(s): + Kent Beck + Erich Gamma + Juanco Añez + Chris Morris + Jeff Moore + Uberto Barbini + Brett Shearer + Kris Golko + The DUnit group at SourceForge + Peter McNab + Graeme Geldenhuys +} + +unit TestFramework; + +{$IFDEF FPC} + {$mode delphi}{$H+} +{$ELSE} + // If Delphi 7, turn off UNSAFE_* Warnings + {$IFNDEF VER130} + {$IFNDEF VER140} + {$WARN UNSAFE_CODE OFF} + {$WARN UNSAFE_CAST OFF} + {$ENDIF} + {$ENDIF} +{$ENDIF} + +// Comment out this define to remove FPCUnit test interface support +{$define fpcunit} + +interface + +uses + TestFrameworkIfaces, + Classes, + SysUtils, + IniFiles; + +{ This lets us use a single include file for both the Interface and + Implementation sections. } +{$define read_interface} +{$undef read_implementation} + +{ TODO -cregistry : Remove Registry support - we want clean INI support only } + +{$IFNDEF FPC} +const + LineEnding = #13#10; + AllFilesMask = '*.*'; +{$ENDIF} + +type + ETestFailure = class(EAbort) + constructor Create; overload; + constructor Create(const ErrorMsg :string); overload; + end; + + + EDUnitException = class(Exception); + ETestError = class(EDUnitException); + + + TReadOnlyIterator = class(TInterfacedObject, IReadOnlyIterator) + private + idx: Integer; + FCurrentTest: ITest; + function Count: Integer; + protected + FIList: IInterfaceList; + procedure Reset; + function FindFirstTest: ITest; + function FindNextTest: ITest; + function PriorTest: ITest; + function FindNextEnabledProc: ITest; + function CurrentTest: ITest; + public + constructor Create; virtual; + destructor Destroy; override; + end; + + + TTestIterator = class(TReadOnlyIterator, ITestIterator) + protected + //Adds entry and resets idx to 1st entry + procedure AddTest(const ATest: ITest); + end; + + + {$M+} + TTestProc = class(TInterfacedObject, ITest, ITestMethod, ITestCheck) + private + FUniqueID: Cardinal; + FProjectID: Integer; + FEnabled: boolean; + FExcluded: boolean; + FTestSetUpData: ITestSetUpData; + FMethodName: string; + FParent: Pointer; // Weak reference to ITestCase; + FIsTestMethod: boolean; + FSupportedIface: TSupportedIface; + FMethod: TTestMethod; + FExecStatus: TExecutionStatus; + FDepth: Integer; + FCheckCalled: boolean; + FElapsedTime: Extended; + FStartTime: Extended; + FStopTime: Extended; + FExceptionIs: ExceptClass; + FExpectedExcept: ExceptClass; + FErrorAddress: PtrType; + FErrorMessage: string; + FFailsOnNoChecksExecuted: boolean; + FStatusMsgs: TStrings; + FProxy: Pointer; // Weak reference to IInterface; + FParentPath: string; + FInhibitSummaryLevelChecks: Boolean; + FEarlyExit: Boolean; + FLeakAllowed: Boolean; + FAllowedLeakList: TAllowedLeakArray; + FAllowedLeakListIndex: Word; + FFailsOnMemoryLeak: boolean; + FIgnoresMemoryLeakInSetUpTearDown: boolean; + function CheckMethodCalledCheck(const ATest: ITest): TExecutionStatus; + function ElapsedTestTime: Extended; + function MethodCode(const MethodsName: string): TTestMethod; + procedure CheckMethodIsNotEmpty(const AMethod: TTestMethod); + procedure InitializeRunState; virtual; + function Run(const CurrentTestCase: ITestCase; + const AMethodName: string; + const ExecControl: ITestExecControl): TExecutionStatus; + function IsValidTestMethod(const AProc: TTestMethod): boolean; + protected + FDisplayedName: string; + FExecControl: ITestExecControl; + function UniqueID: Cardinal; + function get_ProjectID: Integer; + procedure set_ProjectID(const ID: Integer); + function MethodsName: string; + procedure RunTest; virtual; + function get_ParentTestCase: ITestCase; + procedure set_ParentTestCase(const TestCase: ITestCase); + procedure InstallExecutionControl(const Value: ITestExecControl); + function get_ExceptionClass: ExceptClass; + procedure set_ExceptionClass(const Value: ExceptClass); + function get_DisplayedName: string; virtual; + procedure set_DisplayedName(const AName: string); virtual; + function GetName: string; virtual; + function CurrentTest: ITest; virtual; + function get_ParentPath: string; + procedure set_ParentPath(const AName: string); virtual; + function get_Enabled: boolean; + procedure set_Enabled(const Value: boolean); + function get_Excluded: boolean; + procedure set_Excluded(const Value: boolean); + function Count: Integer; virtual; + function get_Depth: Integer; + procedure set_Depth(const Value: Integer); + function get_CheckCalled: boolean; + procedure set_CheckCalled(const Value: boolean); + procedure SaveConfiguration(const iniFile: TCustomIniFile; + const Section: string); virtual; + procedure LoadConfiguration(const iniFile :TCustomIniFile; + const Section :string); virtual; + function IsTestMethod: boolean; + function SupportedIfaceType: TSupportedIface; + function InterfaceSupports(const Value: TSupportedIface): Boolean; + function get_ElapsedTime: Extended; + procedure set_ElapsedTime(const Value: Extended); + function get_TestSetUpData: ITestSetUpData; + procedure set_TestSetUpData(const IsTestSetUpData: ITestSetUpData); + function get_FailsOnNoChecksExecuted: boolean; + procedure set_FailsOnNoChecksExecuted(const Value: boolean); + function get_InhibitSummaryLevelChecks: boolean; + procedure set_InhibitSummaryLevelChecks(const Value: boolean); + function get_EarlyExit: boolean; + function get_LeakAllowed: boolean; + procedure set_LeakAllowed(const Value: boolean); + property LeakAllowed: boolean read get_LeakAllowed; + function get_FailsOnMemoryLeak: boolean; + procedure set_FailsOnMemoryLeak(const Value: boolean); + function GetAllowedLeak: Integer; + procedure SetAllowedLeakArray(const AllowedList: array of Integer); + function get_AllowedLeaksIterator: TListIterator; + function get_AllowedMemoryLeakSize: Integer; + procedure set_AllowedMemoryLeakSize(const NewSize: Integer); + function get_IgnoresMemoryLeakInSetUpTearDown: boolean; + procedure set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); + function get_ExpectedException: ExceptClass; + procedure StartExpectingException(e: ExceptClass); + procedure StopExpectingException(const ErrorMsg :string = ''); + procedure BeginRun; virtual; + function get_ExecStatus: TExecutionStatus; + procedure set_ExecStatus(const Value: TExecutionStatus); + function get_ErrorMessage: string; + procedure set_ErrorMessage(const Value: string); + function get_ErrorAddress: PtrType; + procedure set_ErrorAddress(const Value: PtrType); + procedure Warn(const ErrorMsg: string; + const ErrorAddress: Pointer = nil); overload; + function UpdateOnFail(const ATest: ITest; + const NewStatus: TExecutionStatus; + const Excpt: Exception; + const Addrs: PtrType): TExecutionStatus; + function UpdateOnError(const ATest: ITest; + const NewStatus: TExecutionStatus; + const ExceptnMsg: string; + const Excpt: Exception; + const Addrs: PtrType): TExecutionStatus; + function GetStatus: string; + procedure Status(const Value: string); + function get_Proxy: IInterface; + procedure set_Proxy(const AProxy: IInterface); + procedure PostFail(const ErrorMsg: string; + const ErrorAddress: Pointer = nil); overload; + function PtrToStr(const P: Pointer): string; + procedure Invoke(AMethod: TExceptTestMethod); + // related to Check(Not)EqualsMem, pointer based + function GetMemDiffStr(const expected, actual: pointer; + const size: longword; const ErrorMsg: string): string; + + function EqualsErrorMessage(const expected, actual :UnicodeString; + const ErrorMsg: string): UnicodeString; virtual; + function NotEqualsErrorMessage(const expected, actual :UnicodeString; + const ErrorMsg: string): UnicodeString; virtual; + public + procedure Fail(const ErrorMsg: string; + const ErrorAddress: Pointer = nil); + procedure FailEquals(const expected, actual: UnicodeString; + const ErrorMsg: string = ''; ErrorAddrs: Pointer = nil); //virtual; + procedure FailNotEquals(const expected, actual: UnicodeString; + const ErrorMsg: string = ''; ErrorAddrs: Pointer = nil); //virtual; + procedure FailNotSame(const expected, actual: UnicodeString; + const ErrorMsg: string = ''; ErrorAddrs: Pointer = nil); //virtual; + procedure OnCheckCalled; + + { The following are the calls users make in test procedures . } + procedure EarlyExitCheck(const condition: boolean; const ErrorMsg: string = ''); + procedure CheckFalse(const condition: boolean; const ErrorMsg: string = ''); + procedure CheckNotEquals(const expected, actual: boolean; + const ErrorMsg: string = ''); overload; + procedure CheckEquals(const expected, actual: integer; + const ErrorMsg: string = ''); overload; + procedure CheckNotEquals(const expected, actual: integer; + const ErrorMsg: string = ''); overload; + procedure CheckEquals(const expected, actual: int64; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: int64; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: extended; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: extended; + const delta: extended; + const ErrorMsg: string= ''); overload; + procedure CheckEquals(const expected, actual: string; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: string; + const ErrorMsg: string = ''); overload; + procedure CheckEqualsString(const expected, actual: string; + const ErrorMsg: string = ''); + procedure CheckNotEqualsString(const expected, actual: string; + const ErrorMsg: string = ''); + {$IFNDEF UNICODE} + procedure CheckEquals(const expected, actual: UnicodeString; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: UnicodeString; + const ErrorMsg: string = ''); overload; + procedure CheckEqualsMem(const expected, actual: pointer; + const size:longword; + const ErrorMsg: string= ''); + procedure CheckNotEqualsMem(const expected, actual: pointer; + const size:longword; + const ErrorMsg:string=''); + {$ENDIF} + procedure CheckEqualsUnicodeString(const expected, actual: UnicodeString; + const ErrorMsg: string= ''); + procedure CheckNotEqualsUnicodeString(const expected, actual: UnicodeString; + const ErrorMsg: string = ''); + procedure CheckEqualsBin(const expected, actual: longword; + const ErrorMsg: string = ''; + const digits: Integer=32); + procedure CheckNotEqualsBin(const expected, actual: longword; + const ErrorMsg: string = ''; + const digits: Integer=32); + procedure CheckEqualsHex(const expected, actual: longword; + const ErrorMsg: string = ''; + const digits: Integer=8); + procedure CheckNotEqualsHex(const expected, actual: longword; + const ErrorMsg: string = ''; + const digits: Integer=8); + procedure CheckNotNull(const obj :IInterface; + const ErrorMsg :string = ''); overload; + procedure CheckNull(const obj: IInterface; + const ErrorMsg: string = ''); overload; + procedure CheckNotNull(const obj: TObject; + const ErrorMsg: string = ''); overload; + procedure CheckNull(const obj: TObject; + const ErrorMsg: string = ''); overload; + procedure CheckNotNull(const obj :Pointer; + const ErrorMsg :string = ''); overload; + procedure CheckNull(const obj: Pointer; + const ErrorMsg: string = ''); overload; + procedure CheckNotSame(const expected, actual: IInterface; + const ErrorMsg: string = ''); overload; + procedure CheckSame(const expected, actual: TObject; + const ErrorMsg: string = ''); overload; + procedure CheckNotSame(const expected, actual: TObject; + const ErrorMsg: string = ''); overload; + procedure CheckException(const AMethod: TExceptTestMethod; + const AExceptionClass: TClass; + const ErrorMsg :string = ''); + procedure CheckEquals(const expected, actual: TClass; + const ErrorMsg: string = ''); overload; + procedure CheckNotEquals(const expected, actual: TClass; + const ErrorMsg: string = ''); overload; + procedure CheckInherits(const expected, actual: TClass; + const ErrorMsg: string = ''); + procedure Check(const condition: boolean; const ErrorMsg: string= ''); overload; + procedure CheckEquals(const expected, actual: extended; + const ErrorMsg: string= ''); overload; + procedure CheckTrue(const condition: boolean; const ErrorMsg: string = ''); + procedure CheckEquals(const expected, actual: boolean; + const ErrorMsg: string = ''); overload; + procedure CheckSame(const expected, actual: IInterface; + const ErrorMsg: string = ''); overload; + procedure CheckIs(const AObject :TObject; + const AClass: TClass; + const ErrorMsg: string = ''); + procedure CheckEquals(const expected, actual: extended; + const delta: extended; + const ErrorMsg: string= ''); overload; + {$IFDEF fpcunit} + {$I FPCUnitCompatibleInterface.inc} + {$ENDIF} + public + constructor Create; overload; virtual; + constructor Create(const AName: string); overload; virtual; + constructor Create(const OwnerProc: TTestMethod; + const ParentPath: string; + const AMethod: TTestMethod; + const AMethodName: string); overload; + destructor Destroy; override; + published + property ProjectID: Integer read get_ProjectID write set_ProjectID; + property DisplayedName: string read get_DisplayedName + write set_DisplayedName; + property ParentPath: string read get_ParentPath write set_ParentPath; + property ParentTestCase: ITestCase read get_ParentTestCase write set_ParentTestCase; + property Enabled: boolean read get_Enabled write set_Enabled; + property Excluded: boolean read get_Excluded write set_Excluded; + property Depth: Integer read get_Depth write set_Depth; + property ElapsedTime: Extended read get_ElapsedTime write set_ElapsedTime; + property TestSetUpData: ITestSetUpData read get_TestSetUpData + write set_TestSetUpData; + property FailsOnNoChecksExecuted: boolean read get_FailsOnNoChecksExecuted + write set_FailsOnNoChecksExecuted; + property ExecStatus: TExecutionStatus read get_ExecStatus write set_ExecStatus; + property ExceptionClass: ExceptClass read get_ExceptionClass + write set_ExceptionClass; + property ErrorMessage: string read get_ErrorMessage write set_ErrorMessage; + property ErrorAddress: PtrType read get_ErrorAddress write set_ErrorAddress; + property ExpectedException :ExceptClass read get_ExpectedException + write StartExpectingException; + property InhibitSummaryLevelChecks: boolean read get_InhibitSummaryLevelChecks + write set_InhibitSummaryLevelChecks; + property EarlyExit: boolean read get_EarlyExit; + property FailsOnMemoryLeak: boolean read get_FailsOnMemoryLeak write set_FailsOnMemoryLeak; + property FailsOnMemLeakDetection: boolean read get_FailsOnMemoryLeak write set_FailsOnMemoryLeak; + property IgnoresMemoryLeakInSetUpTearDown: boolean read get_IgnoresMemoryLeakInSetUpTearDown write set_IgnoresMemoryLeakInSetUpTearDown; + property Proxy: IInterface read get_Proxy write set_Proxy; + end; + {$M-} + + // Provided for partial backwards compatibility + TAbstractTest = TTestProc; + + TTestCase = class(TTestProc, ITestCase) + private + FReportErrorOnce: boolean; + FProgressSummary: IInterface; + FReEntering: Boolean; + procedure EnumerateMethods; + protected + FTestIterator: ITestIterator; + procedure set_DisplayedName(const AName: string); override; + procedure set_ParentPath(const AName: string); override; + function GetName: string; override; + procedure SetUpOnce; virtual; + procedure SetUp; virtual; + function Run(const ExecControl: ITestExecControl): TExecutionStatus; virtual; + procedure TearDown; virtual; + procedure TearDownOnce; virtual; + function Count: Integer; override; + function CountTestCases: Integer; virtual; + procedure Reset; virtual; //Resets to 1st entry + procedure BeginRun; override; + function PriorTest: ITest; virtual; + function FindNextEnabledProc: ITest; virtual; + function CurrentTest: ITest; override; + procedure Status(const Value: string); + function GetStatus: string; + function get_ReEntering: Boolean; + procedure set_ReEntering(const Value: Boolean); + function get_ProgressSummary: IInterface; + procedure SaveConfiguration(const iniFile: TCustomIniFile; + const Section: string); override; + procedure LoadConfiguration(const iniFile :TCustomIniFile; + const Section :string); override; + function get_ReportErrorOnce: boolean; + procedure set_ReportErrorOnce(const Value: boolean); + property ReportErrorOnce: Boolean read get_ReportErrorOnce + write set_ReportErrorOnce; + procedure ReleaseProxys; virtual; + procedure StopTests(const ErrorMsg: string = ''); + procedure InhibitStackTrace; overload; + procedure InhibitStackTrace(const Value: boolean); overload; + + { The following are the calls users make in test procedures . } + public + procedure AddSuite(const ATest: ITest); virtual; + procedure AddTest(const ATest: ITest); + constructor Create; overload; override; + constructor Create(const AProcName: string); override; + destructor Destroy; override; + class function Suite: ITestCase; virtual; + published + property AllowedMemoryLeakSize: Integer read get_AllowedMemoryLeakSize write set_AllowedMemoryLeakSize; + property AllowedLeaksIterator: TListIterator read get_AllowedLeaksIterator; + property ProgressSummary: IInterface read get_ProgressSummary; + property ReEntering: Boolean read get_ReEntering write set_ReEntering; + end; + + + TTestSuite = class(TTestCase, ITestSuite) + protected + procedure Reset; override; //Resets all subordinate iterators to 1st entry + function PriorTest: ITest; override; + function FindNextEnabledProc: ITest; override; + function TestIterator: IReadOnlyIterator; + public + procedure AddTest(const SuiteTitle: string; const ASuite: ITestCase); reintroduce; overload; + procedure AddTest(const SuiteTitle: string; const Suites: array of ITestCase); reintroduce; overload; + constructor Create(const ASuiteName: string); overload; override; + class function Suite(const ASuiteName: string): ITestSuite; reintroduce; overload; + class function Suite(const ASuiteName: string; const ATestCase: ITestCase): ITestSuite; reintroduce; overload; + class function Suite(const ASuiteName: string; const TestCases: array of ITestCase): ITestSuite; reintroduce; overload; + end; + + + TTestDecorator = class(TTestSuite, ITestDecorator) + protected + function Run(const ExecControl: ITestExecControl): TExecutionStatus; reintroduce; override; + public + // Provides a decoratorated TestCase. + class function Suite(const DecoratedTestCase: ITestCase): ITestSuite; reintroduce; overload; + // Provides a decoratorated TestSuite. + class function Suite(const DecoratorName: string; + const DecoratedTestCase: ITestCase): ITestSuite; reintroduce; overload; + // Provides an array of decorated TestSuites/TestCases + class function Suite(const DecoratorName: string; + const DecoratedTestCases: array of ITestCase): ITestSuite; reintroduce; overload; + end; + + + TRepeatedTest = class(TTestSuite, IRepeatedTest) + private + FRepeatCount: Integer; + FHaltOnError: Boolean; + function GetHaltOnError: Boolean; + procedure SetHaltOnError(const Value: Boolean); + protected + function Run(const ExecControl: ITestExecControl): TExecutionStatus; override; + procedure set_RepeatCount(const Value: Integer); + function Count: Integer; override; + published + property RepeatCount: Integer write set_RepeatCount; + property HaltOnError: Boolean read GetHaltOnError write SetHaltOnError; + public + class function Suite(const CountedTestCase: ITestCase; + const Iterations: Cardinal): IRepeatedTest; reintroduce; overload; + end; + + + TTestProject = class(TTestSuite, ITestProject, IReadOnlyIterator) + private + FAllTestsList: IInterfaceList; // ITests stored in reverse order + FSuiteList: IInterfaceList; // Holds a list of retreivable TestSuites + FTestIdx: Integer; + FManager: IInterface; //Points to ProjectManager. + FEnabledTestsCounted: boolean; + FProjectName: string; + FExecStatusUpdater: TExecStatusUpdater; + FStatusMsgUpdater: TStatusMsgUpdater; + FTestingBegins: boolean; + FListener: IInterface; + FCount: Integer; + FExecControl: ITestExecControl; + procedure CreateFields; + function IsTestSelected(const ATest: ITest):Boolean; + procedure ExecStatusUpdater(const ATest: ITest); + procedure StatusMessageUpdater(const ATest: ITest; const AStatusMsg: string); + procedure AddNamedSuite(const SuiteTitle: string; const ATest: ITestCase); + protected + function CountEnabledTests: Integer; + function get_ProjectName: string; + procedure set_ProjectName(const AName: string); + procedure Reset; override; + function SuiteByTitle(const SuiteTitle: string): ITestSuite; + function FindFirstTest: ITest; virtual; + function FindNextTest: ITest; virtual; + function FindNextEnabledProc: ITest; override; + function Count: Integer; override; // Count of enabled procedures + procedure AddTest(const ATest: ITest); reintroduce; overload; + procedure RegisterTest(const ATest: ITest); + function get_Manager: IInterface; + procedure set_Manager(const AManager: IInterface); + function ExecutionControl: ITestExecControl; virtual; + function Run(const ExecControl: ITestExecControl): TExecutionStatus; override; + procedure set_Listener(const Value: IInterface); + public + constructor Create; overload; override; + constructor Create(const ASuiteName: string); overload; override; + destructor Destroy; override; + published + property Manager: IInterface read get_Manager write set_Manager; + property ProjectName: string read get_ProjectName write set_ProjectName; + property Listener: IInterface write set_Listener; + end; + + +function TestExecControl: ITestExecControl; +function Projects: ITestProject; overload; +function TestProject: ITestProject; overload; +function TestProject(const idx: Integer): ITestProject; overload; +{$IFDEF FASTMM} +function MemLeakMonitor: IDUnitMemLeakMonitor; +{$ENDIF} +// creating suites +procedure ProjectRegisterTest(const ProjectName: string; + const ATest: ITestCase); overload; +procedure ProjectRegisterTest(const ProjectName: string; + const SuiteTitle: string; + const ATest: ITestCase); overload; +procedure ProjectRegisterTests(const ProjectName: string; + const Tests: array of ITestCase); overload; +procedure ProjectRegisterTests(const ProjectName: string; + const SuiteTitle: string; + const Tests: array of ITestCase); overload; +procedure RegisterTest(const ATest: ITestCase); overload; +procedure RegisterTest(const SuiteTitle: string; + const ATest: ITestCase); overload; +procedure RegisterTests(const Tests: array of ITestCase); overload; +procedure RegisterTests(const SuiteTitle: string; + const Tests: array of ITestCase); overload; +function RegisteredTests: ITestSuite; +function RegisterProject(const AProject: ITestProject): Integer; overload; +function RegisterProject(const AName: string; + const AProject: ITestProject): Integer; overload; +procedure UnRegisterProjectManager; +function CallerAddr: Pointer; {$IFNDEF FPC}assembler;{$ENDIF} + +{$BOOLEVAL OFF} + +implementation +uses +// StrUtils, + TypInfo, + Math, + {$IFDEF FPC} + fpchelper, + {$ENDIF} + ProjectsManagerIface, + ProjectsManager, + TestListenerIface, + TimeManager; + +{$STACKFRAMES ON} // Required to retrieve caller's address + +{ This lets us use a single include file for both the Interface and + Implementation sections. } +{$undef read_interface} +{$define read_implementation} + + +const + csExcluded = 'Excluded_'; + +var // This holds the singleton ProjectManager + ProjectManager: IProjectManager = nil; + +type + +{$M+} + TTestExecControl = class(TInterfacedObject, ITestExecControl) + private + FTestSetUpData: ITestSetUpData; + FHaltTesting: boolean; + FBreakOnFailures: Boolean; + FTestCanRun: boolean; + FStatusUpdater: TExecStatusUpdater; + FStatusMsgUpdater: TStatusMsgUpdater; + FIndividuallyEnabledTest: TIsTestSelected; + FEnabledCount: Cardinal; + FExecutionCount: Cardinal; + FFailsOnNoChecksExecuted: boolean; + FErrorCount: Integer; + FFailureCount: Integer; + FWarningCount: Integer; + FExcludedCount: Integer; + FCurrentTest: ITest; + FCheckCalledCount: Integer; + FInhibitStackTrace: boolean; + FInhibitSummaryLevelChecks: Boolean; + FFailsOnMemoryLeak: boolean; + FIgnoresMemoryLeakInSetUpTearDown: boolean; + function get_TestSetUpData: ITestSetUpData; + procedure set_TestSetUpData(const Value: ITestSetUpData); + function get_HaltExecution: boolean; + procedure set_HaltExecution(const Value: boolean); + function get_BreakOnFailures: boolean; + procedure set_BreakOnFailures(const Value: boolean); + procedure ClearCounts; + function get_TestCanRun: boolean; + procedure set_TestCanRun(const Value: boolean); + function get_CurrentTest: ITest; + procedure set_CurrentTest(const Value: ITest); + function get_ExecStatusUpdater: TExecStatusUpdater; + procedure set_ExecStatusUpdater(const Value: TExecStatusUpdater); + function get_StatusMsgUpdater: TStatusMsgUpdater; + procedure set_StatusMsgUpdater(const Value: TStatusMsgUpdater); + function get_EnabledCount: Cardinal; + procedure set_EnabledCount(const Value: Cardinal); + function get_ExecutionCount: Cardinal; + procedure set_ExecutionCount(const Value: Cardinal); + function get_FailsOnNoChecksExecuted: boolean; + procedure set_FailsOnNoChecksExecuted(const Value: boolean); + function get_FailureCount: Integer; + procedure set_FailureCount(const Value: Integer); + function get_ErrorCount: Integer; + procedure set_ErrorCount(const Value: Integer); + function get_WarningCount: Integer; + procedure set_WarningCount(const Value: Integer); + function get_ExcludedCount: Integer; + procedure set_ExcludedCount(const Value: Integer); + function get_CheckCalledCount: Integer; + procedure set_CheckCalledCount(const Value: Integer); + function get_IndividuallyEnabledTest: TIsTestSelected; + procedure set_IndividuallyEnabledTest(const Value: TIsTestSelected); + procedure IssueStatusMsg(const ATest: ITestMethod; const StatusMsg: string); + function get_InhibitStackTrace: boolean; + procedure set_InhibitStackTrace(const Value: boolean); + function get_InhibitSummaryLevelChecks: boolean; + procedure set_InhibitSummaryLevelChecks(const Value: boolean); + function get_FailsOnMemoryLeak: boolean; + procedure set_FailsOnMemoryLeak(const Value: boolean); + function get_IgnoresMemoryLeakInSetUpTearDown: boolean; + procedure set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); + public + constructor Create; overload; + constructor Create(const MExecStatusCallback: TExecStatusUpdater; + const MStatusMsgUpdater: TStatusMsgUpdater; + const MTestCanRun: TIsTestSelected); overload; + destructor Destroy; override; + end; + {$M-} + + {$M+} + TProgressSummary = class(TInterfacedObject, IProgressSummary) + private + FErrors: Integer; + FFailures: Integer; + FWarnings: Integer; + FTestsExecuted: Cardinal; + FTestsExcluded: Integer; + FUpdated: Boolean; + protected + function get_Errors: Integer; + function get_Failures: Integer; + function get_Warnings: Integer; + function get_TestsExecuted: Cardinal; + function get_TestsExcluded: Integer; + function Updated: boolean; + procedure UpdateSummary(const ExecControl: ITestExecControl); + public + constructor Create(const ExecControl: ITestExecControl); + end; +{$M-} + +function TestExecControl: ITestExecControl; +begin + Result := TTestExecControl.Create; +end; + +function RegisteredTests: ITestSuite; +begin + Result := TestProject; +end; + +function RegisterProject(const AProject: ITestProject): Integer; +begin + Result := -1; + if not Assigned(AProject) then + Exit; + + if not Assigned(ProjectManager) then + ProjectManager := TProjectManager.Create; + Result := ProjectManager.AddProject(AProject); +end; + +function RegisterProject(const AName: string; + const AProject: ITestProject): Integer; overload; +begin + if AName <> '' then + AProject.DisplayedName := AName; + + Result := RegisterProject(AProject); +end; + +procedure UnRegisterProjectManager; +begin + if Assigned(ProjectManager) then + ProjectManager.ReleaseProjects; + ProjectManager := nil; +end; + +const + sExpectedButWasFmt = 'Expected:'+LineEnding+' "%s"'+LineEnding+'But was:'+LineEnding+' "%s"'; + sExpectedButWasAndMessageFmt = ' "%s"'+LineEnding + sExpectedButWasFmt; + sActualEqualsExpFmt = 'Expected '+LineEnding+'< %s > '+LineEnding+'equals actual '+LineEnding+'< %s >'; + sMsgActualEqualsExpFmt = '%s'+LineEnding+sActualEqualsExpFmt; + +type + EStopTestsFailure = class(ETestFailure); + EPostTestFailure = class(ETestFailure); + EPostTestWarning = class(ETestFailure); + ETestFailOverride = class(ETestFailure); + ECheckExit = class(ETestFailure); + EBreakingTestFailure = class(EDUnitException); + + TMemoryLeakMonitor = class(TInterfacedObject, IMemLeakMonitor) + private + {$IFDEF FASTMM} + FMS1: TMemoryManagerState; + FMS2: TMemoryManagerState; + {$ENDIF} + protected + function MemLeakDetected(out LeakSize: Integer): boolean; + public + constructor Create; + end; + + {$M+} + TDUnitMemLeakMonitor = class(TMemoryLeakMonitor, IDUnitMemLeakMonitor) + public + procedure MarkMemInUse; + function MemLeakDetected(const AllowedLeakSize: Integer; + const FailOnMemoryRecovery: boolean; + out LeakSize: Integer): boolean; overload; + function MemLeakDetected(const AllowedValuesGetter: TListIterator; + const FailOnMemoryRecovery: boolean; + out LeakIndex: Integer; + out LeakSize: Integer): boolean; overload; + function GetMemoryUseMsg(const FailOnMemoryRecovery: boolean; + const TestProcChangedMem: Integer; + out ErrorMsg: string): boolean; overload; + function GetMemoryUseMsg(const FailOnMemoryRecovery: boolean; + const TestSetupChangedMem: Integer; + const TestProcChangedMem: Integer; + const TestTearDownChangedMem: Integer; + const TestCaseChangedMem: Integer; + out ErrorMsg: string): boolean; overload; + end; + + TBaseMemUseComparator = class(TInterfacedObject, IMemUseComparator) + private + FTestOwner: ITestCase; + FExecCtrl: ITestExecControl; + protected + procedure RunSetup(const UsersSetUp: TThreadMethod); virtual; + procedure RunTearDown(const UsersTearDown: TThreadMethod); virtual; + function AlertOnMemoryLoss(const CurrentStatus: TExecutionStatus): TExecutionStatus; virtual; + public + constructor Create(const ATestOwner: ITestCase; + const AExecControl: ITestExecControl); virtual; + end; + + TMemUseComparator = class(TBaseMemUseComparator) + private + FTest: ITest; + FEntryWarnCount: Integer; + FTestCaseMemLeakMonitor : IDUnitMemLeakMonitor; + FTestMemLeakMonitor : IDUnitMemLeakMonitor; + FTestCaseMemDiff : Integer; + FTestProcMemDiff : Integer; + FSetUpMemDiff : Integer; + FTearDownMemDiff : Integer; + {$IFDEF FASTMM} + function BumpWarningCount(const ALeakSize: Integer): TExecutionStatus; + {$ENDIF} + protected + procedure BeginTestMethod; + procedure RunSetup(const UsersSetUp: TThreadMethod); override; + procedure RunTearDown(const UsersTearDown: TThreadMethod); override; + function AlertOnMemoryLoss(const CurrentStatus: TExecutionStatus): TExecutionStatus; override; + public + constructor Create(const ATestOwner: ITestCase; + const AExecControl: ITestExecControl); override; + end; + +{ TMethodEnumerator } + +type + TMethodEnumerator = class + private + FMethodNameList: array of string; + protected + function GetNameOfMethod(idx: Integer): string; + function GetMethodCount: Integer; + public + constructor Create(AClass: TClass); + property MethodCount: Integer read GetMethodCount; + property NameOfMethod[idx: Integer]: string read GetNameOfMethod; + end; +{$M-} + + { TMemLeakMonitor } + +constructor TMemoryLeakMonitor.Create; +begin + inherited; + {$IFDEF FASTMM} + GetMemoryManagerState(FMS1); + {$ENDIF} +end; + +{$IFNDEF FASTMM} +function TMemoryLeakMonitor.MemLeakDetected(out LeakSize: Integer): Boolean; +begin + LeakSize := 0; + Result := False; +end; +{$ELSE} + +function MemLeakMonitor: IDUnitMemLeakMonitor; +begin + Result := TDUnitMemLeakMonitor.Create +end; + +function TMemoryLeakMonitor.MemLeakDetected(out LeakSize: Integer): boolean; +var + i: Integer; + LSMBSize1, + LSMBSize2: Int64; + +begin + LeakSize := 0; + LSMBSize1 := 0; + LSMBSize2 := 0; + GetMemoryManagerState(FMS2); + + for i := 0 to NumSmallBlockTypes - 1 do // Iterate through the blocks + begin + Inc(LSMBSize1, (FMS1.SmallBlockTypeStates[i].InternalBlockSize * + FMS1.SmallBlockTypeStates[i].AllocatedBlockCount)); + Inc(LSMBSize2, (FMS2.SmallBlockTypeStates[i].InternalBlockSize * + FMS2.SmallBlockTypeStates[i].AllocatedBlockCount)); + end; + + LeakSize := (LSMBSize2 - LSMBSize1); + + LeakSize := LeakSize + + (Int64(FMS2.TotalAllocatedMediumBlockSize) - Int64(FMS1.TotalAllocatedMediumBlockSize)) + + (Int64(FMS2.TotalAllocatedLargeBlockSize) - Int64(FMS1.TotalAllocatedLargeBlockSize)); + + Result := LeakSize <> 0; +end; +{$ENDIF} + +// May be called after detecting memory use change at Test Procedure level +function TDUnitMemLeakMonitor.GetMemoryUseMsg(const FailOnMemoryRecovery: boolean; + const TestProcChangedMem: Integer; + out ErrorMsg: string): boolean; +begin + ErrorMsg := ''; + + if (TestProcChangedMem > 0) then + ErrorMsg := IntToStr(TestProcChangedMem) + + ' Bytes Memory Leak in Test Procedure' + else + if (TestProcChangedMem < 0) and (FailOnMemoryRecovery) then + ErrorMsg := IntToStr(Abs(TestProcChangedMem)) + + ' Bytes Memory Recovered in Test Procedure'; + + Result := (Length(ErrorMsg) = 0); +end; + +function TDUnitMemLeakMonitor.MemLeakDetected(const AllowedLeakSize: Integer; + const FailOnMemoryRecovery: boolean; + out LeakSize: Integer): boolean; +begin + LeakSize := 0; + inherited MemLeakDetected(LeakSize); + Result := ((LeakSize > 0) and (LeakSize <> AllowedLeakSize)) or + ((LeakSize < 0) and (FailOnMemoryRecovery) and (LeakSize <> AllowedLeakSize)); +end; + +procedure TDUnitMemLeakMonitor.MarkMemInUse; +begin + {$IFDEF FASTMM} + GetMemoryManagerState(FMS1); + {$ENDIF} +end; + +function TDUnitMemLeakMonitor.MemLeakDetected(const AllowedValuesGetter: TListIterator; + const FailOnMemoryRecovery: boolean; + out LeakIndex: Integer; + out LeakSize: Integer): boolean; +var + AllowedLeakSize: Integer; +begin + LeakIndex := 0; + LeakSize := 0; + Result := False; + inherited MemLeakDetected(LeakSize); + if (LeakSize = 0) then + exit; + + // Next line access value stored via SetAllowedLeakSize, if any + if LeakSize = AllowedValuesGetter then + Exit; + + repeat // loop over values stored via SetAllowedLeakArray + inc(LeakIndex); + AllowedLeakSize := AllowedValuesGetter; + if (LeakSize = AllowedLeakSize) then + Exit; + until (AllowedLeakSize = 0); + Result := (LeakSize > 0) or ((LeakSize < 0) and FailOnMemoryRecovery); +end; + +// Expanded message generation for detected leak isolation +// Use additional knowledge of when Setup and or TearDown have nor run. + +function TDUnitMemLeakMonitor.GetMemoryUseMsg(const FailOnMemoryRecovery: boolean; + const TestSetupChangedMem: Integer; + const TestProcChangedMem: Integer; + const TestTearDownChangedMem: Integer; + const TestCaseChangedMem: Integer; + out ErrorMsg: string): boolean; +var + Location: string; +begin + Result := False; + ErrorMsg := ''; + + if (TestSetupChangedMem = 0) and (TestProcChangedMem = 0) and + (TestTearDownChangedMem = 0) and (TestCaseChangedMem <> 0) then + begin + ErrorMsg := + 'Error in TestFrameWork. No leaks in Setup, TestProc or Teardown but '+ + IntToStr(TestCaseChangedMem) + + ' Bytes Memory Leak reported across TestCase'; + Exit; + end; + + if (TestSetupChangedMem + TestProcChangedMem + TestTearDownChangedMem) <> + TestCaseChangedMem then + begin + ErrorMsg := + 'Error in TestFrameWork. Sum of Setup, TestProc and Teardown leaks <> '+ + IntToStr(TestCaseChangedMem) + + ' Bytes Memory Leak reported across TestCase'; + Exit; + end; + + Result := True; + if TestCaseChangedMem = 0 then + Exit; // Dont waste further time here + + if (TestCaseChangedMem < 0) and not FailOnMemoryRecovery then + Exit; // Dont waste further time here + + +// We get to here because there is a memory use imbalance to report. + if (TestCaseChangedMem > 0) then + ErrorMsg := IntToStr(TestCaseChangedMem) + ' Bytes memory leak (' + else + ErrorMsg := IntToStr(TestCaseChangedMem) + ' Bytes memory recovered ('; + + Location := ''; + + if (TestSetupChangedMem <> 0) then + Location := 'Setup= ' + IntToStr(TestSetupChangedMem) + ' '; + if (TestProcChangedMem <> 0) then + Location := Location + 'TestProc= ' + IntToStr(TestProcChangedMem) + ' '; + if (TestTearDownChangedMem <> 0) then + Location := Location + 'TearDown= ' + IntToStr(TestTearDownChangedMem) + ' '; + + ErrorMsg := ErrorMsg + Location + ')'; + Result := (Length(ErrorMsg) = 0); +end; + +{ TBaseMemUseComparator } + +constructor TBaseMemUseComparator.Create(const ATestOwner: ITestCase; + const AExecControl: ITestExecControl); +begin + inherited Create; + FTestOwner := ATestOwner; + FExecCtrl := AExecControl; +end; + +procedure TBaseMemUseComparator.RunSetup(const UsersSetUp: TThreadMethod); +begin + UsersSetUp; +end; + +procedure TBaseMemUseComparator.RunTearDown(const UsersTearDown: TThreadMethod); +begin + UsersTearDown; +end; + +function TBaseMemUseComparator.AlertOnMemoryLoss(const CurrentStatus: TExecutionStatus): TExecutionStatus; +begin + Result := CurrentStatus; +end; + +{ TMemUseComparitor } + +constructor TMemUseComparator.Create(const ATestOwner: ITestCase; + const AExecControl: ITestExecControl); +begin + inherited Create(ATestOwner, AExecControl); + FTestMemLeakMonitor := TDUnitMemLeakMonitor.Create; + FTestCaseMemLeakMonitor := TDUnitMemLeakMonitor.Create; +end; + +{$IFDEF FASTMM} +function TMemUseComparator.BumpWarningCount(const ALeakSize: Integer): TExecutionStatus; +begin + Result := _Warning; + if FEntryWarnCount = FExecCtrl.WarningCount then // we can bump count + begin + FExecCtrl.WarningCount := FExecCtrl.WarningCount + 1; + case ALeakSize of + -1: begin + if FTest.ErrorMessage = '' then + FTest.ErrorMessage := 'Allowed leak size of ' + IntToStr(FTestCaseMemDiff) + ' Bytes'; + FTest.ExceptionClass := ExceptClass(ETestFailOverride); + end; + 0: begin + if FTest.ErrorMessage = '' then + FTest.ErrorMessage := 'Leak Allowed in SetUp/Teardown. Size = ' + IntToStr(FTestCaseMemDiff) + ' Bytes'; + FTest.ExceptionClass := ExceptClass(ETestFailOverride); + end; + else + begin + if FTest.ErrorMessage = '' then + FTest.ErrorMessage := 'Possible memory leak of ' + IntToStr(FTestCaseMemDiff) + ' Bytes'; + FTest.ExceptionClass := ExceptClass(EPostTestWarning); + end; + end; {case} + end; +end; +{$ENDIF} + +procedure TMemUseComparator.BeginTestMethod; +begin + FTest := FTestOwner.CurrentTest; + FEntryWarnCount := FExecCtrl.WarningCount; + {$IFDEF FASTMM} + FTestOwner.AllowedMemoryLeakSize := 0; + FTestOwner.SetAllowedLeakArray([]); + //Set run-time options in owning TTestcase prior to executing user's SetUp proc. + FTestOwner.FailsOnMemoryLeak := FExecCtrl.FailsOnMemoryLeak; + FTestOwner.IgnoresMemoryLeakInSetUpTearDown := FExecCtrl.IgnoresMemoryLeakInSetUpTearDown; + {$ENDIF} +end; + +procedure TMemUseComparator.RunSetup(const UsersSetUp: TThreadMethod); +begin + BeginTestMethod; + FTestCaseMemLeakMonitor.MarkMemInUse; + FTestMemLeakMonitor.MarkMemInUse; + UsersSetUp; + (FTestMemLeakMonitor as IMemLeakMonitor).MemLeakDetected(FSetUpMemDiff); + FTestMemLeakMonitor.MarkMemInUse; +end; + +procedure TMemUseComparator.RunTearDown(const UsersTearDown: TThreadMethod); +begin + (FTestMemLeakMonitor as IMemLeakMonitor).MemLeakDetected(FTestProcMemDiff); + FTestMemLeakMonitor.MarkMemInUse; + UsersTearDown; + (FTestMemLeakMonitor as IMemLeakMonitor).MemLeakDetected(FTearDownMemDiff); + (FTestCaseMemLeakMonitor as IMemLeakMonitor).MemLeakDetected(FTestCaseMemDiff); + + // Test ran in context of owning TTestcase so copy any changed settings into TestMethod instance + {$IFDEF FASTMM} + FTest.FailsOnMemoryLeak := FTestOwner.FailsOnMemoryLeak; + FTest.IgnoresMemoryLeakInSetUpTearDown := FTestOwner.IgnoresMemoryLeakInSetUpTearDown; + {$ENDIF} +end; + +function TMemUseComparator.AlertOnMemoryLoss(const CurrentStatus: TExecutionStatus): TExecutionStatus; +{$IFDEF FASTMM} +var + LMemoryLeakIgnoredInSetupOrTearDown: Boolean; + LMemoryImbalance : boolean; + LLeakIndex : Integer; + LMemErrorMessage : string; + LExcept: Exception; +{$ENDIF} +begin + Result := CurrentStatus; + {$IFDEF FASTMM} + if not (Result = _Passed) then + Exit; + + LExcept := nil; + LMemoryImbalance := + FTestCaseMemLeakMonitor.MemLeakDetected(FTestOwner.AllowedLeaksIterator, + False {was FailsOnMemoryRecovery}, + LLeakIndex, + FTestCaseMemDiff); + + LMemoryLeakIgnoredInSetupOrTearDown := + (FExecCtrl.IgnoresMemoryLeakInSetUpTearDown or + FTestOwner.IgnoresMemoryLeakInSetUpTearDown) and + (FTestProcMemDiff = 0) and LMemoryImbalance; + + if (FTestCaseMemDiff > 0) { or (FailsOnMemoryRecovery and (LTestCaseMemDiff < 0)) } then + begin + // A leak has been detected so see if it matches an allowed leak size, + FTest.LeakAllowed := not LMemoryImbalance; + if FTest.LeakAllowed then + begin + // The leak matched an allowed size so save it and let the test pass + FTest.AllowedMemoryLeakSize := FTestCaseMemDiff; + Result := BumpWarningCount(-1); + end + else + begin + if not FTestOwner.FailsOnMemoryLeak or LMemoryLeakIgnoredInSetupOrTearDown then + Result := BumpWarningCount(0) + else + begin // Construct possible leak location message + FTestCaseMemLeakMonitor.GetMemoryUseMsg(False, //was FailsOnMemoryRecovery (now depricated) + FSetUpMemDiff, + FTestProcMemDiff, + FTearDownMemDiff, + FTestCaseMemDiff, + LMemErrorMessage); + try + LExcept := EPostTestFailure.Create(LMemErrorMessage); + Result := FTestOwner.UpdateOnFail(FTest, _Failed, LExcept, IntPtr(FTest.ErrorAddress)); + finally + FreeAndNil(LExcept); + end + end; + end; + end + else + if (FTestCaseMemDiff > 0) then + begin + if not LMemoryImbalance then + Result := BumpWarningCount(-1) + else + Result := BumpWarningCount(FTestCaseMemDiff); + end; + {$ENDIF} +end; + +{ ETestFailure } + +constructor ETestFailure.Create; +begin + inherited Create('') +end; + +constructor ETestFailure.Create(const ErrorMsg: string); +begin + inherited Create(ErrorMsg) +end; + +constructor TMethodEnumerator.Create(AClass: TClass); +{$IFDEF FPC} +var + ml: TStringList; + i: integer; + LName: string; +begin + inherited Create; + ml := TStringList.Create; + try + GetMethodList(AClass, ml); + if ml.Count > 0 then + SetLength(FMethodNameList, ml.Count); + for i := 0 to ml.Count-1 do + FMethodNameList[i] := ml[i]; + finally + ml.Free; + end; +{$ELSE} +{ TODO -cRefactoring : Move this out into a DelphiHelper unit. } +type + TMethodTable = packed record + Count: SmallInt; + end; + +var + table: ^TMethodTable; + AName: ^ShortString; + i, J: Integer; + LClass: TClass; +begin + inherited Create; + table := nil; + LClass := AClass; + while LClass <> nil do + begin + asm + mov EAX, [LClass] + mov EAX,[EAX].vmtMethodTable { fetch pointer to method table } + mov [table], EAX + end; + if table <> nil then + begin + AName := Pointer(PAnsiChar(table) + 8); + for i := 1 to table.count do + begin + // check if we've seen the method name + J := Low(FMethodNameList); + while (J <= High(FMethodNameList)) and (string(AName^) <> FMethodNameList[J]) do + inc(J); + // if we've seen the name, then the method has probably been overridden + if J > High(FMethodNameList) then + begin + SetLength(FMethodNameList,length(FMethodNameList)+1); + FMethodNameList[J] := string(AName^); + end; + AName := Pointer(PAnsiChar(AName) + length(AName^) + 7) + end; + end; + LClass := LClass.ClassParent; + end; +{$ENDIF} +end; + +function TMethodEnumerator.GetMethodCount: Integer; +begin + Result := Length(FMethodNameList); +end; + +function TMethodEnumerator.GetNameOFMethod(idx: Integer): string; +begin + Result := FMethodNameList[idx]; +end; + + +{ TTestReadOnlyIterator } + +constructor TReadOnlyIterator.Create; +begin + inherited Create; + idx := 0; + FIList := TInterfaceList.Create; +end; + +function TReadOnlyIterator.CurrentTest: ITest; +begin + Result := FCurrentTest; +end; + +destructor TReadOnlyIterator.Destroy; +begin + FIList := nil; // So we can see the destructors run + inherited; +end; + +function TReadOnlyIterator.Count: Integer; +begin + Result := FIList.Count; +end; + +function TReadOnlyIterator.FindFirstTest: ITest; +begin + idx := 0; + if Count > 0 then + Result := (FIList[idx] as ITest) + else + Result := nil; + FCurrentTest := Result; +end; + +function TReadOnlyIterator.FindNextTest: ITest; +begin + Result := nil; + if idx < Count then + begin + Result := (FIList.Items[idx] as ITest); + inc(idx); // idx will eventually = count + end; + FCurrentTest := Result; +end; + +function TReadOnlyIterator.PriorTest: ITest; +begin + Result := nil; + if idx > 0 then + begin + Dec(idx); + Result := (FIList.Items[idx] as ITest); + end; + FCurrentTest := Result; +end; + +procedure TReadOnlyIterator.Reset; +begin + idx := 0; + FCurrentTest := nil; +end; + +function TReadOnlyIterator.FindNextEnabledProc: ITest; +begin + repeat + Result := FindNextTest; + until (Result = nil) or Result.Enabled; +end; + +{ TTestIterator } + +procedure TTestIterator.AddTest(const ATest: ITest); +begin + if (ATest <> nil) then + FIList.Add(ATest); +end; + +{ TTestExectionControl } + +constructor TTestExecControl.Create; +begin + inherited; + FTestCanRun := True; //True by default +end; + +constructor TTestExecControl.Create(const MExecStatusCallback: TExecStatusUpdater; + const MStatusMsgUpdater: TStatusMsgUpdater; + const MTestCanRun: TIsTestSelected); +begin + Create; + FStatusUpdater := MExecStatusCallback; + FStatusMsgUpdater := MStatusMsgUpdater; + FIndividuallyEnabledTest := MTestCanRun; +end; + +destructor TTestExecControl.Destroy; +begin + FTestCanRun := False; + FStatusUpdater := nil; + inherited; +end; + +procedure TTestExecControl.ClearCounts; +begin + FEnabledCount := 0; + FExecutionCount := 0; + FErrorCount := 0; + FFailureCount := 0; + FWarningCount := 0; + FCheckCalledCount := 0; +end; + +function TTestExecControl.get_BreakOnFailures: boolean; +begin + Result := FBreakOnFailures; +end; + +procedure TTestExecControl.set_BreakOnFailures(const Value: boolean); +begin + FBreakOnFailures := Value; +end; + +function TTestExecControl.get_CheckCalledCount: Integer; +begin + Result := FCheckCalledCount; +end; + +procedure TTestExecControl.set_CheckCalledCount(const Value: Integer); +begin + if Value = 0 then + FCheckCalledCount := 0 + else + Inc(FCheckCalledCount); +end; + +function TTestExecControl.get_CurrentTest: ITest; +begin + Result := FCurrentTest; +end; + +procedure TTestExecControl.set_CurrentTest(const Value: ITest); +begin + FCurrentTest := Value; +end; + +function TTestExecControl.get_EnabledCount: Cardinal; +begin + Result := FEnabledCount; +end; + +procedure TTestExecControl.set_EnabledCount(const Value: Cardinal); +begin + FEnabledCount := Value; +end; + +function TTestExecControl.get_ErrorCount: Integer; +begin + Result := FErrorCount; +end; + +procedure TTestExecControl.set_ErrorCount(const Value: Integer); +begin + FErrorCount := Value; +end; + +function TTestExecControl.get_ExecutionCount: Cardinal; +begin + Result := FExecutionCount; +end; + +procedure TTestExecControl.set_ExecutionCount(const Value: Cardinal); +begin + FExecutionCount := Value; +end; + +function TTestExecControl.get_FailsOnNoChecksExecuted: boolean; +begin + Result := FFailsOnNoChecksExecuted; +end; + +procedure TTestExecControl.set_FailsOnNoChecksExecuted(const Value: boolean); +begin + FFailsOnNoChecksExecuted := Value; +end; + +function TTestExecControl.get_FailureCount: Integer; +begin + Result := FFailureCount; +end; + +function TTestExecControl.get_HaltExecution: boolean; +begin + Result := FHaltTesting; +end; + +procedure TTestExecControl.set_HaltExecution(const Value: boolean); +begin + FHaltTesting := Value; +end; + +procedure TTestExecControl.set_FailureCount(const Value: Integer); +begin + FFailureCount := Value; +end; + +function TTestExecControl.get_IndividuallyEnabledTest: TIsTestSelected; +begin + Result := FIndividuallyEnabledTest; +end; + +function TTestExecControl.get_InhibitSummaryLevelChecks: boolean; +begin + Result := FInhibitSummaryLevelChecks; +end; + +procedure TTestExecControl.set_InhibitSummaryLevelChecks(const Value: boolean); +begin + FInhibitSummaryLevelChecks := Value; +end; + +function TTestExecControl.get_InhibitStackTrace: boolean; +begin + Result := FInhibitStackTrace; +end; + +procedure TTestExecControl.set_InhibitStackTrace(const Value: boolean); +begin + FInhibitStackTrace := Value; +end; + +procedure TTestExecControl.set_IndividuallyEnabledTest(const Value: TIsTestSelected); +begin + FIndividuallyEnabledTest := Value; +end; + +function TTestExecControl.get_StatusMsgUpdater: TStatusMsgUpdater; +begin + Result := FStatusMsgUpdater; +end; + +procedure TTestExecControl.set_StatusMsgUpdater(const Value: TStatusMsgUpdater); +begin + FStatusMsgUpdater := Value; +end; + +function TTestExecControl.get_ExecStatusUpdater: TExecStatusUpdater; +begin + Result := FStatusUpdater; +end; + +procedure TTestExecControl.set_ExecStatusUpdater(const Value: TExecStatusUpdater); +begin + FStatusUpdater := Value; +end; + +function TTestExecControl.get_TestCanRun: boolean; +begin + Result := FTestCanRun; +end; + +function TTestExecControl.get_TestSetUpData: ITestSetUpData; +begin + Result := FTestSetUpData; +end; + +procedure TTestExecControl.set_TestCanRun(const Value: boolean); +begin + FTestCanRun := Value; +end; + +procedure TTestExecControl.set_TestSetUpData(const Value: ITestSetUpData); +begin + FTestSetUpData := Value; +end; + +function TTestExecControl.get_WarningCount: Integer; +begin + Result := FWarningCount; +end; + +procedure TTestExecControl.set_WarningCount(const Value: Integer); +begin + FWarningCount := Value; +end; + +function TTestExecControl.get_ExcludedCount: Integer; +begin + Result := FExcludedCount; +end; + +procedure TTestExecControl.set_ExcludedCount(const Value: Integer); +begin + FExcludedCount := Value; +end; + +procedure TTestExecControl.IssueStatusMsg(const ATest: ITestMethod; + const StatusMsg: string); +begin + Assert(False, 'procedure IssueStatusMsg not implenented'); +end; + +function TTestExecControl.get_FailsOnMemoryLeak: boolean; +begin + Result := FFailsOnMemoryLeak; +end; + +procedure TTestExecControl.set_FailsOnMemoryLeak(const Value: boolean); +begin + FFailsOnMemoryLeak := Value; +end; + +function TTestExecControl.get_IgnoresMemoryLeakInSetUpTearDown: boolean; +begin + Result := FIgnoresMemoryLeakInSetUpTearDown; +end; + +procedure TTestExecControl.set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); +begin + FIgnoresMemoryLeakInSetUpTearDown := Value; +end; + +{ TProgressSummary } + +constructor TProgressSummary.Create(const ExecControl: ITestExecControl); +begin + inherited Create; + if ExecControl = nil then + Exit; + + FErrors := ExecControl.ErrorCount; + FFailures := ExecControl.FailureCount; + FWarnings := ExecControl.WarningCount; + FTestsExecuted := ExecControl.ExecutionCount; + FTestsExcluded := ExecControl.ExcludedCount; +end; + +function TProgressSummary.get_Errors: Integer; +begin + Result := FErrors; +end; + +function TProgressSummary.get_Failures: Integer; +begin + Result := FFailures; +end; + +function TProgressSummary.get_TestsExcluded: Integer; +begin + Result := FTestsExcluded; +end; + +function TProgressSummary.get_TestsExecuted: Cardinal; +begin + Result := FTestsExecuted; +end; + +function TProgressSummary.get_Warnings: Integer; +begin + Result := FWarnings; +end; + +function TProgressSummary.Updated: boolean; +begin + Result := FUpdated; +end; + +procedure TProgressSummary.UpdateSummary(const ExecControl: ITestExecControl); +begin + FErrors := ExecControl.ErrorCount - FErrors; + FFailures := ExecControl.FailureCount - FFailures; + FWarnings := ExecControl.WarningCount - FWarnings; + FTestsExecuted := ExecControl.ExecutionCount - FTestsExecuted; + FTestsExcluded := ExecControl.ExcludedCount - FTestsExcluded; + FUpdated := True; +end; + + +{ TTestProc } +var + CUniqueID: Cardinal = 0; + +constructor TTestProc.Create; +begin + inherited; + Inc(CUniqueID); + FUniqueID := CUniqueID; + FDisplayedName := Self.ClassName; + FEnabled := True; + + FSupportedIface := _Other; + if Supports(Self, ITestProject) then + FSupportedIface := _isTestProject + else + if Supports(Self, ITestDecorator) then + FSupportedIface := _isTestDecorator + else + if Supports(Self, ITestSuite) then + FSupportedIface := _isTestSuite + else + if Supports(Self, ITestCase) then + FSupportedIface := _isTestCase + else + if Supports(Self, ITestMethod) then + FSupportedIface := _isTestMethod +end; + +constructor TTestProc.Create(const AName: string); +begin + Create; + if AName <> '' then + FDisplayedName := AName; +end; + +constructor TTestProc.Create(const OwnerProc: TTestMethod; + const ParentPath: string; + const AMethod: TTestMethod; + const AMethodName: string); +begin + Create; + FMethod := AMethod; + {$IFNDEF CLR} + FErrorAddress := PtrType(@FMethod); + if Assigned(AMethod) then + {$ENDIF} + FMethodName := AMethodName; + FDisplayedName := FMethodName; + FIsTestMethod := IsValidTestMethod(OwnerProc); + FParentPath := ParentPath; +end; + +function TTestProc.CurrentTest: ITest; +begin + Result := Self; +end; + +destructor TTestProc.Destroy; +begin + FreeAndNil(FStatusMsgs); + FDisplayedName := ''; + FMethodName := ''; + FMethod := nil; + inherited; +end; + +{ DUnit compatibility interface } +{$IFDEF fpcunit} + {$I FPCUnitCompatibleInterface.inc} +{$ENDIF} + +function TTestProc.get_Depth: Integer; +begin + Result := FDepth; +end; + +procedure TTestProc.set_Depth(const Value: Integer); +begin + FDepth := Value; +end; + +function TTestProc.get_DisplayedName: string; +begin + Result := FDisplayedName; +end; + +procedure TTestProc.set_DisplayedName(const AName: string); +begin + FDisplayedName := AName; +end; + +// returns TestTime in seconds.millisecs +function TTestProc.ElapsedTestTime: Extended; +var + LTime: Extended; +begin + if FStopTime > 0 then + LTime := FStopTime + else if FStartTime > 0 then + LTime := gTimer.Elapsed + else + LTime := 0; + Result := LTime - FStartTime; +end; + +function TTestProc.get_Enabled: boolean; +begin + Result := FEnabled; +end; + +procedure TTestProc.set_Enabled(const Value: boolean); +begin + FEnabled := Value; +end; + +function TTestProc.get_Excluded: boolean; +begin + Result := FExcluded; +end; + +procedure TTestProc.set_Excluded(const Value: boolean); +begin + FExcluded := Value; +end; + +function TTestProc.get_ErrorAddress: PtrType; +begin + Result := FErrorAddress; +end; + +function TTestProc.get_ErrorMessage: string; +begin + Result := FErrorMessage; +end; + +procedure TTestProc.set_ErrorMessage(const Value: string); +begin + FErrorMessage := Value; +end; + +procedure TTestProc.InstallExecutionControl(const Value: ITestExecControl); +begin + FExecControl := Value; +end; + +function TTestProc.UniqueID: Cardinal; +begin + Result := FUniqueID; +end; + +function TTestProc.get_ExceptionClass: ExceptClass; +begin + Result := FExceptionIs; +end; + +function TTestProc.get_ExpectedException: ExceptClass; +begin + Result := FExpectedExcept; +end; + +function TTestProc.get_CheckCalled: boolean; +begin + Result := FCheckCalled; +end; + +procedure TTestProc.set_CheckCalled(const Value: boolean); +begin + FCheckCalled := Value; +end; + +function TTestProc.get_InhibitSummaryLevelChecks: boolean; +begin + Result := FInhibitSummaryLevelChecks; +end; + +procedure TTestProc.set_InhibitSummaryLevelChecks(const Value: boolean); +begin + FInhibitSummaryLevelChecks := Value; +end; + +function TTestProc.get_EarlyExit: boolean; +begin + Result := FEarlyExit; +end; + +function TTestProc.get_AllowedMemoryLeakSize: Integer; +// Array[0] reserved for property AllowedLeakSize and remainder for +// values entered by SetAllowedLeakArray +var + i: Integer; +begin + Result := FAllowedLeakList[0]; + if (result = 0) then + begin // The user may have set the values using SetAllowedLeakArray + for i := 0 to Length(FAllowedLeakList) - 1 do // Iterate + begin + if FAllowedLeakList[0] <> 0 then + begin + result := FAllowedLeakList[i]; + break; + end; + end; // for + end; +end; + +procedure TTestProc.set_AllowedMemoryLeakSize(const NewSize: Integer); +begin + FAllowedLeakList[0] := NewSize; +end; + +function TTestProc.get_FailsOnMemoryLeak: boolean; +begin + Result := FFailsOnMemoryLeak; +end; + +procedure TTestProc.set_FailsOnMemoryLeak(const Value: boolean); +begin + FFailsOnMemoryLeak := Value; +end; + +function TTestProc.GetAllowedLeak: Integer; +begin // Auto Iterator + if FAllowedLeakListIndex >= Length(FAllowedLeakList) then + Result := 0 + else + begin + Result := FAllowedLeakList[FAllowedLeakListIndex]; + Inc(FAllowedLeakListIndex); + end; +end; + +function TTestProc.get_AllowedLeaksIterator: TListIterator; +begin + FAllowedLeakListIndex := 0; + Result := GetAllowedLeak; +end; + +function TTestProc.get_IgnoresMemoryLeakInSetUpTearDown: boolean; +begin + Result := FIgnoresMemoryLeakInSetUpTearDown; +end; + +function TTestProc.get_LeakAllowed: boolean; +begin + Result := FLeakAllowed; +end; + +procedure TTestProc.set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); +begin + FIgnoresMemoryLeakInSetUpTearDown := Value; +end; + +procedure TTestProc.set_LeakAllowed(const Value: boolean); +begin + FLeakAllowed := Value; +end; + +procedure TTestProc.SetAllowedLeakArray(const AllowedList: array of Integer); +var + i: Integer; + LLen: Integer; +begin // Note the 0th element is reserved for old code value. + LLen := Length(AllowedList); + if LLen >= Length(FAllowedLeakList) then + Fail('Too many values in AllowedLeakArray. Limit = ' + + IntToStr(Length(FAllowedLeakList) - 1)); + + for i := 1 to Length(FAllowedLeakList) - 1 do + begin + if i <= LLen then + FAllowedLeakList[i] := AllowedList[i-1] + else + FAllowedLeakList[i] := 0; + end; +end; + +function TTestProc.get_FailsOnNoChecksExecuted: boolean; +begin + Result := FFailsOnNoChecksExecuted; +end; + +function TTestProc.get_ParentPath: string; +begin + Result := FParentPath; +end; + +function TTestProc.get_ParentTestCase: ITestCase; +begin + Result := ITestCase(FParent); +end; + +procedure TTestProc.set_ParentTestCase(const TestCase: ITestCase); +begin + FParent := Pointer(TestCase); +end; + +procedure TTestProc.set_ParentPath(const AName: string); +begin + FParentPath := AName; +end; + +function TTestProc.get_ProjectID: Integer; +begin + Result := FProjectID; +end; + +procedure TTestProc.set_ProjectID(const ID: Integer); +begin + FProjectID := ID; +end; + +function TTestProc.get_Proxy: IInterface; +begin + Result := IInterface(FProxy); +end; + +procedure TTestProc.set_Proxy(const AProxy: IInterface); +begin + FProxy := Pointer(AProxy); +end; + +function TTestProc.GetName: string; +begin + Result := FDisplayedName; +end; + +function TTestProc.GetStatus: string; +begin + Result := ''; + if Assigned(FStatusMsgs) then + Result := FStatusMsgs.Text; +end; + +procedure TTestProc.Status(const Value: string); +begin + if FStatusMsgs = nil then + FStatusMsgs := TStringList.Create; + FStatusMsgs.Add(Value); + if Assigned(FExecControl.StatusMsgUpdater) then + FExecControl.StatusMsgUpdater(Self, Value); +end; + +function TTestProc.get_TestSetUpData: ITestSetUpData; +begin + Result := FTestSetUpData; +end; + +procedure TTestProc.set_ElapsedTime(const Value: Extended); +begin + FElapsedTime := Value; +end; + +procedure TTestProc.SaveConfiguration(const iniFile: TCustomIniFile; + const Section: string); + + procedure DeleteIfEmpty(ASection: string); + var + LKeys: TStringList; + begin + LKeys := TStringList.Create; + try + iniFile.deleteKey(ASection, DisplayedName); + iniFile.ReadSection(ASection, LKeys); + if LKeys.Count = 0 then + iniFile.EraseSection(ASection); + finally + FreeAndNil(LKeys); + end; + end; + +begin + if Section = '' then + Exit; + if Enabled then + DeleteIfEmpty(Section) + else + iniFile.writeBool(Section, DisplayedName, False); + + if Excluded then + iniFile.writeBool(csExcluded + Section, DisplayedName, False) + else + DeleteIfEmpty(csExcluded + Section); +end; + +procedure TTestProc.LoadConfiguration(const iniFile: TCustomIniFile; + const Section: string); +begin + self.set_Enabled(iniFile.readBool(Section, self.DisplayedName, True)); + self.set_Excluded(not iniFile.readBool(csExcluded + Section, self.DisplayedName, True)); +end; + +procedure TTestProc.set_ErrorAddress(const Value: PtrType); +begin + FErrorAddress := Value; +end; + +procedure TTestProc.set_ExceptionClass(const Value: ExceptClass); +begin + FExceptionIs := Value; +end; + +procedure TTestProc.set_FailsOnNoChecksExecuted(const Value: boolean); +begin + FFailsOnNoChecksExecuted := Value; +end; + +procedure TTestCase.Status(const Value: string); +begin + if Assigned(FExecControl.CurrentTest) then + FExecControl.CurrentTest.Status(Value); +end; + +function TTestCase.GetStatus: string; +begin + Result := ''; + if Assigned(FExecControl.CurrentTest) then + Result := FExecControl.CurrentTest.GetStatus; +end; + +procedure TTestProc.set_TestSetUpData(const IsTestSetUpData: ITestSetUpData); +begin + FTestSetUpData := IsTestSetUpData; +end; + +{$IFNDEF FPC} +function IsBadPointer(const P: Pointer):boolean; register; +begin + try + Result := (P = nil) or + ((Pointer(P^) <> P) and (Pointer(P^) = P)); + except + Result := true; + end +end; + +{$WARN SYMBOL_PLATFORM OFF} +function RtlCaptureStackBackTrace(FramesToSkip: ULONG; FramesToCapture: ULONG; + out BackTrace: Pointer; BackTraceHash: PULONG): USHORT; stdcall; + external 'kernel32.dll' name 'RtlCaptureStackBackTrace' delayed; +{$WARN SYMBOL_PLATFORM ON} + +// 32-bit and 64-bit compatible +// Source: http://stackoverflow.com/questions/12022862/what-does-dunit2s-calleraddr-function-do-and-how-do-i-convert-it-to-64-bits +function CallerAddr: Pointer; +begin + // Skip 2 Frames, one for the return of CallerAddr and one for the + // return of RtlCaptureStackBackTrace + if RtlCaptureStackBackTrace(2, 1, Result, nil) > 0 then + begin + if not IsBadPointer(Result) then + Result := Pointer(NativeInt(Result) - 5) + else + Result := nil; + end + else + begin + Result := nil; + end; +end; +{$ELSE} +// FPC has a cross-platform implementation for this. +function CallerAddr: Pointer; +var + bp: Pointer; +begin + bp := get_caller_frame(get_frame); + if bp <> nil then + Result := get_caller_addr(bp) + else + Result := nil; +end; + +{$ENDIF} + +function TTestProc.get_ExecStatus: TExecutionStatus; +begin + Result := FExecStatus; +end; + +procedure TTestProc.set_ExecStatus(const Value: TExecutionStatus); +begin + if (Ord(Value) > Ord(FExecStatus)) or (Value = _Ready) then + begin + FExecStatus := Value; + if Assigned(FExecControl) and Assigned(FExecControl.ExecStatusUpdater) then + FExecControl.ExecStatusUpdater(Self); + if (Value = _Ready) then // We are starting a new exection run + FreeAndNil(FStatusMsgs); + end; +end; + +procedure TTestProc.StartExpectingException(e: ExceptClass); +begin + StopExpectingException; + FExpectedExcept := e; +end; + +procedure TTestProc.StopExpectingException(const ErrorMsg: string); +begin + if FExpectedExcept <> nil then + try + Fail(Format('Expected exception "%s" but there was none. %s', + [FExpectedExcept.ClassName, ErrorMsg]), CallerAddr); + finally + FExpectedExcept := nil; + end; +end; + +function TTestProc.SupportedIfaceType: TSupportedIface; +begin + Result := FSupportedIface; +end; + +function TTestProc.InterfaceSupports(const Value: TSupportedIface): Boolean; +begin + Result := (Ord(SupportedIfaceType) >= Ord(Value)); +end; + +function TTestProc.IsValidTestMethod(const AProc: TTestMethod): boolean; +begin + Result := (FMethodName <> '') and + (TMethod(FMethod).Code <> nil) and + (TMethod(FMethod).Data = TMethod(AProc).Data); +end; + +function TTestProc.MethodsName: string; +begin + Result := FMethodName; +end; + +function TTestProc.MethodCode(const MethodsName: string): TTestMethod; +var + LMethod: TMethod; +begin + LMethod.Code := MethodAddress(MethodsName); + LMethod.Data := self; + Result := TTestMethod(LMethod); +end; + +function TTestProc.get_ElapsedTime: Extended; +begin + Result := FElapsedTime; +end; + +procedure TTestProc.InitializeRunState; +begin + FEarlyExit := False; + FCheckCalled := False; + FElapsedTime := 0; + FStartTime := 0; + FStopTime := 0; + FErrorMessage := ''; + FExceptionIs := nil; + FExpectedExcept := nil; +end; + +function TTestProc.IsTestMethod: boolean; +begin + Result := FIsTestMethod; +end; + +procedure TTestProc.BeginRun; +begin + ExecStatus := _Ready; +end; + +// The users test method is called from this function. +function TTestProc.Run(const CurrentTestCase: ITestCase; + const AMethodName: string; + const ExecControl: ITestExecControl): TExecutionStatus; +var + LMsg: string; + {$IFDEF USE_JEDI_JCL} + LTrackingStack: boolean; + {$ENDIF} +begin + InitializeRunState; + FExecControl := ExecControl; + ExecStatus := _Running; //Issue _Running state to listeners if not already set + try + ExecControl.ExecutionCount := ExecControl.ExecutionCount + 1; + CheckMethodIsNotEmpty(FMethod); + {$IFNDEF USE_JEDI_JCL} + try + {$ELSE} + LTrackingStack := JclExceptionTrackingActive; + try + {$IFNDEF CLR} + if (ExecControl.InhibitStackTrace or ExecControl.FailsOnMemoryLeak) then + JclStopExceptionTracking //Does nothing if already stopped + else + JclStartExceptionTracking; // Does nothing if already started. + {$ENDIF} + {$ENDIF} + // Clear here so state cannot be contrived by user in Setup + (CurrentTestCase as ITestCase).CheckCalled := False; + // Note. Processing in FMethod/RunTest occurs in context of + // Parent TTestCase, not in context of this ITest instance. + if IsTestMethod then + begin + FStartTime := gTimer.Elapsed; + FMethod; + end + else + begin + FStartTime := gTimer.Elapsed; + RunTest; + end; + finally + FStopTime := gTimer.Elapsed; + FElapsedTime := ElapsedTestTime; + end; + + // Arrive here when there are no unhandled exceptions in Method's code. + // If exception was expected but no exception occurred then fail the testproc. + FExpectedExcept := CurrentTestCase.ExpectedException; + StopExpectingException; + + // Get CheckCalled from Parent because method runs in context of TTestCase + if IsTestMethod then + begin + FCheckCalled := CurrentTestCase.CheckCalled; + ErrorMessage := CurrentTestCase.ErrorMessage; + end + else + CurrentTestCase.CheckCalled := FCheckCalled; + FailsOnNoChecksExecuted := CurrentTestCase.FailsOnNoChecksExecuted; + // Pass back the state after the method executed + Result := CheckMethodCalledCheck(ITestCase(FParent)); + if (Result = _Warning) then + ExecControl.WarningCount := ExecControl.WarningCount + 1 + else + if ErrorMessage <> '' then + begin + Result := _Failed; // CheckExit failed and passed through + ExecStatus := Result; + end; + + except // Handle execution exceptions here + on e: ECheckExit do + begin + FEarlyExit := True; + Result := _Passed; + end; + + on e: EStopTestsFailure do + begin + ExecStatus := UpdateOnFail(Self, _Stopped, e, PtrType(ExceptAddr)); + Result := ExecStatus; + end; + + on e: ETestFailure do + begin + ExecStatus := UpdateOnFail(Self, _Failed, e, PtrType(ExceptAddr)); + Result := ExecStatus; + end; + + on e: EBreakingTestFailure do + begin + ExecStatus := UpdateOnFail(Self, _Break, e, PtrType(ExceptAddr)); + Result := ExecStatus; + end; + + on e: Exception do + begin + //See if it was an expected exception, in which case the test does not fail + FExceptionIs := (CurrentTestCase as ITestCase).ExpectedException; + if E.ClassType.InheritsFrom(FExceptionIs) and + (FExceptionIs.ClassName = E.ClassName) then + begin + Result := _Passed; // Was the expected exception + FExpectedExcept := nil; + FExceptionIs := nil; + LMsg := ''; + end + else + begin + FExceptionIs := ExceptClass(e.ClassType); + LMsg := e.Message; // Unexpected exception + ExecStatus := UpdateOnError(Self, _Error, LMsg, e, PtrType(ExceptAddr)); + Result := ExecStatus; + end; + end; + end; +end; + +procedure TTestProc.RunTest; +begin +// Legacy dunit compatibility. +// Methodless TestProcs call this procedure which can invoke Fail(); +end; + +function TTestProc.UpdateOnError(const ATest: ITest; + const NewStatus: TExecutionStatus; + const ExceptnMsg: string; + const Excpt: Exception; + const Addrs: PtrType): TExecutionStatus; +begin + ATest.ErrorMessage := ExceptnMsg; + ATest.ErrorAddress := Addrs; + ATest.ExceptionClass := ExceptClass(Excpt.ClassType); + FExecControl.ErrorCount := FExecControl.ErrorCount + 1; + Result := NewStatus; // This just passes through +end; + +function TTestProc.UpdateOnFail(const ATest: ITest; + const NewStatus: TExecutionStatus; + const Excpt: Exception; + const Addrs: PtrType): TExecutionStatus; +begin + ATest.ErrorMessage := Excpt.Message; + ATest.ErrorAddress := Addrs; + ATest.ExceptionClass := ExceptClass(Excpt.ClassType); + if (NewStatus = _Stopped) or + (NewStatus = _Failed) or + (NewStatus = _Break) then + FExecControl.FailureCount := FExecControl.FailureCount + 1; + Result := NewStatus; // This just passes through +end; + +procedure TTestProc.Warn(const ErrorMsg: string; const ErrorAddress: Pointer); +begin + if ErrorAddress = nil then + raise EPostTestFailure.Create(ErrorMsg) at CallerAddr + else + raise EPostTestFailure.Create(ErrorMsg) at ErrorAddress; +end; + +procedure TTestProc.CheckMethodIsNotEmpty(const AMethod: TTestMethod); +const + AssemblerRet = $C3; +begin +{$IFNDEF CLR} + if (not Assigned(AMethod)) then + Exit; + if byte(TMethod(AMethod).Code^) = AssemblerRet then + Fail('Empty test', TMethod(AMethod).Code); +{$ENDIF} +end; + +function TTestProc.Count: Integer; +begin + Result := 1 +end; + +function TTestProc.CheckMethodCalledCheck(const ATest: ITest): TExecutionStatus; +begin + Result := _Passed; + if FCheckCalled then + Exit; + + if FailsOnNoChecksExecuted then + begin + PostFail('No checks executed in TestCase', TMethod(FMethod).Code); + end + else + begin + ErrorMessage := ATest.ErrorMessage; + if ErrorMessage = '' then + ErrorMessage := 'No checks executed in TestCase'; + ExceptionClass := ExceptClass(EPostTestWarning); + end; + + Result := _Warning; // Pass back warning to show check not called overridden +end; + +procedure TTestCase.EnumerateMethods; +var + i: Integer; + LNameOfMethod: string; + LMethod: TTestMethod; + LMethodEnumerator: TMethodEnumerator; + LTest: ITest; + LParentStr: string; +begin + LMethod := nil; + LMethodEnumerator := TMethodEnumerator.Create(Self.ClassType); + try + if LMethodEnumerator.MethodCount > 0 then + begin + for i := 0 to LMethodEnumerator.MethodCount-1 do + begin + LNameOfMethod := LMethodEnumerator.NameOfMethod[i]; + LMethod := MethodCode(LNameOfMethod); + Assert(Assigned(LMethod), 'Bad method address'); + LParentStr := ''; + if (FParentPath <> '') then + LParentStr := FParentPath + '.'; + LTest := TTestProc.Create(EnumerateMethods, LParentStr + + FDisplayedName, LMethod, LNameOfMethod); + Assert(LTest.IsTestMethod, 'Invalid test method'); + FTestIterator.AddTest(LTest); + end; + end; + finally + LMethodEnumerator.free; + end; +end; + +constructor TTestCase.Create; +begin + inherited Create; + FTestIterator := TTestIterator.Create; + EnumerateMethods; +end; + +constructor TTestCase.Create(const AProcName: string); +var + LTest: ITest; +begin + Create; + repeat + LTest := FTestIterator.FindNextTest; + if Assigned(LTest) then + LTest.Enabled := (LTest.DisplayedName = AProcName) or (AProcName = ''); + until (LTest = nil); +end; + +function TTestCase.CurrentTest: ITest; +begin + Result := FTestIterator.CurrentTest; + if result = nil then + Exit; + + // Recurse into lower levels + if not Result.IsTestMethod then + Result := Result.CurrentTest; + if Result = nil then + Result := self; +end; + +procedure TTestProc.Invoke(AMethod: TExceptTestMethod); +begin + AMethod; +end; + +function TTestCase.Count: Integer; +var + LTest: ITest; +begin + Result := 0; + FTestIterator.Reset; + repeat + LTest := FTestIterator.FindNextEnabledProc; + if (LTest <> nil) then + begin + LTest.Depth := Depth + 1; + if not LTest.Excluded then + Result := Result + LTest.Count; + end; + until (LTest = nil); +end; + +// Deprecated, backwards compatibility use only +function TTestCase.CountTestCases: Integer; +begin + Result := Count; +end; + +procedure TTestCase.AddTest(const ATest: ITest); +begin + if Assigned(ATest) then + begin + ATest.Depth := Self.Depth + 1; + FTestIterator.AddTest(ATest); + if ParentPath <> '' then + ATest.ParentPath := ParentPath + '.' + DisplayedName + else + ATest.ParentPath := DisplayedName; + // Reset required because setting parentpath screws with the iterator index + Reset; + end; +end; + +procedure TTestCase.AddSuite(const ATest: ITest); +begin + AddTest(ATest); +end; + +class function TTestCase.Suite: ITestCase; +begin + Result := Self.Create; +end; + +destructor TTestCase.Destroy; +begin + FTestIterator := nil; + FMethod := nil; + inherited; +end; + +procedure TTestCase.set_ParentPath(const AName: string); +var + LTest: ITest; +begin + if FParentPath <> AName then + begin + FParentPath := AName; + // Now propogate addition to ParentPath to subordinate test methods. + FTestIterator.Reset; + LTest := FTestIterator.FindNextTest; + while Assigned(LTest) do + begin + if FParentPath = '' then + LTest.ParentPath := DisplayedName + else + LTest.ParentPath := FParentPath + '.' + DisplayedName; + LTest := FTestIterator.FindNextTest; + end; + end; +end; + +function TTestCase.get_ProgressSummary: IInterface; +begin + Result := FProgressSummary; +end; + +procedure TTestCase.set_DisplayedName(const AName: string); +var + LTest: ITest; +begin + if FDisplayedName <> AName then + begin + FDisplayedName := AName; + FTestIterator.Reset; + LTest := FTestIterator.FindNextTest; + while Assigned(LTest) do + begin + if ParentPath = '' then + LTest.ParentPath := AName + else + LTest.ParentPath := FParentPath + '.' + FDisplayedName; + LTest := FTestIterator.FindNextTest; + end; + end; +end; + +procedure TTestCase.Reset; +begin + FTestIterator.Reset; +end; + +function TTestCase.PriorTest: ITest; +begin + Result := FTestIterator.PriorTest; +end; + +function TTestProc.PtrToStr(const P: Pointer): string; +begin + Result := Format('%p', [P]) +end; + +procedure TTestCase.BeginRun; +var + LTest: ITest; +begin + inherited; + LTest := FTestIterator.FindFirstTest; + while Assigned(LTest) do + begin + if LTest.Enabled then + LTest.BeginRun; + LTest := FTestIterator.FindNextTest; + end; +end; + +procedure TTestCase.ReleaseProxys; +var + LTest: ITest; +begin + Proxy := nil; + LTest := FTestIterator.FindFirstTest; + while Assigned(LTest) do + begin + if LTest.IsTestMethod then + LTest.Proxy := nil + else + (LTest as ITestCase).ReleaseProxys; + LTest := FTestIterator.FindNextTest; + end; +end; + +function TTestCase.get_ReEntering: Boolean; +begin + Result := FReEntering; + FReEntering := False; +end; + +procedure TTestCase.set_ReEntering(const Value: Boolean); +begin + FReEntering := Value; +end; + +function TTestCase.get_ReportErrorOnce: boolean; +begin + Result := FReportErrorOnce; + FReportErrorOnce := False; +end; + +procedure TTestCase.InhibitStackTrace(const Value: boolean); +begin + FExecControl.InhibitStackTrace := Value; +end; + +procedure TTestCase.InhibitStackTrace; +begin + FExecControl.InhibitStackTrace := True; +end; + +procedure TTestCase.set_ReportErrorOnce(const Value: boolean); +begin + FReportErrorOnce := Value; +end; + +// Called once before executing all test procedures in class +procedure TTestCase.SetUpOnce; +begin +// Empty but required in case called via inheritance +end; + +// Called once before executing each test procedures in class +procedure TTestCase.Setup; +begin +// Empty but required in case called via inheritance +end; + +function TTestCase.Run(const ExecControl: ITestExecControl): TExecutionStatus; +var + LStartTime: Extended; + LMemUseComparitor: IMemUseComparator; + + function ExecuteTestMethod(const ATest: ITest): TExecutionStatus; + var + LErrors : Integer; + begin + Result := ExecStatus; + LErrors := ExecControl.ErrorCount; // Hold count so we only bump it once + FErrorMessage := ''; + ATest.ParentTestCase := self; + + try + TestSetUpData := ExecControl.TestSetUpData; + ATest.ExecStatus := _Running; + FailsOnNoChecksExecuted := ExecControl.FailsOnNoChecksExecuted; + + try + LMemUseComparitor.RunSetup(SetUp); + // Now run the test method + Result := (ATest as ITestMethod).Run(Self, ATest.MethodsName, ExecControl); + try + LMemUseComparitor.RunTearDown(TearDown); + except + on E:Exception do + Result := UpdateOnError(ATest, _Error, 'TearDown failed: ' + E.Message, E, PtrType(ExceptAddr)); + end; + except + on E:Exception do + Result := UpdateOnError(ATest, _Error, 'SetUp failed: ' + E.Message, E, PtrType(ExceptAddr)); + end; + finally + if ExecControl.ErrorCount > LErrors then + ExecControl.ErrorCount := LErrors + 1 + else + Result := LMemUseComparitor.AlertOnMemoryLoss(Result); + end; + + ATest.ExecStatus := Result; + ATest.ErrorMessage := ''; + FExpectedExcept := nil; + ExecControl.CurrentTest := nil; + FTestSetUpData := nil; + ATest.ParentTestCase := nil; + end; + + function RunAsTestCase(const ATest: ITestCase): TExecutionStatus; + var + LExecStatus: TExecutionStatus; + begin + FStartTime := gTimer.Elapsed; + Result := ATest.ExecStatus; + + try + SetUp; + ATest.ReEntering := True; + Result := ATest.Run(ExecControl); // Run the testcase + try + TearDown; + except + on E:Exception do + begin + (ATest as ITestCase).ReportErrorOnce := True; + LExecStatus := UpdateOnError(ATest, _Error, 'TearDown failed: ' + + E.Message, E, PtrType(ExceptAddr)); + Result := TExecutionStatus(Max(ord(LExecStatus), Ord(Result))); + end; + end; + except + on E:Exception do + begin + ATest.ExecStatus := _Running; + (ATest as ITestCase).ReportErrorOnce := True; + LExecStatus := UpdateOnError(ATest, _Error, 'SetUp failed: ' + + E.Message, E, PtrType(ExceptAddr)); + Result := TExecutionStatus(Max(ord(LExecStatus), Ord(Result))); + end; + end; + + FStopTime := gTimer.Elapsed; + ATest.ElapsedTime := ElapsedTestTime; + ATest.ExecStatus := Result; + end; + +var + LLExecStatus: TExecutionStatus; + LTest: ITest; +begin {TTestCase.Run(const ExecControl: ITestExecControl): TExecutionStatus;} + FExecControl := ExecControl; + FTestSetUpData := ExecControl.TestSetUpData; + FProgressSummary := TProgressSummary.Create(ExecControl); + {$IFDEF FASTMM} + LMemUseComparitor := TMemUseComparator.Create(Self, ExecControl); + {$ELSE} + LMemUseComparitor := TBaseMemUseComparator.Create(Self, ExecControl); + {$ENDIF} + + LStartTime := gTimer.Elapsed; + FTestIterator.Reset; + InitializeRunState; + if not ReEntering then + FExecStatus := _Ready; // Pre-set status + ExecStatus := _Running; // Notify listeners + Result := ExecStatus; + LLExecStatus := ExecStatus; // Holds status until it needs to be propogated + try + SetUpOnce; + repeat + if (not ExecControl.TestCanRun or ExecControl.HaltExecution) then + Result := TExecutionStatus(Max(ord(_HaltTest), Ord(Result))) + else + begin + LTest := FTestIterator.FindNextEnabledProc; + ExecControl.CurrentTest := LTest; + if (LTest <> nil) then + begin + if LTest.Excluded then + ExecControl.ExcludedCount := ExecControl.ExcludedCount + 1; + if (not Assigned(ExecControl.IndividuallyEnabledTest) or + ExecControl.IndividuallyEnabledTest(LTest)) then + begin + LTest.InstallExecutionControl(ExecControl); + if LTest.SupportedIfaceType = _isTestMethod then + LLExecStatus := ExecuteTestMethod(LTest) + else + LLExecStatus := RunAsTestCase(LTest as ITestCase); + end; + Result := TExecutionStatus(Max(ord(LLExecStatus), Ord(Result))); + end; + end; + until ((LTest = nil) or + (ExecControl.BreakOnFailures and ((Result = _Error) or (Result = _Failed)) or + (Result = _HaltTest) or + (Result = _Stopped) or + (Result = _Break) or + ExecControl.HaltExecution)); + + try + TearDownOnce; + except // Catch exception in TearDownOnce and report + on E:Exception do + begin + FReportErrorOnce := True; + LLExecStatus := UpdateOnError(Self, _Error, 'TearDownOnce failed: '+ + E.Message, E, PtrType(ExceptAddr)); + Result := TExecutionStatus(Max(ord(LLExecStatus), Ord(Result))); + end; + end; + + except // Catch exception in SetUpOnce and report + on E:Exception do + begin + ReportErrorOnce := True; + LLExecStatus := UpdateOnError(Self, _Error, 'SetUpOnce failed: ' + + E.Message, E, PtrType(ExceptAddr)); + Result := TExecutionStatus(Max(ord(LLExecStatus), Ord(Result))); + end; + end; + + FStartTime := LStartTime; + FStopTime := gTimer.Elapsed; + ElapsedTime := ElapsedTestTime; + + (FProgressSummary as IProgressSummary).UpdateSummary(ExecControl); + ExecStatus := Result; // Report status to listeners + + // Let the world know we are finished with these + LMemUseComparitor := nil; + FTestSetUpData := nil; + FProgressSummary := nil; +end; + +// Called after executing each test method in class +procedure TTestCase.TearDown; +begin +// Empty but required in case called via inheritance +end; + +// Called once after executing all tests procedures in class. +procedure TTestCase.TearDownOnce; +begin +// Empty but required in case called via inheritance +end; + +function ByteAt(P: pointer; const Offset: Integer): byte; +begin + Result:=pByte(PtrUInt(P)+Offset)^; +end; + +function FirstByteDiff(p1, p2: pointer; size: longword; out b1, b2: byte): Integer; +// Returns offset of first byte pair (left to right, incrementing address) that is unequal +// Returns -1 if no difference found, or if size=0 +var + i: Integer; +begin + Result := -1; + if size > 0 then + for i := 0 to size-1 do // Subject to optimisation for sure: + if ByteAt(p1,i)<>ByteAt(p2,i) then + begin + Result := i; + b1 :=ByteAt(p1,i); + b2 :=ByteAt(p2,i); + break; + end; +end; + +function TTestProc.GetMemDiffStr(const expected, actual: pointer; const size: longword; + const ErrorMsg: string): string; +var + Ldb1, Ldb2: byte; + LOffset: Integer; +begin + LOffset := FirstByteDiff(expected, actual, size, Ldb1, Ldb2); + Result := NotEqualsErrorMessage(IntToHex(Ldb1,2),IntToHex(Ldb2,2), ErrorMsg); + Result := Result + ' at offset = ' + IntToHex(LOffset,4) + 'h'; +end; + +function TTestCase.GetName: string; +var + LTest: ITest; +begin + Result := FDisplayedName; + LTest := CurrentTest; + if not Assigned(LTest) or (LTest.UniqueID = Self.UniqueID) then + Exit; + + Result := LTest.GetName +end; + +function TTestCase.FindNextEnabledProc: ITest; +begin + Result := FTestIterator.FindNextEnabledProc; +end; + +procedure TTestCase.SaveConfiguration(const iniFile: TCustomIniFile; + const Section: string); +var + LTestSection: string; + LTest: ITest; +begin + inherited SaveConfiguration(iniFile, Section); + FTestIterator.Reset; + LTestSection := Section + '.' + Self.DisplayedName; + repeat + LTest := FTestIterator.FindNextTest; + if (LTest <> nil) then + LTest.SaveConfiguration(iniFile, LTestSection); + until (LTest = nil); +end; + +procedure TTestCase.LoadConfiguration(const iniFile: TCustomIniFile; + const Section: string); +var + LTest: ITest; + LTestSection: string; +begin + inherited LoadConfiguration(iniFile, Section); + FTestIterator.Reset; + LTestSection := Section + '.' + Self.DisplayedName; + LTest := FTestIterator.FindNextTest; + while LTest <> nil do + begin + LTest.LoadConfiguration(iniFile, LTestSection); + LTest := FTestIterator.FindNextTest; + end; +end; + +{---------- helper functions ------------} +function TTestProc.EqualsErrorMessage(const expected, actual: UnicodeString; + const ErrorMsg: string): UnicodeString; +begin + if (ErrorMsg <> '') then + Result := Format(sMsgActualEqualsExpFmt, [ErrorMsg + ', ', expected, actual]) + else + Result := Format(sActualEqualsExpFmt, [expected, actual]) +end; + +function TTestProc.NotEqualsErrorMessage(const expected, actual: UnicodeString; + const ErrorMsg: string): UnicodeString; +begin + if (ErrorMsg <> '') then + Result := Format(sExpectedButWasAndMessageFmt, [ErrorMsg, expected, actual]) + else + Result := Format(sExpectedButWasFmt, [expected, actual]); +end; + +{--------- Fail exception generation ---------} +procedure TTestProc.Fail(const ErrorMsg: string; const ErrorAddress: Pointer); +begin +// raise ETestFailure.Create(ErrorMsg); + if ErrorAddress = nil then + raise ETestFailure.Create(ErrorMsg) at CallerAddr + else + raise ETestFailure.Create(ErrorMsg) at ErrorAddress; +end; + +procedure TTestProc.PostFail(const ErrorMsg: string; const ErrorAddress: Pointer); +begin + if ErrorAddress = nil then + raise EPostTestFailure.Create(ErrorMsg) at CallerAddr + else + raise EPostTestFailure.Create(ErrorMsg) at ErrorAddress; +end; + +procedure TTestProc.FailEquals(const expected, actual: UnicodeString; + const ErrorMsg: string; + ErrorAddrs: Pointer); +begin + Fail(EqualsErrorMessage(expected, actual, ErrorMsg), ErrorAddrs); +end; + +procedure TTestProc.FailNotEquals(const expected, actual: UnicodeString; + const ErrorMsg: string; + ErrorAddrs: Pointer); +begin + Fail(NotEqualsErrorMessage(expected, actual, ErrorMsg), ErrorAddrs); +end; + +procedure TTestProc.FailNotSame(const expected, actual: UnicodeString; + const ErrorMsg: string; + ErrorAddrs: Pointer); +begin + Fail(NotEqualsErrorMessage(expected, actual, ErrorMsg), ErrorAddrs); +end; + +procedure TTestProc.OnCheckCalled; +begin + FCheckCalled := True; + if Assigned(FExecControl) then + FExecControl.CheckCalledCount := 1; +end; + +{-------------Checks---------------} +function IntToBin(const Value, digits: longword): string; +const + ALL_32_BIT_0 = '00000000000000000000000000000000'; +var + LCounter: Integer; + Lpow: Integer; +begin + Result := ALL_32_BIT_0; + SetLength(Result, digits); + Lpow := 1 shl (digits - 1); + if Value <> 0 then + for LCounter := 0 to digits - 1 do + begin + if (Value and (Lpow shr LCounter)) <> 0 then + Result[LCounter+1] := '1'; + end; +end; + +procedure TTestProc.Check(const condition: boolean; const ErrorMsg: string); +begin + OnCheckCalled; + if (not condition) then + Fail(ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckTrue(const condition: boolean; const ErrorMsg: string); +begin + OnCheckCalled; + if (not condition) then + FailNotEquals(BoolToStr(true, true), BoolToStr(false, true), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckFalse(const condition: boolean; const ErrorMsg: string); +begin + OnCheckCalled; + if (condition) then + FailNotEquals(BoolToStr(false, true), BoolToStr(true, true), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEquals(const expected, actual: int64; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected <> actual) then + FailNotEquals(IntToStr(expected), IntToStr(actual), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotEquals(const expected, actual: int64; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected = actual) then + FailEquals(IntToStr(expected), IntToStr(actual), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEquals(const expected, actual: extended; + const ErrorMsg: string); +begin + CheckEquals(expected, actual, 0, ErrorMsg); +end; + +procedure TTestProc.CheckEquals(const expected, actual: extended; + const delta: extended; const ErrorMsg: string); +begin + OnCheckCalled; + if (abs(expected-actual) > delta) then + FailNotEquals(FloatToStr(expected), FloatToStr(actual), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEquals(const expected, actual: string; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected <> actual then + FailNotEquals(expected, actual, ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEqualsString(const expected, actual: string; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected <> actual then + FailNotEquals(expected, actual, ErrorMsg, CallerAddr); +end; + +{$IFNDEF UNICODE} +procedure TTestProc.CheckEquals(const expected, actual: UnicodeString; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected <> actual then + FailNotEquals(expected, actual, ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEqualsMem(const expected, actual: pointer; + const size: longword; const ErrorMsg: string); +begin + OnCheckCalled; + if not CompareMem(expected, actual, size) then + Fail(GetMemDiffStr(expected, actual, size, ErrorMsg), CallerAddr); +end; + +procedure TTestProc.CheckNotEquals(const expected, actual: UnicodeString; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected = actual then + FailEquals(expected, actual, ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotEqualsMem(const expected, actual: pointer; + const size: longword; const ErrorMsg: string); +begin + OnCheckCalled; + if CompareMem(expected, actual, size) then + begin + if (ErrorMsg <> '') then + Fail(ErrorMsg + ', ' + 'Memory content was identical', CallerAddr) + else + Fail(ErrorMsg + 'Memory content was identical', CallerAddr) + end; +end; +{$ENDIF} + +procedure TTestProc.CheckEqualsUnicodeString(const expected, actual: UnicodeString; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected <> actual then + FailNotEquals(expected, actual, ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotEqualsUnicodeString(const expected, actual: UnicodeString; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected = actual then + FailEquals(expected, actual, ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEquals(const expected, actual: boolean; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected <> actual) then + FailNotEquals(BoolToStr(expected, true), BoolToStr(actual, true), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEqualsBin(const expected, actual: longword; + const ErrorMsg: string; + const digits: Integer); +begin + OnCheckCalled; + if expected <> actual then + FailNotEquals(IntToBin(expected, digits), IntToBin(actual, digits), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEqualsHex(const expected, actual: longword; + const ErrorMsg: string; + const digits: Integer); +begin + OnCheckCalled; + if expected <> actual then + FailNotEquals(IntToHex(expected, digits), IntToHex(actual, digits), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotEquals(const expected, actual: extended; + const delta: extended; + const ErrorMsg: string); +begin + OnCheckCalled; + if (abs(expected-actual) <= delta) then + FailEquals(FloatToStr(expected), FloatToStr(actual), ErrorMsg, CallerAddr); +end; + +{$IFNDEF VER130} +procedure TTestProc.CheckNotEquals(const expected, actual: string; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected = actual then + FailEquals(expected, actual, ErrorMsg, CallerAddr); +end; +{$ENDIF} + +procedure TTestProc.CheckNotEqualsString(const expected, actual: string; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected = actual then + FailEquals(expected, actual, ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotEquals(const expected, actual: boolean; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected = actual) then + FailEquals(BoolToStr(expected, true), BoolToStr(actual, true), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckEquals(const expected, actual: integer; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected <> actual) then + FailNotEquals(IntToStr(expected), IntToStr(actual), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotEquals(const expected, actual: integer; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected = actual) then + FailEquals(IntToStr(expected), IntToStr(actual), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotEqualsBin(const expected, actual: longword; + const ErrorMsg: string; + const digits: Integer); +begin + OnCheckCalled; + if (expected = actual) then + FailEquals(IntToBin(expected, digits), IntToBin(actual, digits), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotEqualsHex(const expected, actual: longword; + const ErrorMsg: string; + const digits: Integer); +begin + OnCheckCalled; + if (expected = actual) then + FailEquals(IntToHex(expected, digits), IntToHex(actual, digits), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotNull(const obj: IInterface; const ErrorMsg: string); +begin + OnCheckCalled; + if obj = nil then + Fail(ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNull(const obj: IInterface; const ErrorMsg: string); +begin + OnCheckCalled; + if obj <> nil then + Fail(ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckSame(const expected, actual: IInterface; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected <> actual) then + FailNotEquals(PtrToStr(Pointer(expected)), PtrToStr(Pointer(actual)), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotSame(const expected, actual: IInterface; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected = actual) then + FailEquals(PtrToStr(Pointer(expected)), PtrToStr(Pointer(actual)), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckSame(const expected, actual: TObject; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected <> actual) then + FailNotEquals(PtrToStr(Pointer(expected)), PtrToStr(Pointer(actual)), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotSame(const expected, actual: TObject; + const ErrorMsg: string); +begin + OnCheckCalled; + if (expected = actual) then + FailEquals(PtrToStr(Pointer(expected)), PtrToStr(Pointer(actual)), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotNull(const obj: TObject; const ErrorMsg: string); +begin + OnCheckCalled; + if obj = nil then + FailNotEquals('object', PtrToStr(Pointer(obj)), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNull(const obj: TObject; const ErrorMsg: string); +begin + OnCheckCalled; + if obj <> nil then + FailEquals('nil', PtrToStr(Pointer(obj)), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNotNull(const obj: Pointer; const ErrorMsg: string); +begin + OnCheckCalled; + if obj = nil then + FailNotEquals('pointer', PtrToStr(obj), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckNull(const obj: Pointer; const ErrorMsg: string); +begin + OnCheckCalled; + if obj <> nil then + FailEquals('nil', PtrToStr(obj), ErrorMsg, CallerAddr); +end; + +procedure TTestProc.CheckException(const AMethod: TExceptTestMethod; + const AExceptionClass: TClass; + const ErrorMsg: string); +var + LExceptionClass: TClass; +begin + LExceptionClass := AExceptionClass; + try + Invoke(AMethod); + except + on E:Exception do + begin + OnCheckCalled; + if not Assigned(LExceptionClass) then + raise + else if not e.ClassType.InheritsFrom(LExceptionClass) then + FailNotEquals(AExceptionClass.ClassName, e.ClassName, ErrorMsg, CallerAddr) + else + LExceptionClass := nil; + end; + end; + if Assigned(LExceptionClass) then + FailNotEquals(AExceptionClass.ClassName, 'nothing', ErrorMsg, CallerAddr) +end; + +procedure TTestProc.EarlyExitCheck(const condition: boolean; const ErrorMsg: string); +begin + if FExecControl.InhibitSummaryLevelChecks then + begin + Check(condition, ErrorMsg); + Exit; + end; + + FExecControl.CheckCalledCount := FExecControl.CheckCalledCount + 1; + if condition then + raise ECheckExit.Create(''); + + // Note we fall through to here if the test failed. + if ErrorMessage = '' then + ErrorMessage := ErrorMsg + else + ErrorMessage := ErrorMessage + '.' + ErrorMsg +end; + +procedure TTestProc.CheckEquals(const expected, actual: TClass; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected <> actual then + begin + if expected = nil then + FailNotEquals('nil', actual.ClassName, ErrorMsg, CallerAddr) + else if actual = nil then + FailNotEquals(expected.ClassName, 'nil', ErrorMsg, CallerAddr) + else + FailNotEquals(expected.ClassName, actual.ClassName, ErrorMsg, CallerAddr) + end; +end; + +procedure TTestProc.CheckNotEquals(const expected, actual: TClass; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected = nil then + FailNotEquals('nil', '', ErrorMsg, CallerAddr) + else if actual = nil then + FailNotEquals('', 'nil', ErrorMsg, CallerAddr) + else + if expected = actual then + FailNotEquals(expected.ClassName, actual.ClassName, ErrorMsg, CallerAddr) +end; + +procedure TTestProc.CheckNotEquals(const expected, actual: extended; + const ErrorMsg: string); +begin + // TODO: This is not going to report correct calling error address + CheckNotEquals(expected, actual, 0, ErrorMsg); +end; + +procedure TTestProc.CheckInherits(const expected, actual: TClass; + const ErrorMsg: string); +begin + OnCheckCalled; + if expected = nil then + FailNotEquals('nil', actual.ClassName, ErrorMsg, CallerAddr) + else if actual = nil then + FailNotEquals(expected.ClassName, 'nil', ErrorMsg, CallerAddr) + else if not actual.InheritsFrom(expected) then + FailNotEquals(expected.ClassName, actual.ClassName, ErrorMsg, CallerAddr) +end; + +procedure TTestProc.CheckIs(const AObject: TObject; + const AClass: TClass; + const ErrorMsg: string); +begin + OnCheckCalled; + if AClass= nil then + FailNotEquals(Self.ClassName, 'nil', ErrorMsg, CallerAddr); + if AObject = nil then + FailNotEquals(AClass.ClassName, 'nil', ErrorMsg, CallerAddr) + else if not AObject.ClassType.InheritsFrom(AClass) then + FailNotEquals(AClass.ClassName, AObject.ClassName, ErrorMsg, CallerAddr) +end; + +procedure TTestCase.StopTests(const ErrorMsg: string); +begin + OnCheckCalled; // This line is questionable. + raise EStopTestsFailure.Create('Testing Stopped: ' + ErrorMsg); +end; + + +{ TTestSuite } + +constructor TTestSuite.Create(const ASuiteName: string); +begin + Create; + if ASuiteName <> '' then + FDisplayedName := ASuiteName; +end; + +class function TTestSuite.Suite(const ASuiteName: string): ITestSuite; +begin + Result := Self.Create; + if ASuiteName <> '' then + Result.DisplayedName := ASuiteName; +end; + +class function TTestSuite.Suite(const ASuiteName: string; + const ATestCase: ITestCase): ITestSuite; +begin + Result := Self.Create(ASuiteName); + Result.AddTest('', ATestCase); +end; + +class function TTestSuite.Suite(const ASuiteName: string; + const TestCases: array of ITestCase): ITestSuite; +begin + Result := Self.Create(ASuiteName); + Result.AddTest('', TestCases); +end; + +procedure TTestSuite.AddTest(const SuiteTitle: string; + const ASuite: ITestCase); +begin + if Assigned(ASuite) then + begin + if SuiteTitle <> '' then + ASuite.DisplayedName := SuiteTitle; + inherited AddTest(ASuite); + end; +end; + +procedure TTestSuite.AddTest(const SuiteTitle: string; + const Suites: array of ITestCase); +var + idx: Integer; +begin + if SuiteTitle <> '' then + DisplayedName := SuiteTitle; + for idx := 0 to Length(Suites) - 1 do + begin + AddTest(Suites[idx]); + end; +end; + +function TTestSuite.FindNextEnabledProc: ITest; +var + LTest: ITest; +begin + Result := nil; + repeat + LTest := FTestIterator.FindNextEnabledProc; + if Assigned(LTest) then + begin + if (LTest.SupportedIfaceType = _isTestMethod) then + Result := LTest + else + begin + Result := (LTest as ITestCase).FindNextEnabledProc; + if Assigned(Result) then + FTestIterator.PriorTest; + end; + end; + until (Assigned(Result) or (LTest = nil)); +end; + +function TTestSuite.TestIterator: IReadOnlyIterator; +begin + Result := FTestIterator; +end; + +function TTestSuite.PriorTest: ITest; +var + LTest : ITest; +begin + Result := FTestIterator.PriorTest; + if Assigned(Result) then + begin + if Result.InterfaceSupports(_isTestCase) then + begin + LTest := (Result as ITestCase).PriorTest; + if Assigned(LTest) then + begin // Hold current entry while tests are valid + FTestIterator.FindNextTest; + Result := LTest; + end; + end; + end; +end; + +procedure TTestSuite.Reset; +var + LTest: ITest; +begin + LTest := FTestIterator.FindFirstTest; + while Assigned(LTest) do + begin + LTest := FTestIterator.FindNextTest; + if Assigned(LTest) and LTest.InterfaceSupports(_isTestCase) then + (LTest as ITestCase).Reset; + end; + FTestIterator.Reset; +end; + +{ TTestDecorator } + +class function TTestDecorator.Suite(const DecoratorName: string; + const DecoratedTestCase: ITestCase): ITestSuite; +begin + Result := Self.Create; + Result.AddTest(DecoratorName, DecoratedTestCase); +end; + +class function TTestDecorator.Suite(const DecoratedTestCase: ITestCase): ITestSuite; +begin + Result := Suite('', DecoratedTestCase); +end; + +class function TTestDecorator.Suite(const DecoratorName: string; + const DecoratedTestCases: array of ITestCase): ITestSuite; +var + idx: Integer; + LSuite : ITestSuite; +begin + Result := Self.Create; + if DecoratorName = '' then + for idx := 0 to Length(DecoratedTestCases) - 1 do + Result.AddTest(DecoratorName, DecoratedTestCases[idx]) + else + begin + LSuite := TTestSuite.Create(DecoratorName); + for idx := 0 to Length(DecoratedTestCases) - 1 do + LSuite.AddTest(DecoratedTestCases[idx]); + Result.AddTest(LSuite); + end; +end; + +function TTestDecorator.Run(const ExecControl: ITestExecControl): TExecutionStatus; +var + LTest: ITestCase; + LWhichOne: string; +begin + try + ExecStatus := _Running; + LWhichOne := 'Once'; + SetUpOnce; + LWhichOne := ''; + SetUp; + FTestIterator.Reset; + LTest := FTestIterator.FindNextTest as ITestCase; + while LTest <> nil do + begin + ExecStatus := LTest.Run(ExecControl); + LTest := FTestIterator.FindNextTest as ITestCase; + end; + + try + TearDown; + LWhichOne := 'Once'; + TearDownOnce; + except + on E:Exception do + begin + FReportErrorOnce := True; + ExecStatus := UpdateOnError(Self, + _Error, + 'TearDown ' + LWhichOne + ' failed: ' + E.Message, + E, + PtrType(ExceptAddr)); + end; + end; + except + on E:Exception do + begin + FReportErrorOnce := True; + ExecStatus := UpdateOnError(Self, + _Error, + 'SetUp ' + LWhichOne + ' failed: ' + E.Message, + E, + PtrType(ExceptAddr)); + end; + end; + + LWhichOne := ''; + Result := ExecStatus; +end; + +{ TRepeatedTest } + +class function TRepeatedTest.Suite(const CountedTestCase: ITestCase; + const Iterations: Cardinal): IRepeatedTest; +begin + Result := Self.Create; + (Result as IRepeatedTest).RepeatCount := Iterations; + Result.DisplayedName := Self.ClassName; + CountedTestCase.DisplayedName := IntToStr(Iterations) + ' * ' + CountedTestCase.DisplayedName; + Result.AddTest(CountedTestCase); +end; + +function TRepeatedTest.Count: Integer; +begin + Result := inherited Count * FRepeatCount; +end; + +function TRepeatedTest.GetHaltOnError: Boolean; +begin + Result := FHaltOnError; +end; + +procedure TRepeatedTest.SetHaltOnError(const Value: Boolean); +begin + FHaltOnError := Value; +end; + +procedure TRepeatedTest.set_RepeatCount(const Value: Integer); +begin + FRepeatCount := Value; +end; + +function TRepeatedTest.Run(const ExecControl: ITestExecControl): TExecutionStatus; +var + LCount: Integer; + LErrorCount: Integer; + LFailureCount: Integer; + LHalt: boolean; +begin + Result := ExecStatus; + LHalt := False; + LCount := FRepeatCount; + + while (LCount > 0) and (not LHalt) do + begin + LErrorCount := ExecControl.ErrorCount; + LFailureCount := ExecControl.FailureCount; + Result := inherited Run(ExecControl); + LHalt := FHaltOnError and + ((ExecControl.ErrorCount > LErrorCount) or + (ExecControl.FailureCount > LFailureCount)); + Dec(LCount); + end; +end; + +{------------------------------------------------------------------------------} +{ TTestProject } + +function TestProject: ITestProject; +begin + Result := nil; + if Assigned(ProjectManager) then + Result := ProjectManager.Project[0]; +end; + +function TestProject(const idx: Integer): ITestProject; +begin + Result := nil; + if Assigned(ProjectManager) and + ((idx >= 0) and (idx < ProjectManager.Count)) then + Result := ProjectManager.Project[idx]; +end; + +function Projects: ITestProject; overload; +begin + Result := nil; + if Assigned(ProjectManager) then + begin + Result := ProjectManager.Projects; + if not Assigned(Result) then + Result := TestProject; + end; +end; + +constructor TTestProject.Create; +begin + inherited Create; + CreateFields; +end; + +constructor TTestProject.Create(const ASuiteName: string); +begin + Create; + if (ASuiteName <> '') then + FDisplayedName := ASuiteName + else + FDisplayedName := DefaultProject; +end; + +procedure TTestProject.CreateFields; +begin + FAllTestsList := TInterfaceList.Create; + FSuiteList := TInterfaceList.Create; + // Install procedures that direct callbacks + FExecStatusUpdater := ExecStatusUpdater; + FStatusMsgUpdater := StatusMessageUpdater; +end; + +destructor TTestProject.Destroy; +begin + FExecStatusUpdater := nil; + FListener := nil; + FSuiteList := nil; + FAllTestsList := nil; + inherited; +end; + +procedure TTestProject.ExecStatusUpdater(const ATest: ITest); +begin + if (ATest = nil) or (FListener = nil) then + Exit; + case (ATest as ITest).ExecStatus of + _Ready: FTestingBegins := False; + + _Running: + begin + FTestingBegins := True; + if not ATest.IsTestMethod then + begin + if (ATest.Depth = 0) and (ATest.ProjectID = 0) then + (FListener as ITestListenerProxy).TestingStarts; + (FListener as ITestListenerProxy).StartSuite(ATest); + end; + (FListener as ITestListenerProxy).StartTest(ATest); + end; + + else // All other conditions + begin + (FListener as ITestListenerProxy).EndTest(ATest); + if not (ATest.SupportedIfaceType = _isTestMethod) then + begin + (FListener as ITestListenerProxy).EndSuite(ATest); + if (ATest.Depth = 0) and (ATest.ProjectID = 0) then + (FListener as ITestListenerProxy).TestingEnds; + end; + end; + end; {case} +end; + +procedure TTestProject.StatusMessageUpdater(const ATest: ITest; const AStatusMsg: string); +begin + if (ATest = nil) or (FListener = nil) then + Exit; + + (FListener as ITestListenerProxy).Status(ATest, AStatusMsg); +end; + +function TTestProject.ExecutionControl: ITestExecControl; +begin + if not Assigned(FExecControl) then + begin + FExecControl := TTestExecControl.Create(ExecStatusUpdater, + StatusMessageUpdater, + IsTestSelected); + end; + Result := FExecControl; +end; + +function TTestProject.get_Manager: IInterface; +begin + Result := ProjectManager as IInterface; +end; + +function TTestProject.get_ProjectName: string; +begin + Result := FProjectName; +end; + +procedure TTestProject.RegisterTest(const ATest: ITest); +begin + if Assigned(ATest) and (FAllTestsList.IndexOf(ATest) < 0) then + FAllTestsList.Add(ATest) +end; + +procedure TTestProject.Reset; +begin + inherited Reset; + FTestIdx := FAllTestsList.Count-1; + FEnabledTestsCounted := False; +end; + +// Note. The calling code can do the testing starts and end function just as +// well as this code and then there is no need for callbacks. +function TTestProject.Run(const ExecControl: ITestExecControl): TExecutionStatus; +var + i: Integer; + LCount: Cardinal; +begin + LCount := CountEnabledTests; + if Assigned(ExecControl) and (Depth = 0) then + begin // This is the top level project + ExecControl.CheckCalledCount := 0; + ExecControl.EnabledCount := LCount; + end; + + for i := FAllTestsList.Count - 1 downto 0 do + (FAllTestsList.Items[i] as ITest).ExecStatus := _Ready; + + ExecStatus := inherited Run(ExecControl); + ExecControl.TestSetUpData := nil; //Prevent data leakage outside of project + Result := ExecStatus; +end; + +procedure TTestProject.set_Listener(const Value: IInterface); +begin + FListener := Value; +end; + +procedure TTestProject.set_Manager(const AManager: IInterface); +begin + FManager := AManager; +end; + +procedure TTestProject.set_ProjectName(const AName: string); +begin + FProjectName := Trim(AName); + DisplayedName := FProjectName; +end; + +function TTestProject.IsTestSelected(const ATest: ITest): Boolean; +begin + Result := False; + if (ATest = nil) then + Exit; + + if (FListener = nil) then + Result := True + else + Result := (FListener as ITestListenerProxy).ShouldRunTest(ATest); +end; + +function TTestProject.SuiteByTitle(const SuiteTitle: string): ITestSuite; +var + i: Integer; + LSuite: ITest; +begin + Result := nil; + if SuiteTitle = DisplayedName then + begin + Result := Self; + Exit; + end; + + for i := 0 to FSuiteList.Count - 1 do + begin + LSuite := (FSuiteList.Items[i] as ITest); + if LSuite.InterfaceSupports(_isTestSuite) and + ((LSuite as ITestSuite).DisplayedName = SuiteTitle) then + begin + Result := (LSuite as ITestSuite); + Break; + end; + end; +end; + +// Visit the low level instances recursively +function TTestProject.FindNextEnabledProc: ITest; +begin + if not FEnabledTestsCounted then + FindFirstTest; + Result := inherited FindNextEnabledProc; +end; + +// Pull an instance out of the linear list or registered tests +function TTestProject.FindFirstTest: ITest; +begin + CountEnabledTests; + if FAllTestsList.Count <= 0 then + Result := nil + else + Result := (FAllTestsList.Items[FAllTestsList.Count-1] as ITest); +end; + +function TTestProject.FindNextTest: ITest; +begin + if not FEnabledTestsCounted then + Result := FindFirstTest + else + begin + Result := nil; + if FTestIdx > 0 then + begin + Dec(FTestIdx); + Result := (FAllTestsList.Items[FTestIdx] as ITest); + end; + end; +end; + +function TTestProject.CountEnabledTests: Integer; +var + LTest: ITest; + LHeldTest: ITest; +begin + Result := 0; + LHeldTest := nil; + FCount := inherited Count; + if Assigned(FAllTestsList) then + begin + FAllTestsList.Clear; // Clean out any/all old entries + FEnabledTestsCounted := False; + + LTest := FTestIterator.PriorTest; + repeat // Now build the reversed linear list of all entities. + LHeldTest := LTest; + if Assigned(LTest) and LTest.InterfaceSupports(_isTestCase) then + begin + LTest := (LTest as ITestCase).PriorTest; + if Assigned(LTest) then + begin + LTest.ProjectID := Self.ProjectID; + FTestIterator.FindNextTest; // Hold current entry while tests are valid + end; + end; + + begin + if LTest <> nil then + RegisterTest(LTest) + else + if Assigned(LHeldTest) then + RegisterTest(LHeldTest); + end; + + LTest := FTestIterator.PriorTest; + until LTest = nil; + Reset; + FEnabledTestsCounted := True; + Result := FCount; + end; +end; + +procedure TTestProject.AddTest(const ATest: ITest); +begin + if ATest = nil then + Exit; + + if ParentPath = '' then + ATest.ParentPath := DisplayedName + else + ATest.ParentPath := ParentPath + '.' + DisplayedName; + + if ATest.InterfaceSupports(_isTestSuite) then + FSuiteList.Add(ATest); + + ATest.ProjectID := FSuiteList.Count; + inherited AddTest(ATest); +end; + +procedure TTestProject.AddNamedSuite(const SuiteTitle: string; + const ATest: ITestCase); +var + LTestSuite: ITestSuite; +begin + LTestSuite := SuiteByTitle(SuiteTitle); + if Assigned(LTestSuite) then + LTestSuite.AddTest(ATest) + else + begin + LTestSuite := TTestSuite.Create; + LTestSuite.DisplayedName := SuiteTitle; + LTestSuite.AddTest(ATest); + AddTest(LTestSuite); + end; +end; + +function TTestProject.Count: Integer; +begin + if FEnabledTestsCounted then + Result := FCount + else + Result := CountEnabledTests; +end; + +{------------------------------------------------------------------------------} +{ Register tests } + +procedure RegisterTest(const ATest: ITestCase); +begin + ProjectRegisterTest('', ATest); +end; + +procedure RegisterTest(const SuiteTitle: string; const ATest: ITestCase); +begin + ProjectRegisterTest('', SuiteTitle, ATest); +end; + +procedure RegisterTests(const Tests: array of ITestCase); +begin + ProjectRegisterTests('', Tests); +end; + +procedure RegisterTests(const SuiteTitle: string; + const Tests: array of ITestCase); +begin + ProjectRegisterTests('', SuiteTitle, Tests); +end; + + +procedure ProjectRegisterTest(const ProjectName: string; + const ATest: ITestCase); +var + LProjectID: Integer; + LProject: ITestProject; +begin //procedure ProjectRegisterTest + if (ATest = nil) then + Exit; + + if not Assigned(ProjectManager) then + ProjectManager := TProjectManager.Create; + + LProjectID := ProjectManager.FindProjectID(ProjectName); + + if (LProjectID < 0) then // project has not been registered before + begin + LProject := TTestProject.Create(ProjectName); + ProjectManager.AddProject(LProject); + LProject.AddTest(ATest); + end + else + begin + LProject := ProjectManager.Project[LProjectID]; + LProject.AddTest(ATest); + end; +end; + +procedure ProjectRegisterTests(const ProjectName: string; + const Tests: array of ITestCase); overload; +var + idx: Integer; +begin + if Length(Tests) = 0 then + Exit; + + for idx := 0 to Length(Tests)-1 do + begin + if Assigned(Tests[idx]) then + ProjectRegisterTest(ProjectName, Tests[idx]); + end; +end; + +procedure ProjectRegisterTest(const ProjectName: string; + const SuiteTitle: string; + const ATest: ITestCase); overload; +var + LProject: ITestProject; + LProjectID: Integer; +begin + if (ATest = nil) then + Exit; + + if SuiteTitle = '' then + begin + ProjectRegisterTest(ProjectName, ATest); + Exit; + end; + + if not Assigned(ProjectManager) then + ProjectManager := TProjectManager.Create; + LProjectID := ProjectManager.FindProjectID(ProjectName); + if (LProjectID < 0) then // project has not been registered before + begin + LProject := TTestProject.Create(ProjectName); + LProject.AddNamedSuite(SuiteTitle, ATest); + LProjectID := ProjectManager.AddProject(LProject); + end + else + begin + LProject := ProjectManager.Project[LProjectID]; + LProject.AddNamedSuite(SuiteTitle, ATest); + end; + + ATest.ProjectID := LProjectID; +end; + +procedure ProjectRegisterTests(const ProjectName: string; + const SuiteTitle: string; + const Tests: array of ITestCase); +var + idx: Integer; +begin + if Length(Tests) = 0 then + Exit; + + if SuiteTitle = '' then + begin + for idx := 0 to Length(Tests)-1 do + ProjectRegisterTest(ProjectName, Tests[idx]); + end + else + for idx := 0 to Length(Tests)-1 do + begin + ProjectRegisterTest(ProjectName, SuiteTitle, Tests[idx]); + end; +end; + +initialization + gTimer.Clear; + gTimer.Start; + +finalization + UnRegisterProjectManager; +end. diff --git a/tests/fptest/src/TestFrameworkIfaces.pas b/tests/fptest/src/TestFrameworkIfaces.pas new file mode 100644 index 00000000..074ea74d --- /dev/null +++ b/tests/fptest/src/TestFrameworkIfaces.pas @@ -0,0 +1,540 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is DUnit. + + The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + and Juancarlo Añez. + Portions created The Initial Developers are Copyright (C) 1999-2000. + Portions created by The DUnit Group are Copyright (C) 2000-2007. + All rights reserved. + + Contributor(s): + Kent Beck + Erich Gamma + Juanco Añez + Chris Morris + Jeff Moore + Uberto Barbini + Brett Shearer + Kris Golko + The DUnit group at SourceForge + Peter McNab + Graeme Geldenhuys +} + +unit TestFrameworkIfaces; + +{$IFDEF FPC} + {$mode delphi}{$H+} +{$ENDIF} + +interface + +uses + Classes, + IniFiles, + SysUtils; + +type + PtrType = PtrUInt; + TExceptTestMethod = procedure of object; + + TTestMethod = procedure of object; + ITest = interface; + TIsTestSelected = function(const ATest: ITest): boolean of object; + TExecStatusUpdater = procedure(const ATest: ITest) of object; + TStatusMsgUpdater = procedure(const ATest: ITest; + const AStatusMsg: string) of object; +{$M+} + // The order is determined such that higher values always override lower + // values when reporting status. So a failed testmethod will override a passed + // test method at the testcase level and so on. + TExecutionStatus = (_Ready, _Running, _HaltTest, _Passed, + _Warning, _Stopped, _Failed, _Break, _Error); + + TSupportedIface = (_isTestMethod, _isTestCase, _isTestSuite, _isTestProject, + _isTestDecorator, _Other); + +{$M-} + + TAllowedLeakArray = array[0..3] of integer; + TListIterator = function: integer of object; + + + IMemLeakMonitor = interface(IUnknown) + ['{041368CC-5B04-4111-9E2E-05A5908B3A58}'] + + function MemLeakDetected(out LeakSize: Integer): boolean; + end; + + + IDUnitMemLeakMonitor = interface(IMemLeakMonitor) + ['{45466FCA-1ADC-4457-A41C-88FA3F8D23F7}'] + + function MemLeakDetected(const AllowedLeakSize: Integer; + const FailOnMemoryRecovery: boolean; + out LeakSize: Integer): boolean; overload; + function MemLeakDetected(const AllowedValuesGetter: TListIterator; + const FailOnMemoryRecovery: boolean; + out LeakIndex: integer; + out LeakSize: Integer): boolean; overload; + function GetMemoryUseMsg(const FailOnMemoryRecovery: boolean; + const TestProcChangedMem: Integer; + out ErrorMsg: string): boolean; overload; + function GetMemoryUseMsg(const FailOnMemoryRecovery: boolean; + const TestSetupChangedMem: Integer; + const TestProcChangedMem: Integer; + const TestTearDownChangedMem: Integer; + const TestCaseChangedMem: Integer; + out ErrorMsg: string): boolean; overload; + procedure MarkMemInUse; + end; + + + // forward declaration + ITestMethod = interface; + + + ITestSetUpData = interface + ['{46F62E93-A9C4-45D9-9AF1-C914E75481C0}'] + // derive from this interface when adding getters, setters and properties + end; + + + ITestExecControl = interface + ['{F2E51368-2D72-49B3-A91F-E202C4466EB7}'] + + function get_TestSetUpData: ITestSetUpData; + procedure set_TestSetUpData(const Value: ITestSetUpData); + property TestSetUpData: ITestSetUpData read Get_TestSetUpData write Set_TestSetUpData; + + function get_HaltExecution: boolean; + procedure set_HaltExecution(const Value: boolean); + property HaltExecution: boolean read get_HaltExecution write set_HaltExecution; + + function get_BreakOnFailures: boolean; + procedure set_BreakOnFailures(const Value: boolean); + property BreakOnFailures: boolean read get_BreakOnFailures write set_BreakOnFailures; + + procedure ClearCounts; + function get_TestCanRun: boolean; + procedure set_TestCanRun(const Value: boolean); + property TestCanRun: boolean read get_TestCanRun write set_TestCanRun; + + function get_CurrentTest: ITest; + procedure set_CurrentTest(const Value: ITest); + property CurrentTest: ITest read get_CurrentTest write set_CurrentTest; + + function get_ExecStatusUpdater: TExecStatusUpdater; + procedure set_ExecStatusUpdater(const Value: TExecStatusUpdater); + property ExecStatusUpdater: TExecStatusUpdater read get_ExecStatusUpdater + write set_ExecStatusUpdater; + function get_StatusMsgUpdater: TStatusMsgUpdater; + procedure set_StatusMsgUpdater(const Value: TStatusMsgUpdater); + property StatusMsgUpdater: TStatusMsgUpdater read get_StatusMsgUpdater + write set_StatusMsgUpdater; + function get_EnabledCount: Cardinal; + procedure set_EnabledCount(const Value: Cardinal); + property EnabledCount: Cardinal read get_EnabledCount + write set_EnabledCount; + function get_ExecutionCount: Cardinal; + procedure set_ExecutionCount(const Value: Cardinal); + property ExecutionCount: Cardinal read get_ExecutionCount + write set_ExecutionCount; + function get_FailsOnNoChecksExecuted: boolean; + procedure set_FailsOnNoChecksExecuted(const Value: boolean); + property FailsOnNoChecksExecuted: boolean read get_FailsOnNoChecksExecuted + write set_FailsOnNoChecksExecuted; + function get_FailureCount: Integer; + procedure set_FailureCount(const Value: Integer); + property FailureCount: Integer read get_FailureCount + write set_FailureCount; + function get_ErrorCount: Integer; + procedure set_ErrorCount(const Value: Integer); + property ErrorCount: Integer read get_ErrorCount + write set_ErrorCount; + function get_WarningCount: Integer; + procedure set_WarningCount(const Value: Integer); + property WarningCount: Integer read get_WarningCount + write set_WarningCount; + function get_ExcludedCount: Integer; + procedure set_ExcludedCount(const Value: Integer); + property ExcludedCount: Integer read get_ExcludedCount + write set_ExcludedCount; + procedure IssueStatusMsg(const ATest: ITestMethod; const StatusMsg: string); + function get_CheckCalledCount: integer; + procedure set_CheckCalledCount(const Value: Integer); + property CheckCalledCount: integer read get_CheckCalledCount + write set_CheckCalledCount; + function get_IndividuallyEnabledTest: TIsTestSelected; + procedure set_IndividuallyEnabledTest(const Value: TIsTestSelected); + property IndividuallyEnabledTest: TIsTestSelected read get_IndividuallyEnabledTest + write set_IndividuallyEnabledTest; + function get_InhibitStackTrace: boolean; + procedure set_InhibitStackTrace(const Value: boolean); + property InhibitStackTrace: boolean read get_InhibitStackTrace + write set_InhibitStackTrace; + function get_InhibitSummaryLevelChecks: boolean; + procedure set_InhibitSummaryLevelChecks(const Value: boolean); + property InhibitSummaryLevelChecks: boolean read get_InhibitSummaryLevelChecks + write set_InhibitSummaryLevelChecks; + function get_FailsOnMemoryLeak: boolean; + procedure set_FailsOnMemoryLeak(const Value: boolean); + property FailsOnMemoryLeak: boolean read get_FailsOnMemoryLeak + write set_FailsOnMemoryLeak; + property FailsOnMemLeakDetection: boolean read get_FailsOnMemoryLeak + write set_FailsOnMemoryLeak; + function get_IgnoresMemoryLeakInSetUpTearDown: boolean; + procedure set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); + property IgnoresMemoryLeakInSetUpTearDown: boolean + read get_IgnoresMemoryLeakInSetUpTearDown + write set_IgnoresMemoryLeakInSetUpTearDown; + end; + + + // forward declaration + ITestCase = interface; + + + ITest = interface + ['{E465B9E7-5D7E-4A82-A5E7-9F4F86B465AD}'] + function UniqueID: Cardinal; + function get_Proxy: IInterface; + procedure set_Proxy(const AProxy: IInterface); + property Proxy: IInterface read get_Proxy write set_Proxy; + function get_ProjectID: integer; + procedure set_ProjectID(const ID: integer); + property ProjectID: integer read get_ProjectID write set_ProjectID; + function MethodsName: string; + // Legacy dunit partial compatability + procedure RunTest; + function get_ParentTestCase: ITestCase; + procedure set_ParentTestCase(const TestCase: ITestCase); + property ParentTestCase: ITestCase read get_ParentTestCase write set_ParentTestCase; + procedure InstallExecutionControl(const Value: ITestExecControl); + function get_DisplayedName: string; + procedure set_DisplayedName(const AName: string); + function GetName: string; + function CurrentTest: ITest; + property DisplayedName: string read get_DisplayedName write set_DisplayedName; + function get_ParentPath: string; + procedure set_ParentPath(const AName: string); + property ParentPath: string read get_ParentPath write set_ParentPath; + procedure set_Enabled(const Value: boolean); + function get_Enabled: boolean; + property Enabled : boolean read get_Enabled write set_Enabled; + function get_Excluded: boolean; + procedure set_Excluded(const Value: boolean); + property Excluded: boolean read get_Excluded write set_Excluded; + function Count: integer; + function get_Depth: integer; + procedure set_Depth(const Value: integer); + property Depth: integer read get_Depth write set_Depth; + function get_TestSetUpData: ITestSetUpData; + procedure set_TestSetUpData(const Value: ITestSetUpData); + property TestSetUpData : ITestSetUpData read get_TestSetUpData write set_TestSetUpData; + function IsTestMethod: boolean; + function SupportedIfaceType: TSupportedIface; + function InterfaceSupports(const Value: TSupportedIface): Boolean; + function get_ElapsedTime: Extended; + procedure set_ElapsedTime(const Value: Extended); + property ElapsedTime: Extended read get_ElapsedTime write set_ElapsedTime; + procedure SaveConfiguration(const iniFile: TCustomIniFile; const Section: string); + procedure LoadConfiguration(const iniFile :TCustomIniFile; const Section :string); + procedure BeginRun; + function get_ExecStatus: TExecutionStatus; + procedure set_ExecStatus(const Value: TExecutionStatus); + property ExecStatus: TExecutionStatus read get_ExecStatus write set_ExecStatus; + procedure Status(const Value: string); + function GetStatus: string; + function UpdateOnFail(const ATest: ITest; + const NewStatus: TExecutionStatus; + const Excpt: Exception; + const Addrs: PtrType): TExecutionStatus; + function get_CheckCalled: boolean; + procedure set_CheckCalled(const Value: boolean); + property CheckCalled: boolean read get_CheckCalled write set_CheckCalled; + function get_ErrorMessage: string; + procedure set_ErrorMessage(const Value: string); + property ErrorMessage: string read get_ErrorMessage write set_ErrorMessage; + function get_ErrorAddress: PtrType; + procedure set_ErrorAddress(const Value: PtrType); + property ErrorAddress: PtrType read get_ErrorAddress write set_ErrorAddress; + function get_ExceptionClass: ExceptClass; + procedure set_ExceptionClass(const Value: ExceptClass); + property ExceptionClass: ExceptClass read get_ExceptionClass + write set_ExceptionClass; + function get_FailsOnNoChecksExecuted: boolean; + procedure set_FailsOnNoChecksExecuted(const Value: boolean); + property FailsOnNoChecksExecuted: boolean read get_FailsOnNoChecksExecuted + write set_FailsOnNoChecksExecuted; + function get_InhibitSummaryLevelChecks: boolean; + procedure set_InhibitSummaryLevelChecks(const Value: boolean); + property InhibitSummaryLevelChecks: boolean read get_InhibitSummaryLevelChecks + write set_InhibitSummaryLevelChecks; + function get_EarlyExit: Boolean; + property EarlyExit: boolean read get_EarlyExit; + function get_LeakAllowed: boolean; + procedure set_LeakAllowed(const Value: boolean); + property LeakAllowed: boolean read get_LeakAllowed write set_LeakAllowed; + function get_FailsOnMemoryLeak: boolean; + procedure set_FailsOnMemoryLeak(const Value: boolean); + property FailsOnMemoryLeak: boolean read get_FailsOnMemoryLeak + write set_FailsOnMemoryLeak; + function get_AllowedMemoryLeakSize: Integer; + procedure set_AllowedMemoryLeakSize(const NewSize: Integer); + property AllowedMemoryLeakSize: Integer read get_AllowedMemoryLeakSize + write set_AllowedMemoryLeakSize; + procedure SetAllowedLeakArray(const AllowedList: array of Integer); + function get_AllowedLeaksIterator: TListIterator; + property AllowedLeaksIterator: TListIterator read get_AllowedLeaksIterator; + function get_IgnoresMemoryLeakInSetUpTearDown: boolean; + procedure set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); + property IgnoresMemoryLeakInSetUpTearDown: boolean + read get_IgnoresMemoryLeakInSetUpTearDown + write set_IgnoresMemoryLeakInSetUpTearDown; + end; + + + ITestMethod = interface(ITest) + ['{9B2501B0-F692-48A5-BE95-4DB6DD3FD382}'] + function Run(const Parent: ITestCase; + const AMethodName: string; + const ExecControl: ITestExecControl): TExecutionStatus; + procedure Warn(const ErrorMsg: string; + const ErrorAddress: Pointer = nil); + procedure Fail(const ErrorMsg: string; + const ErrorAddress: Pointer = nil); + procedure FailEquals(const expected, actual: UnicodeString; + const ErrorMsg: string = ''; ErrorAddrs: Pointer = nil); + procedure FailNotEquals(const expected, actual: UnicodeString; + const ErrorMsg: string = ''; ErrorAddrs: Pointer = nil); + procedure FailNotSame(const expected, actual: UnicodeString; + const ErrorMsg: string = ''; ErrorAddrs: Pointer = nil); + //function get_ExceptionClass: ExceptClass; + //procedure set_ExceptionClass(const Value: ExceptClass); + //property ExceptionClass: ExceptClass read get_ExceptionClass + // write set_ExceptionClass; + end; + + + ITestCheck = interface + ['{D6CFEE09-44AE-499A-AE8E-EFE23848AEED}'] + procedure OnCheckCalled; + { The following are the calls users make in test procedures} + procedure EarlyExitCheck(const condition: boolean; const ErrorMsg: string = ''); + procedure CheckFalse(const condition: boolean; const ErrorMsg: string = ''); + procedure CheckNotEquals(const expected, actual: boolean; + const ErrorMsg: string = ''); overload; + procedure CheckEquals(const expected, actual: integer; + const ErrorMsg: string = ''); overload; + procedure CheckNotEquals(const expected, actual: integer; + const ErrorMsg: string = ''); overload; + procedure CheckEquals(const expected, actual: int64; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: int64; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: extended; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: extended; + const delta: extended; + const ErrorMsg: string= ''); overload; + procedure CheckEquals(const expected, actual: string; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: string; + const ErrorMsg: string = ''); overload; + procedure CheckEqualsString(const expected, actual: string; + const ErrorMsg: string = ''); + procedure CheckNotEqualsString(const expected, actual: string; + const ErrorMsg: string = ''); + {$IFNDEF UNICODE} + procedure CheckEquals(const expected, actual: UnicodeString; + const ErrorMsg: string= ''); overload; + procedure CheckNotEquals(const expected, actual: UnicodeString; + const ErrorMsg: string = ''); overload; + procedure CheckEqualsMem(const expected, actual: pointer; + const size:longword; + const ErrorMsg: string= ''); + procedure CheckNotEqualsMem(const expected, actual: pointer; + const size:longword; + const ErrorMsg:string=''); + {$ENDIF} + procedure CheckEqualsUnicodeString(const expected, actual: UnicodeString; + const ErrorMsg: string= ''); + procedure CheckNotEqualsUnicodeString(const expected, actual: UnicodeString; + const ErrorMsg: string = ''); + procedure CheckEqualsBin(const expected, actual: longword; + const ErrorMsg: string = ''; + const digits: Integer=32); + procedure CheckNotEqualsBin(const expected, actual: longword; + const ErrorMsg: string = ''; + const digits: Integer=32); + procedure CheckEqualsHex(const expected, actual: longword; + const ErrorMsg: string = ''; + const digits: Integer=8); + procedure CheckNotEqualsHex(const expected, actual: longword; + const ErrorMsg: string = ''; + const digits: Integer=8); + + procedure CheckNotNull(const obj :IInterface; + const ErrorMsg :string = ''); overload; + procedure CheckNull(const obj: IInterface; + const ErrorMsg: string = ''); overload; + procedure CheckNotNull(const obj: TObject; + const ErrorMsg: string = ''); overload; + procedure CheckNull(const obj: TObject; + const ErrorMsg: string = ''); overload; + procedure CheckNotNull(const obj :Pointer; + const ErrorMsg :string = ''); overload; + procedure CheckNull(const obj: Pointer; + const ErrorMsg: string = ''); overload; + procedure CheckNotSame(const expected, actual: IInterface; + const ErrorMsg: string = ''); overload; + procedure CheckSame(const expected, actual: TObject; + const ErrorMsg: string = ''); overload; + procedure CheckNotSame(const expected, actual: TObject; + const ErrorMsg: string = ''); overload; + procedure CheckException(const AMethod: TExceptTestMethod; + const AExceptionClass: TClass; + const ErrorMsg :string = ''); + procedure CheckEquals(const expected, actual: TClass; + const ErrorMsg: string = ''); overload; + procedure CheckNotEquals(const expected, actual: TClass; + const ErrorMsg: string = ''); overload; + procedure CheckInherits(const expected, actual: TClass; + const ErrorMsg: string = ''); + procedure Check(const condition: boolean; const ErrorMsg: string= ''); overload; + procedure CheckEquals(const expected, actual: extended; + const ErrorMsg: string= ''); overload; + procedure CheckTrue(const condition: boolean; const ErrorMsg: string = ''); + procedure CheckEquals(const expected, actual: boolean; + const ErrorMsg: string = ''); overload; + procedure CheckSame(const expected, actual: IInterface; + const ErrorMsg: string = ''); overload; + procedure CheckIs(const AObject :TObject; + const AClass: TClass; + const ErrorMsg: string = ''); + procedure CheckEquals(const expected, actual: extended; + const delta: extended; + const ErrorMsg: string= ''); overload; + end; + + + ITestCase = interface(ITest) + ['{230CEE88-79CD-4D01-9CE3-DF8018327C05}'] + procedure SetUp; + procedure TearDown; + function Run(const ExecControl: ITestExecControl): TExecutionStatus; + procedure AddTest(const ATest: ITest); + //function Count: integer; + function CountTestCases: Integer; + procedure AddSuite(const ATest: ITest); + procedure Reset; //Resets to 1st entry + function PriorTest: ITest; + function FindNextEnabledProc: ITest; + function get_ProgressSummary: IInterface; + property ProgressSummary: IInterface read get_ProgressSummary; + function get_ExpectedException: ExceptClass; + procedure StartExpectingException(e: ExceptClass); + property ExpectedException :ExceptClass read get_ExpectedException + write StartExpectingException; + //procedure InstallExecutionControl(const Value: ITestExecControl); + function get_ReEntering: Boolean; + procedure set_ReEntering(const Value: Boolean); + property ReEntering: Boolean read get_ReEntering write set_ReEntering; + function get_ReportErrorOnce: boolean; + procedure set_ReportErrorOnce(const Value: boolean); + property ReportErrorOnce: Boolean read get_ReportErrorOnce + write set_ReportErrorOnce; + procedure ReleaseProxys; + procedure StopTests(const ErrorMsg: string = ''); + procedure InhibitStackTrace; overload; + procedure InhibitStackTrace(const Value: boolean); overload; + end; + + + IReadOnlyIterator = interface + ['{F76E5F49-B2EC-4F6C-ACB9-E8E03B1F230B}'] + procedure Reset; //Resets to 1st entry + function FindFirstTest: ITest; + function FindNextTest: ITest; + function PriorTest: ITest; + function FindNextEnabledProc: ITest; + function CurrentTest: ITest; + end; + + + ITestIterator = interface(IReadOnlyIterator) + ['{A408E082-8F55-4E37-AA66-E41629E2DE26}'] + procedure AddTest(const ATest: ITest); + end; + + + ITestSuite = interface(ITestCase) + ['{DD917A7D-B457-43A9-9828-250C890DFE58}'] + procedure AddTest(const SuiteTitle: string; + const ASuite: ITestCase); overload; + procedure AddTest(const SuiteTitle: string; + const Suites: array of ITestCase); overload; + end; + + + {: General interface for test decorators} + ITestDecorator = interface(ITestSuite) + ['{962956B6-0633-4296-A5E7-AC6250450793}'] + end; + + + IRepeatedTest = interface(ITestSuite) + ['{DF3B52FF-2645-42C2-958A-174FF87A19B8}'] + procedure set_RepeatCount(const Value: Integer); + property RepeatCount: Integer write set_RepeatCount; + function GetHaltOnError: Boolean; + procedure SetHaltOnError(const Value: Boolean); + property HaltOnError: Boolean read GetHaltOnError write SetHaltOnError; + end; + + + ITestProject = interface(ITestSuite) + ['{83481224-7BC4-4C9F-83B3-56DD17BD73AA}'] + function get_Manager: IInterface; + procedure set_Manager(const AManager: IInterface); + property Manager: IInterface read Get_Manager write Set_Manager; + function CountEnabledTests: integer; + function SuiteByTitle(const SuiteTitle: string): ITestSuite; + //procedure AddTest(const SuiteTitle: string; + // const ASuite: ITestCase); overload; + //procedure AddTest(const SuiteTitle: string; + // const Suites: array of ITestCase); overload; + procedure AddNamedSuite(const SuiteTitle: string; const ATest: ITestCase); + function FindFirstTest: ITest; + function FindNextTest: ITest; + procedure RegisterTest(const ATest: ITest); + function ExecutionControl: ITestExecControl; + procedure set_Listener(const Value: IInterface); + property Listener: IInterface write set_Listener; + end; + + + IMemUseComparator = interface + ['{1D015AE6-6555-426D-987D-64B482AFBB94}'] + procedure RunSetup(const UsersSetUp: TThreadMethod); + procedure RunTearDown(const UsersTearDown: TThreadMethod); + function AlertOnMemoryLoss(const CurrentStatus: TExecutionStatus): TExecutionStatus; + end; + + +implementation + +end. diff --git a/tests/fptest/src/TestFrameworkProxy.pas b/tests/fptest/src/TestFrameworkProxy.pas new file mode 100644 index 00000000..4549400d --- /dev/null +++ b/tests/fptest/src/TestFrameworkProxy.pas @@ -0,0 +1,1394 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is DUnit. + + The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + and Juancarlo Añez. + Portions created The Initial Developers are Copyright (C) 1999-2000. + Portions created by The DUnit Group are Copyright (C) 2000-2007. + All rights reserved. + + Contributor(s): + Kent Beck + Erich Gamma + Juanco Añez + Chris Morris + Jeff Moore + Uberto Barbini + Brett Shearer + Kris Golko + The DUnit group at SourceForge + Peter McNab + Graeme Geldenhuys +} + +{ Description: + This unit sits between the adapted GUITestRunner and TestFramework. + It provides an interface to look and behave like the original TestFramework. + When tests FPTest code has reached a mature stage a new GUITestRunner will be + introduced to interface directly with a new TestRunner TestFramework. + This "Proxy" unit re-creates the Tests structure currently accessed by + the treeview. } +unit TestFrameworkProxy; + +{$IFDEF FPC} + {$mode delphi}{$H+} + {$UNDEF FASTMM} +{$ELSE} + {$WARN UNIT_PLATFORM OFF} +{$ENDIF} + +{$BOOLEVAL OFF} + +interface +uses + TestFrameworkProxyIfaces, + TestFrameworkIfaces, + Classes; + +function RegisteredTests(const TestSuite: ITestCase): ITestSuiteProxy; overload; +function RegisteredTests: ITestSuiteProxy; overload; +function RegisteredTests(const TestsTitle: string): ITestSuiteProxy; overload; +function IsTestMethod(ATest: ITestProxy): Boolean; +function GetDUnitRegistryKey: string; +procedure ClearRegistry; +function GetTestResult: ITestResult; +function RunTest(Suite: ITestProxy; const Listeners: array of ITestListener): ITestResult; overload; +function PointerToLocationInfo(Addrs: PtrType): string; + + +implementation + +uses + TestFramework, + TestListenerIface, + ProjectsManagerIface, + SysUtils, + TimeManager; + +type + TTestListenerProxy = class(TInterfacedObject, ITestListenerProxy) + private + FTestResult: ITestResult; + FTestListeners: IInterfaceList; + FRunningStartTime: Extended; + FRunningStopTime: Extended; + procedure UpdateTestResult; + function EndTestExec(const ATest: ITest):ITestProxy; + protected + function ShouldRunTest(const ATest :ITest):Boolean; + procedure AddListener(const Listener: ITestListener); overload; + procedure TestingStarts; + procedure StartSuite(ASuite: ITest); + procedure StartTest(Test: ITest); + procedure EndTest(ATest: ITest); + procedure EndSuite(ASuite: ITest); + procedure TestingEnds; + procedure ReleaseListeners; + procedure Status(const ATest: ITest; const AMessage: string); + public + constructor Create(const Value: ITestResult); + destructor Destroy; override; + end; + + + {$M+} + TTestProxy = class(TInterfacedObject, ITestProxy) + private + FITest: ITest; + FGUIObject: TObject; + FTestName: string; + FExecutionStatus : TExecutionStatus; + FIsOverridden: boolean; + FIsWarning: boolean; + FFailsOnMemoryRecovery: boolean; + FAllowedLeakList: TAllowedLeakArray; + FITestList: IInterfaceList; + FErrors: Integer; + FFailures: Integer; + FTestExecuted: Integer; + FWarnings: Integer; + procedure SetGUIObject(const GUIObject: TObject); + function GetGUIObject: TObject; + function GetEnabled: Boolean; + procedure SetEnabled(Value: Boolean); + function GetExcluded: Boolean; + procedure SetExcluded(Value: Boolean); + function GetName: string; + function ParentPath: string; + function GetStatus :string; + function get_IsTestMethod: boolean; + function SupportedIfaceType: TSupportedIface; + function get_ExecutedStatus: TExecutionStatus; + procedure set_ExecutedStatus(const Value: TExecutionStatus); + function get_IsOverridden: boolean; + procedure set_IsOverridden(const Value: boolean); + function get_IsWarning: boolean; + procedure set_IsWarning(const Value: boolean); + function get_Errors: Integer; + procedure set_Errors(const Value: Integer); + function get_Failures: Integer; + procedure set_Failures(const Value: Integer); + function get_Warnings: Integer; + procedure set_Warnings(const Value: Integer); + function get_TestsExecuted: Integer; + procedure set_TestsExecuted(const Value: Integer); + function Updated: boolean; + procedure SetFailsOnNoChecksExecuted(const Value: Boolean); + function GetFailsOnNoChecksExecuted: Boolean; + function get_InhibitSummaryLevelChecks: boolean; + procedure set_InhibitSummaryLevelChecks(const Value: boolean); + function EarlyExit: boolean; + + function get_LeakAllowed: boolean; + function GetFailsOnMemoryLeak: Boolean; + procedure SetFailsOnMemoryLeak(const Value: Boolean); + function GetIgnoreSetUpTearDownLeaks: Boolean; + procedure SetIgnoreSetUpTearDownLeaks(const Value: Boolean); + function GetAllowedMemoryLeakSize: Integer; + procedure SetAllowedMemoryLeakSize(const NewSize: Integer); + function GetFailsOnMemoryRecovery: Boolean; + + procedure SaveConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); + procedure LoadConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); virtual; + function CountEnabledTestCases: Integer; + function ElapsedTestTime: Extended; + function Tests: IInterfaceList; + procedure Run(const TestResult: ITestResult); overload; + function Run(const Listeners: array of ITestListener): ITestResult; overload; + function Run(const AListener: ITestListener): ITestResult; overload; + procedure HaltTesting; + procedure ReleaseTests; virtual; + public + constructor Create; virtual; + destructor Destroy; override; + end; + {$M-} + + + TTestSuiteProxy = class(TTestProxy, ITestSuiteProxy) + protected + FIsTestMethod: Boolean; + FIsNotTestMethod: Boolean; + public + constructor Create(const ATestProject: ITestProject); reintroduce; overload; + constructor Create(const ATestProject: ITestProject; + const CurrentTest: ITest; + out LTest: ITest); reintroduce; overload; + function Tests: IInterfaceList; + procedure TestSuiteTitle(const ATitle: string); + end; + + + TITestFailure = class(TInterfacedObject, TTestFailure) + private + FFailedTest: ITestProxy; + FStackTrace: string; + FThrownExceptionAddress: PtrType; + FThrownExceptionMessage: string; + FThrownExceptionClassName: string; + function ThrownExceptionAddress: PtrType; virtual; + procedure CaptureStackTrace; + public + constructor Create(const FailedTest: ITestProxy; + const ThrownExceptionClass: ExceptClass; + const AMsg: string; + const Addrs: PtrType; + const ShowStack: boolean); overload; + function FailedTest: ITestProxy; virtual; + function ThrownExceptionName: string; virtual; + function ThrownExceptionMessage: string; virtual; + function LocationInfo: string; virtual; + function AddressInfo: string; virtual; + function StackTrace: string; virtual; + end; + + + { This interfaced object replicates the reporting and control of the original + TTestResult object but unwinds some of the deeper convoluted involvement in + test execution. } + {$M+} + TITestResult = class(TInterfacedObject, ITestResult) + private + FOverrides: Integer; + FBreakOnFailures: boolean; + FFailsIfNoChecksExecuted: boolean; + FFailsIfMemoryLeaked: boolean; + FIgnoresMemoryLeakInSetUpTearDown: boolean; + FErrorCount: Integer; + FWarningCount: Integer; + FFailureCount: Integer; + FFailures: IInterfaceList; + FErrors: IInterfaceList; + FWarnings: IInterfaceList; + FRunTests: Integer; + FChecksCalledCount: Integer; + FStop: Boolean; + FWasStopped: Boolean; + FTestListenerProxy: ITestListenerProxy; + FTotalTime: Extended; + FExcludedCount: Integer; + FInhibitSummaryLevelChecks: Boolean; + function GetFailure(idx: Integer): TTestFailure; + procedure SetFailure(idx: Integer; AFailure: TTestFailure); + function GetError(idx: Integer): TTestFailure; + procedure SetError(idx: Integer; AnError: TTestFailure); + function GetWarning(idx :Integer) :TTestFailure; + procedure SetWarning(idx: Integer; AFailure: TTestFailure); + protected + function get_TotalTime: Extended; + procedure set_TotalTime(const Value: Extended); + function get_WarningCount: Integer; + procedure set_WarningCount(const Value: Integer); + function get_ExcludedCount: Integer; + procedure set_ExcludedCount(const Value: integer); + function get_Overrides: Integer; + procedure set_Overrides(const Value: Integer); + function get_ChecksCalledCount: Integer; + procedure set_ChecksCalledCount(const Value: Integer); + function get_BreakOnFailures: boolean; + procedure set_BreakOnFailures(const Value: boolean); + function get_FailsIfNoChecksExecuted: boolean; + procedure set_FailsIfNoChecksExecuted(const Value: boolean); + function get_FailsIfMemoryLeaked: boolean; + procedure set_FailsIfMemoryLeaked(const Value: boolean); + function get_IgnoresMemoryLeakInSetUpTearDown: boolean; + procedure set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); + function get_InhibitSummaryLevelChecks: boolean; + procedure set_InhibitSummaryLevelChecks(const Value: boolean); + procedure ReleaseListeners; + function get_ErrorCount: Integer; virtual; + procedure set_ErrorCount(const Value: Integer); + function get_RunCount: Integer; + procedure set_RunCount(const Value: Integer); + function get_FailureCount: Integer; virtual; + procedure set_FailureCount(const Value: Integer); virtual; + procedure Stop; virtual; + procedure AddListener(const Listener: ITestListener); virtual; + procedure RemoveListener(const Listener: ITestListener); virtual; + function WasSuccessful: Boolean; virtual; + function get_WasStopped :Boolean; + procedure set_WasStopped(const Value: Boolean); + + public + constructor Create; + destructor Destroy; override; + published + property ErrorCount: Integer read get_ErrorCount write set_ErrorCount; + property FailureCount: Integer read get_FailureCount write set_FailureCount; + property WasStopped:Boolean read get_WasStopped write set_WasStopped; + end; + {$M-} + + +var + DUnitRegistryKey: string = ''; + + +function GetTestResult: ITestResult; +begin + Result := TITestResult.Create; +end; + +function RunTest(Suite: ITestProxy; const Listeners: array of ITestListener): ITestResult; overload; +var + i: Integer; +begin + Result := GetTestResult; + if Supports(Suite, ITestSuiteProxy) then + begin + Result.FailsIfNoChecksExecuted := Suite.FailsOnNoChecksExecuted; + Result.InhibitSummaryLevelChecks := Suite.InhibitSummaryLevelChecks; + {$IFDEF FASTMM} + Result.FailsIfMemoryLeaked := Suite.FailsOnMemoryLeak; + Result.IgnoresMemoryLeakInSetUpTearDown := Suite.IgnoreSetUpTearDownLeaks; + {$ENDIF} + end; + for i := low(Listeners) to high(Listeners) do + result.addListener(Listeners[i]); + if Suite <> nil then + try + Suite.Run(result); + finally + TestFrameWork.RegisteredTests.ReleaseProxys; + end; +end; + +function RegisteredTests(const TestSuite: ITestCase): ITestSuiteProxy; overload; +begin + if TestSuite = nil then + begin + Result := nil; + Exit; + end; + + if TestSuite.SupportedIfaceType = _isTestProject then + Result := TTestSuiteProxy.Create(TestSuite as ITestProject) + else + Result := TTestSuiteProxy.Create(Projects) +end; + +function RegisteredTests(const TestsTitle: string): ITestSuiteProxy; overload; +var + LProject: ITestProject; +begin + Result := nil; + LProject := Projects; + if LProject = nil then + Exit; + + if TestsTitle <> '' then + LProject.DisplayedName := TestsTitle; + Result := TTestSuiteProxy.Create(LProject); +end; + +function RegisteredTests: ITestSuiteProxy; overload; +begin + Result := RegisteredTests(''); +end; + +function IsTestMethod(aTest: ITestProxy): Boolean; +begin + Result := ATest.IsTestMethod; +end; + +function GetDUnitRegistryKey: string; +begin + Result := DUnitRegistryKey; +end; + +function TestToProxy(const ATest: ITest): ITestProxy; +begin + if Assigned(ATest) then + Result := (ATest.Proxy as ITestProxy) + else + Result := nil; +end; + +{ TTestResult } + +procedure TITestResult.AddListener(const Listener: ITestListener); +begin + if Listener = nil then + Exit; + + if not Assigned(FTestListenerProxy) then + FTestListenerProxy := TTestListenerProxy.Create(Self); + FTestListenerProxy.AddListener(Listener); + (TestProject.Manager as IProjectManager).AddListener(FTestListenerProxy); +end; + +procedure TITestResult.RemoveListener(const Listener: ITestListener); +begin + if Listener = nil then + Exit; + + if Assigned(FTestListenerProxy) then + begin + (TestProject.Manager as IProjectManager).RemoveListener(FTestListenerProxy); + FTestListenerProxy.ReleaseListeners; + end; +end; + +procedure TITestResult.SetError(idx: Integer; AnError: TTestFailure); +begin + if Assigned(AnError) then + FErrors.Add(AnError); +end; + +procedure TITestResult.SetFailure(idx: Integer; AFailure: TTestFailure); +begin + if Assigned(AFailure) then + FFailures.Add(AFailure); +end; + +procedure TITestResult.SetWarning(idx: Integer; AFailure: TTestFailure); +begin + if Assigned(AFailure) then + FWarnings.Add(AFailure); +end; + +constructor TITestResult.Create; +begin + inherited Create; + FFailures := TInterfaceList.Create; + FErrors := TInterfaceList.Create; + FWarnings := TInterfaceList.Create; + FStop := false; + FRunTests := 0; +end; + +destructor TITestResult.Destroy; +begin + FTestListenerProxy := nil; + FWarnings := nil; + FErrors := nil; + FFailures := nil; + inherited; +end; + +procedure TITestResult.ReleaseListeners; +begin + try + if Assigned(FTestListenerProxy) then + FTestListenerProxy.ReleaseListeners; + finally + FTestListenerProxy := nil; + end; +end; + +function TITestResult.get_ErrorCount: Integer; +begin + Result := FErrorCount; +end; + +function TITestResult.get_ExcludedCount: integer; +begin + Result := FExcludedCount; +end; + +procedure TITestResult.set_ExcludedCount(const Value: integer); +begin + FExcludedCount := Value; +end; + +function TITestResult.get_FailureCount: Integer; +begin + Result := FFailureCount; +end; + +function TITestResult.GetError(idx: Integer): TTestFailure; +begin + Result := nil; + if (idx >= 0) and (idx < FErrors.Count) then + Result := (FErrors[idx]) as TTestFailure; +end; + +function TITestResult.GetFailure(idx: Integer): TTestFailure; +begin + Result := nil; + if (idx >= 0) and (idx < FFailures.Count) then + Result := FFailures[idx] as TTestFailure; +end; + +function TITestResult.GetWarning(idx: Integer): TTestFailure; +begin + Result := nil; + if (idx >= 0) and (idx < FWarnings.Count) then + Result := (FWarnings[idx]) as TTestFailure; +end; + +function TITestResult.get_BreakOnFailures: boolean; +begin + Result := FBreakOnFailures; +end; + +function TITestResult.get_ChecksCalledCount: Integer; +begin + Result := FChecksCalledCount; +end; + +procedure TITestResult.set_ChecksCalledCount(const Value: Integer); +begin + FChecksCalledCount := Value; +end; + +function TITestResult.get_FailsIfMemoryLeaked: boolean; +begin + Result := FFailsIfMemoryLeaked; +end; + +function TITestResult.get_FailsIfNoChecksExecuted: boolean; +begin + Result := FFailsIfNoChecksExecuted; +end; + +function TITestResult.get_IgnoresMemoryLeakInSetUpTearDown: boolean; +begin + Result := FIgnoresMemoryLeakInSetUpTearDown; +end; + +function TITestResult.get_Overrides: Integer; +begin + Result := FOverrides; +end; + +function TITestResult.get_TotalTime: Extended; +begin + Result := FTotalTime; +end; + +function TITestResult.get_WarningCount: Integer; +begin + Result := FWarningCount; +end; + +function TITestResult.get_WasStopped: Boolean; +begin + Result := FWasStopped; +end; + +function TITestResult.get_RunCount: Integer; +begin + Result := FRunTests; +end; + +procedure TITestResult.Stop; +begin + FStop := true; +end; + +function TITestResult.WasSuccessful: Boolean; +begin + Result := (FailureCount = 0) and (ErrorCount = 0) and not WasStopped; +end; + +procedure TITestResult.set_BreakOnFailures(const Value: boolean); +begin + FBreakOnFailures := Value; +end; + +procedure TITestResult.set_ErrorCount(const Value: Integer); +begin + FErrorCount := Value; +end; + +procedure TITestResult.set_FailsIfMemoryLeaked(const Value: boolean); +begin + FFailsIfMemoryLeaked := Value; +end; + +procedure TITestResult.set_FailsIfNoChecksExecuted(const Value: boolean); +begin + FFailsIfNoChecksExecuted := Value; +end; + +procedure TITestResult.set_FailureCount(const Value: Integer); +begin + FFailureCount := Value; +end; + +procedure TITestResult.set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); +begin + FIgnoresMemoryLeakInSetUpTearDown := Value; +end; + +procedure TITestResult.set_Overrides(const Value: Integer); +begin + FOverrides := Value; +end; + +procedure TITestResult.set_RunCount(const Value: Integer); +begin + FRunTests := Value; +end; + +procedure TITestResult.set_TotalTime(const Value: Extended); +begin + FTotalTime := Value; +end; + +procedure TITestResult.set_WarningCount(const Value: Integer); +begin + FWarningCount := Value; +end; + +procedure TITestResult.set_WasStopped(const Value: Boolean); +begin + FWasStopped := Value; +end; + +function PtrToStr(P: PtrType): string; +begin + // 2009-07-15 graemeg + // I guess we can cast to Pointer here, even though the compiler complains. + Result := Format('%p', [Pointer(P)]) +end; + +function AddrsToStr(Addrs: PtrType): string; +begin + if Addrs > 0 then + Result := '$'+PtrToStr(Addrs) + else + Result := 'n/a'; +end; + +function PointerToLocationInfo(Addrs: PtrType): string; +var + _line: Integer; + _file: string; +begin + // TODO: Extract file and line info from backtrace +// if _file <> '' then +// Result := Format('%s:%d', [_file, _line]); + Result := BackTraceStrFunc(Pointer(Addrs)); +// else +// Result := string(_module); + if Trim(Result) = '' then + Result := AddrsToStr(Addrs) + ' '; +end; + +function PointerToAddressInfo(Addrs: PtrType): string; +begin + Result := AddrsToStr(Addrs); +end; + +{ TITestFailure } + +function TITestFailure.AddressInfo: string; +begin + Result := PointerToAddressInfo(ThrownExceptionAddress); +end; + +procedure TITestFailure.CaptureStackTrace; +var + LTrace: TStrings; +begin + LTrace := TStringList.Create; + try + { TODO -cStackTrace : See DumpStack for details } + {$IFDEF USE_JEDI_JCL} + JclDebug.JclLastExceptStackListToStrings(LTrace, true); + {$ENDIF} + FStackTrace := LTrace.Text; + finally + LTrace.Free; + end; +end; + +constructor TITestFailure.Create(const FailedTest: ITestProxy; + const ThrownExceptionClass: ExceptClass; + const AMsg: string; + const Addrs: PtrType; + const ShowStack: boolean); +begin + inherited Create; + FFailedTest := FailedTest; + if (ThrownExceptionClass = nil) then + FThrownExceptionClassName := 'ETestFailure' + else + FThrownExceptionClassName := ThrownExceptionClass.ClassName; + FThrownExceptionMessage := AMsg; + FThrownExceptionAddress := Addrs; + if ShowStack then + CaptureStackTrace + else + FStackTrace := ''; +end; + +function TITestFailure.FailedTest: ITestProxy; +begin + Result := FFailedTest; +end; + +function TITestFailure.LocationInfo: string; +begin + Result := PointerToLocationInfo(ThrownExceptionAddress); +end; + +function TITestFailure.StackTrace: string; +begin + Result := FStackTrace; +end; + +function TITestFailure.ThrownExceptionAddress: PtrType; +begin + Result := FThrownExceptionAddress; +end; + +function TITestFailure.ThrownExceptionMessage: string; +begin + Result := FThrownExceptionMessage; +end; + +function TITestFailure.ThrownExceptionName: string; +begin + Result := FThrownExceptionClassName +end; + +{ TTestProxy } + +function TTestProxy.CountEnabledTestCases: Integer; +begin + Projects.Reset; + Result := Projects.Count; +end; + +constructor TTestProxy.Create; +begin + inherited Create; + FITestList := TInterfaceList.Create; +end; + +destructor TTestProxy.Destroy; +begin // Delibarately release refs so tests go down early + FITest := nil; // Release ref to this proxy's ITest. + FITestList := nil; // Release the list of contained proxys + FTestName := ''; // Releasing string early helps isolate other leaks + inherited; +end; + +function TTestProxy.ElapsedTestTime: Extended; +begin + Result := FITest.ElapsedTime; +end; + +function TTestProxy.GetEnabled: Boolean; +begin + Result := FITest.Enabled; +end; + +function TTestProxy.GetFailsOnNoChecksExecuted: Boolean; +begin + Result := FITest.FailsOnNoChecksExecuted; +end; + +function TTestProxy.GetExcluded: Boolean; +begin + Result := FITest.Excluded; +end; + +procedure TTestProxy.SetExcluded(Value: Boolean); +begin + FITest.Excluded := Value; +end; + +function TTestProxy.GetAllowedMemoryLeakSize: Integer; +begin + Result := 0; + if FITest.IsTestMethod then + Result := FITest.AllowedMemoryLeakSize +end; + +function TTestProxy.GetFailsOnMemoryLeak: Boolean; +begin + Result := FITest.FailsOnMemoryLeak; +end; + +function TTestProxy.GetFailsOnMemoryRecovery: Boolean; +begin + Result := FFailsOnMemoryRecovery; +end; + +procedure TTestProxy.SetFailsOnMemoryLeak(const Value: Boolean); +begin + FITest.FailsOnMemoryLeak := Value; +end; + +function TTestProxy.GetIgnoreSetUpTearDownLeaks: Boolean; +begin + Result := FITest.IgnoresMemoryLeakInSetUpTearDown; +end; + +procedure TTestProxy.SetIgnoreSetUpTearDownLeaks(const Value: Boolean); +begin + FITest.IgnoresMemoryLeakInSetUpTearDown := Value; +end; + +procedure TTestProxy.SetAllowedMemoryLeakSize(const NewSize: Integer); +begin + FAllowedLeakList[0] := NewSize; +end; + +procedure TTestProxy.SetFailsOnNoChecksExecuted(const Value: Boolean); +begin + FITest.FailsOnNoChecksExecuted := Value; +end; + +function TTestProxy.GetGUIObject: TObject; +begin + Result := FGUIObject; +end; + +function TTestProxy.GetName: string; +var + LTest: ITest; +begin + Result := ''; + if FITest = nil then + Exit; + + if FITest.ParentTestCase <> nil then + begin + Result := FITest.ParentTestCase.GetName; + Exit; + end; + + LTest := FITest.CurrentTest; + if Assigned(LTest) then + Result := LTest.GetName + else + Result := FITest.DisplayedName; +end; + +function TTestProxy.GetStatus: string; +begin + Result := FITest.GetStatus; +end; + +function TTestProxy.get_IsTestMethod: boolean; +begin + Result := FITest.IsTestMethod; +end; + +function TTestProxy.ParentPath: string; +begin + Result := FITest.ParentPath; +end; + +procedure TTestProxy.LoadConfiguration(const FileName: string; + const useRegistry, useMemIni: Boolean); +begin + (TestProject.Manager as IProjectManager).LoadConfiguration(FileName, useRegistry, useMemIni); +end; + +procedure TTestProxy.SaveConfiguration(const FileName: string; + const useRegistry, useMemIni: Boolean); +begin + (TestProject.Manager as IProjectManager).SaveConfiguration(FileName, useRegistry, useMemIni); +end; + +procedure TTestProxy.ReleaseTests; +var + i: Integer; +begin + for i := FITestList.Count - 1 downto 0 do + begin + (FITestList.Items[i] as ITestProxy).ReleaseTests; + end; + if Assigned(FITest) then + begin + FITest.Proxy := nil; + FITest.ParentTestCase := nil; + end; + FITest := nil; +end; + +procedure TTestProxy.Run(const TestResult: ITestResult); +var + LExecControl: ITestExecControl; +begin + TestResult.FailsIfNoChecksExecuted := Projects.FailsOnNoChecksExecuted; + TestResult.InhibitSummaryLevelChecks := Projects.InhibitSummaryLevelChecks; + {$IFDEF FASTMM} + TestResult.FailsIfMemoryLeaked := Projects.FailsOnMemoryLeak; + TestResult.IgnoresMemoryLeakInSetUpTearDown := Projects.IgnoresMemoryLeakInSetUpTearDown; + {$ENDIF} + + LExecControl := Projects.ExecutionControl; + LExecControl.HaltExecution := False; + LExecControl.BreakOnFailures := TestResult.BreakOnFailures; + LExecControl.ClearCounts; + LExecControl.FailsOnNoChecksExecuted := Projects.FailsOnNoChecksExecuted; + LExecControl.InhibitSummaryLevelChecks := Projects.InhibitSummaryLevelChecks; + {$IFDEF FASTMM} + LExecControl.FailsOnMemoryLeak := Projects.FailsOnMemoryLeak; + LExecControl.IgnoresMemoryLeakInSetUpTearDown := Projects.IgnoresMemoryLeakInSetUpTearDown; + {$ENDIF} + Projects.Run(LExecControl); + TestResult.WasStopped := (Self.FITest.ExecStatus = _Break) or + (Self.FITest.ExecStatus = _HaltTest); +end; + +function TTestProxy.Run(const Listeners: array of ITestListener): ITestResult; +var + idx: Integer; + LTestResult: ITestResult; +begin + Result := nil; + LTestResult := GetTestResult; + if Length(Listeners) = 0 then + Exit; + + for idx := 0 to Length(Listeners) - 1 do + if Assigned(Listeners[idx]) then + LTestResult.addListener(Listeners[idx]); + + Run(LTestResult); + Result := LTestResult; +end; + +function TTestProxy.Run(const AListener: ITestListener): ITestResult; +begin + Result := Run([AListener]); +end; + +procedure TTestProxy.HaltTesting; +var + LExecControl: ITestExecControl; +begin + // Projects.ExecutionControl returns a reference to the project's ExecControl instance. + LExecControl := Projects.ExecutionControl; + LExecControl.HaltExecution := True; + LExecControl := nil; +end; + +procedure TTestProxy.SetEnabled(Value: Boolean); +begin + FITest.Enabled := Value; +end; + +procedure TTestProxy.SetGUIObject(const GUIObject: TObject); +begin + FGUIObject := GUIObject; +end; + +function TTestProxy.Tests: IInterfaceList; +begin + Result := FITestList; +end; + +function TTestProxy.Updated: boolean; +var + LSummaryData: IProgressSummary; +begin + Result := False; + if FITest.IsTestMethod then + Exit; + + LSummaryData := ((FITest as ITestCase).ProgressSummary as IProgressSummary); + if LSummaryData = nil then + Exit; + + Result := LSummaryData.Updated; + FErrors := LSummaryData.Errors; + FFailures := LSummaryData.Failures; + FTestExecuted := LSummaryData.TestsExecuted; + FWarnings := LSummaryData.Warnings; +end; + +procedure ClearRegistry; +begin + UnRegisterProjectManager; +end; + +function TTestProxy.get_ExecutedStatus: TExecutionStatus; +begin + Result := FExecutionStatus; +end; + +procedure TTestProxy.set_ExecutedStatus(const Value: TExecutionStatus); +begin + FExecutionStatus := Value; +end; + +function TTestProxy.get_Errors: Integer; +begin + Result := FErrors; +end; + +procedure TTestProxy.set_Errors(const Value: Integer); +begin + FErrors := Value; +end; + +function TTestProxy.get_Failures: Integer; +begin + Result := FFailures; +end; + +procedure TTestProxy.set_Failures(const Value: Integer); +begin + FFailures := Value; +end; + +function TTestProxy.get_IsWarning: boolean; +begin + Result := FIsWarning; +end; + +function TTestProxy.get_LeakAllowed: boolean; +begin + Result := FITest.LeakAllowed; +end; + +function TTestProxy.get_TestsExecuted: Integer; +begin + Result := FTestExecuted; +end; + +procedure TTestProxy.set_TestsExecuted(const Value: Integer); +begin + FTestExecuted := Value; +end; + +function TTestProxy.get_Warnings: Integer; +begin + Result := FWarnings; +end; + +procedure TTestProxy.set_Warnings(const Value: Integer); +begin + FWarnings := Value; +end; + +procedure TTestProxy.set_IsWarning(const Value: boolean); +begin + FIsWarning := Value; +end; + +function TTestProxy.SupportedIfaceType: TSupportedIface; +begin + if Assigned(FITest) then + Result := FITest.SupportedIfaceType + else + Result := _Other; +end; + +function TTestProxy.get_IsOverridden: boolean; +begin + Result := FIsOverridden; +end; + +procedure TTestProxy.set_IsOverridden(const Value: boolean); +begin + FIsOverridden := Value; +end; + +function TTestProxy.EarlyExit: boolean; +begin + Result := FITest.EarlyExit; +end; + +function TTestProxy.get_InhibitSummaryLevelChecks: boolean; +begin + Result := FITest.InhibitSummaryLevelChecks; +end; + +procedure TTestProxy.set_InhibitSummaryLevelChecks(const Value: boolean); +begin + FITest.InhibitSummaryLevelChecks := Value; +end; + +{ TTestSuiteProxy } + +constructor TTestSuiteProxy.Create(const ATestProject: ITestProject); +var + LTest: ITest; + LNext: ITest; + LTestProxy: ITestProxy; +begin + if ATestProject = nil then + Exit; + + inherited Create; + FTestName := ATestProject.DisplayedName; + ATestProject.Proxy := Self as IInterface; + FITest := ATestProject; + + LNext := nil; + LTest := ATestProject.FindFirstTest; + while Assigned(LTest) do + begin + LTestProxy := TTestSuiteProxy.Create(ATestProject, LTest, LNext); + if Assigned(LTestProxy) then + FITestList.Add(LTestProxy); + LTest := LNext; + end; +end; + +constructor TTestSuiteProxy.Create(const ATestProject: ITestProject; + const CurrentTest: ITest; out LTest: ITest); +var + LNext: ITest; + LTestProxy: ITestProxy; +begin + LTest := nil; + if not Assigned(CurrentTest) then + Exit; + + inherited Create; + FTestName := CurrentTest.DisplayedName; + CurrentTest.Proxy := Self as IInterface; + FITest := CurrentTest; + + LTest := ATestProject.FindNextTest; + while Assigned(LTest) do + begin + if (LTest.Depth <= CurrentTest.Depth) then + begin + FIsNotTestMethod := True; + Break; + end; + + if (LTest.Depth = CurrentTest.Depth) then + FIsTestMethod := True + else + begin + LTestProxy := TTestSuiteProxy.Create(ATestProject, LTest, LNext); + if Assigned(LTestProxy) then + FITestList.Add(LTestProxy); + LTest := LNext; + end; + end; +end; + +function TTestSuiteProxy.Tests: IInterfaceList; +begin + Result := FITestList; +end; + +procedure TTestSuiteProxy.TestSuiteTitle(const ATitle: string); +begin + if ATitle <> '' then + FTestName := ATitle; +end; + +{ TTestListenerProxy } + +constructor TTestListenerProxy.Create(const Value: ITestResult); +begin + inherited Create; + FTestResult := Value; + FTestListeners := TInterfaceList.Create; +end; + +destructor TTestListenerProxy.Destroy; +begin + FTestListeners := nil; + FTestResult := nil; + inherited; +end; + +function TTestListenerProxy.ShouldRunTest(const ATest: ITest): Boolean; +var + i: Integer; +begin + Result := False; + if ATest = nil then + Exit; + + for i := 0 to FTestListeners.Count - 1 do + begin + Result := (FTestListeners.Items[i] as ITestListener).ShouldRunTest(TestToProxy(ATest)); + if not Result then + Break; + end; +end; + +procedure TTestListenerProxy.AddListener(const Listener: ITestListener); +begin + if Assigned(Listener) then + FTestListeners.Add(Listener); +end; + +procedure TTestListenerProxy.UpdateTestResult; +var + LExecControl: ITestExecControl; +begin + LExecControl := Projects.ExecutionControl; + FTestResult.RunCount := LExecControl.ExecutionCount; + FTestResult.FailureCount := LExecControl.FailureCount; + FTestResult.ErrorCount := LExecControl.ErrorCount; + FTestResult.WarningCount := LExecControl.WarningCount; + FTestResult.ChecksCalledCount := LExecControl.CheckCalledCount; + FTestResult.ExcludedCount := LExecControl.ExcludedCount; + FRunningStopTime := gTimer.Elapsed; + FTestResult.TotalTime := FRunningStopTime-FRunningStartTime; + LExecControl := nil; +end; + +procedure TTestListenerProxy.StartSuite(ASuite: ITest); +var + i: Integer; +begin + if ASuite = nil then + Exit; + + for i := 0 to FTestListeners.Count - 1 do + if Supports(FTestListeners.Items[i], ITestListenerX) then + (FTestListeners.Items[i] as ITestListenerX).StartSuite(TestToProxy(ASuite)) + else + (FTestListeners.Items[i] as ITestListener).StartTest(TestToProxy(ASuite)); +end; + +procedure TTestListenerProxy.StartTest(Test: ITest); +var + i: Integer; +begin + if Test = nil then + Exit; + + for i := 0 to FTestListeners.Count - 1 do + (FTestListeners.Items[i] as ITestListener).StartTest(TestToProxy(Test)); +end; + +procedure TTestListenerProxy.TestingStarts; +var + idx: Integer; +begin + for idx := 0 to FTestListeners.Count -1 do + (FTestListeners.Items[idx] as ITestListener).TestingStarts; + + FRunningStopTime := 0.0; + FRunningStartTime := gTimer.Elapsed; +end; + +procedure TTestListenerProxy.TestingEnds; +var + idx: Integer; +begin + UpdateTestResult; + for idx := 0 to FTestListeners.Count -1 do + (FTestListeners.Items[idx] as ITestListener).TestingEnds(FTestResult); +end; + +function TTestListenerProxy.EndTestExec(const ATest: ITest):ITestProxy; +begin + Result := ATest.Proxy as ITestProxy; + Result.ExecutionStatus := ATest.ExecStatus; + Result.IsWarning := ATest.ExecStatus = _Warning; + UpdateTestResult; +end; + +procedure TTestListenerProxy.EndSuite(ASuite: ITest); +var + idx: Integer; + LProxy: ITestProxy; + LProgressSummary: IProgressSummary; + +begin + if ASuite = nil then + Exit; + + LProxy := EndTestExec(ASuite); + if not ASuite.IsTestMethod then + LProgressSummary := ((ASuite as ITestCase).ProgressSummary as IProgressSummary); + if (LProgressSummary <> nil) and LProgressSummary.Updated then + begin + LProxy.Errors := LProgressSummary.Errors; + LProxy.Failures := LProgressSummary.Failures; + LProxy.TestsExecuted := LProgressSummary.TestsExecuted; + LProxy.Warnings:= LProgressSummary.Warnings; + end; + + for idx := 0 to FTestListeners.Count - 1 do + begin + if Supports(FTestListeners.Items[idx], ITestListenerX) then + (FTestListeners.Items[idx] as ITestListenerX).EndSuite(LProxy) + else + (FTestListeners.Items[idx] as ITestListener).EndTest(LProxy); + end; +end; + +procedure TTestListenerProxy.EndTest(ATest: ITest); +var + idx: Integer; + LProxy: ITestProxy; + LErrorLevelRaised: boolean; + LTestFailure: TTestFailure; + LListener: ITestListener; +begin + if ATest = nil then + Exit; + + LProxy := EndTestExec(ATest); + + LErrorLevelRaised := (ATest.ExecStatus = _Error) and + (not ATest.IsTestMethod) and (ATest as ITestCase).ReportErrorOnce; + + case ATest.ExecStatus of + _Passed: + begin + for idx := 0 to FTestListeners.Count - 1 do + begin + LListener := (FTestListeners.Items[idx] as ITestListener); + LListener.AddSuccess(LProxy); + end; + end; + + _Warning: + if (ATest.SupportedIfaceType = _isTestMethod) then + begin + LTestFailure := TITestFailure.Create(LProxy, + ATest.ExceptionClass, + ATest.ErrorMessage, + ATest.ErrorAddress, + False); + FTestResult.Warnings[0] := LTestFailure; + for idx := 0 to FTestListeners.Count - 1 do + begin + LListener := (FTestListeners.Items[idx] as ITestListener); + LListener.AddWarning(LTestFailure); + end; + end; + + _Failed: + if (ATest.SupportedIfaceType = _isTestMethod) then + begin + LTestFailure := TITestFailure.Create(LProxy, + ATest.ExceptionClass, + ATest.ErrorMessage, + ATest.ErrorAddress, + False); + FTestResult.Failures[0] := LTestFailure; + for idx := 0 to FTestListeners.Count - 1 do + begin + LListener := (FTestListeners.Items[idx] as ITestListener); + LListener.AddFailure(LTestFailure); + end; + end; + + _Error: + if (ATest.IsTestMethod) or LErrorLevelRaised then + begin + LTestFailure := TITestFailure.Create(LProxy, + ATest.ExceptionClass, + ATest.ErrorMessage, + ATest.ErrorAddress, + True); + FTestResult.Errors[0] := LTestFailure; + for idx := 0 to FTestListeners.Count - 1 do + begin + LListener := (FTestListeners.Items[idx] as ITestListener); + LListener.AddError(LTestFailure); + end; + end; + end; + + for idx := 0 to FTestListeners.Count - 1 do + begin + LListener := (FTestListeners.Items[idx] as ITestListener); + LListener.EndTest(LProxy); + end; +end; + +procedure TTestListenerProxy.ReleaseListeners; +begin + FTestResult := nil; + FTestListeners.Clear; +end; + +procedure TTestListenerProxy.Status(const ATest: ITest; const AMessage: string); +var + i: Integer; +begin + if ATest = nil then + Exit; + + for i := 0 to FTestListeners.Count - 1 do + (FTestListeners.Items[i] as ITestListener).Status(TestToProxy(ATest), AMessage); +end; + +function TITestResult.get_InhibitSummaryLevelChecks: boolean; +begin + Result := FInhibitSummaryLevelChecks; +end; + +procedure TITestResult.set_InhibitSummaryLevelChecks(const Value: boolean); +begin + FInhibitSummaryLevelChecks := Value; +end; + +end. diff --git a/tests/fptest/src/TestFrameworkProxyIfaces.pas b/tests/fptest/src/TestFrameworkProxyIfaces.pas new file mode 100644 index 00000000..c9ba76cc --- /dev/null +++ b/tests/fptest/src/TestFrameworkProxyIfaces.pas @@ -0,0 +1,262 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is DUnit. + + The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + and Juancarlo Añez. + Portions created The Initial Developers are Copyright (C) 1999-2000. + Portions created by The DUnit Group are Copyright (C) 2000-2007. + All rights reserved. + + Contributor(s): + Kent Beck + Erich Gamma + Juanco Añez + Chris Morris + Jeff Moore + Uberto Barbini + Brett Shearer + Kris Golko + The DUnit group at SourceForge + Peter McNab + Graeme Geldenhuys +} + +unit TestFrameworkProxyIfaces; +{ This unit sits between a modified GUITestRunner and the new FPTest + TestFramework. It provides an interface to make the new TestFrameWork + look and appear to behave like the old TestFramework. Once tests are + running GUITestRunner will be gradually modified to interface more closely + with the new TestFramework. This "Proxy" unit re-creates the Tests + structure currently accessed by the treeview. } + +{$IFDEF FPC} + {$mode delphi}{$H+} +{$ENDIF} + +interface + +uses + Classes, + TestFrameworkIfaces; + +type + // forward declarations + ITestResult = interface; + ITestListener = interface; + + ITestProxy = interface + ['{D09EA9F7-3C0D-4A51-9A07-30BF202AF87C}'] + procedure SetGUIObject(const GUIObject: TObject); + function GetGUIObject: TObject; + function GetEnabled: Boolean; + procedure SetEnabled(Value: Boolean); + function GetExcluded: Boolean; + procedure SetExcluded(Value: Boolean); + function GetName: string; + function ParentPath: string; + function GetStatus :string; + function get_IsTestMethod: boolean; + function SupportedIfaceType: TSupportedIface; + function get_ExecutedStatus: TExecutionStatus; + procedure set_ExecutedStatus(const Value: TExecutionStatus); + function get_IsOverridden: boolean; + procedure set_IsOverridden(const Value: boolean); + function get_IsWarning: boolean; + procedure set_IsWarning(const Value: boolean); + function get_Errors: Integer; + procedure set_Errors(const Value: Integer); + function get_Failures: integer; + procedure set_Failures(const Value: integer); + function get_Warnings: integer; + procedure set_Warnings(const Value: integer); + function get_TestsExecuted: Integer; + procedure set_TestsExecuted(const Value: Integer); + function Updated: boolean; + procedure SetFailsOnNoChecksExecuted(const Value: Boolean); + function GetFailsOnNoChecksExecuted: Boolean; + function get_InhibitSummaryLevelChecks: boolean; + procedure set_InhibitSummaryLevelChecks(const Value: boolean); + property InhibitSummaryLevelChecks: boolean read get_InhibitSummaryLevelChecks + write set_InhibitSummaryLevelChecks; + function EarlyExit: boolean; + + function get_LeakAllowed: boolean; + property LeakAllowed: boolean read get_LeakAllowed; + function GetFailsOnMemoryLeak: Boolean; + procedure SetFailsOnMemoryLeak(const Value: Boolean); + function GetIgnoreSetUpTearDownLeaks: Boolean; + procedure SetIgnoreSetUpTearDownLeaks(const Value: Boolean); + function GetAllowedMemoryLeakSize: Integer; + procedure SetAllowedMemoryLeakSize(const NewSize: Integer); + function GetFailsOnMemoryRecovery: Boolean; + + procedure SaveConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); + procedure LoadConfiguration(const FileName: string; const useRegistry, useMemIni: Boolean); + function CountEnabledTestCases: integer; + function ElapsedTestTime: Extended; + function Tests: IInterfaceList; + procedure Run(const TestResult: ITestResult); overload; + function Run(const Listeners: array of ITestListener): ITestResult; overload; + function Run(const AListener: ITestListener): ITestResult; overload; + procedure HaltTesting; + procedure ReleaseTests; + + property GUIObject: TObject read GetGUIObject write SetGUIObject; + property Enabled: Boolean read GetEnabled write SetEnabled; + property Excluded: Boolean read GetExcluded write SetExcluded; + property Name: string read GetName; + property Status: string read GetStatus; + property IsTestMethod: boolean read get_IsTestMethod; + property ExecutionStatus: TExecutionStatus read get_ExecutedStatus + write set_ExecutedStatus; + property IsOverridden: boolean read get_IsOverridden write set_IsOverridden; + property IsWarning: boolean read get_IsWarning write set_IsWarning; + property Errors: integer read get_Errors write set_Errors; + property Failures: integer read get_Failures write set_Failures; + property Warnings: integer read get_Warnings write set_Warnings; + property TestsExecuted: integer read get_TestsExecuted write set_TestsExecuted; + property FailsOnNoChecksExecuted: Boolean + read GetFailsOnNoChecksExecuted + write SetFailsOnNoChecksExecuted; + property FailsOnMemoryLeak: Boolean read GetFailsOnMemoryLeak + write SetFailsOnMemoryLeak; + property FailsOnMemLeakDetection: boolean read GetFailsOnMemoryLeak + write SetFailsOnMemoryLeak; + property IgnoreSetUpTearDownLeaks: Boolean read GetIgnoreSetUpTearDownLeaks + write SetIgnoreSetUpTearDownLeaks; + property AllowedMemoryLeakSize: Integer read GetAllowedMemoryLeakSize + write SetAllowedMemoryLeakSize; + end; + + + ITestSuiteProxy = interface(ITestProxy) + ['{7CFE1779-1207-4D55-A0DD-BA71240F96E0}'] + procedure TestSuiteTitle(const ATitle: string); + end; + + + TTestFailure = interface + ['{C652E195-29DC-409D-B4EF-65B1EF1223F0}'] + function ThrownExceptionAddress: PtrType; + function FailedTest: ITestProxy; + function ThrownExceptionName: string; + function ThrownExceptionMessage: string; + function LocationInfo: string; + function AddressInfo: string; + function StackTrace: string; + end; + + + { IStatusListeners are notified of test status messages } + IStatusListener = interface + ['{8681DC88-033C-4A42-84F4-4C52EF9ABAC0}'] + procedure Status(const ATest: ITestProxy; AMessage: string); + end; + + + { ITestListeners get notified of testing events. + See ITestResult.AddListener() } + ITestListener = interface(IStatusListener) + ['{114185BC-B36B-4C68-BDAB-273DBD450F72}'] + procedure AddSuccess(Test: ITestProxy); + procedure AddError(Error: TTestFailure); + procedure AddFailure(Failure: TTestFailure); + procedure AddWarning(AWarning: TTestFailure); + procedure TestingStarts; + procedure StartTest(Test: ITestProxy); + procedure EndTest(Test: ITestProxy); + procedure TestingEnds(TestResult: ITestResult); + function ShouldRunTest(const ATest :ITestProxy):Boolean; + end; + + + ITestListenerX = interface(ITestListener) + ['{5C28B1BE-38B5-4D6F-AA96-A04E9302C317}'] + procedure StartSuite(Suite: ITestProxy); + procedure EndSuite(Suite: ITestProxy); + end; + + + ITestResult = interface + procedure ReleaseListeners; + function GetFailure(idx :Integer) :TTestFailure; + procedure SetFailure(idx: Integer; AFailure: TTestFailure); + function GetError(idx :Integer) :TTestFailure; + procedure SetError(idx: Integer; AnError: TTestFailure); + function GetWarning(idx :Integer) :TTestFailure; + procedure SetWarning(idx: Integer; AFailure: TTestFailure); + function get_ErrorCount: integer; + procedure set_ErrorCount(const Value: integer); + property ErrorCount: integer read get_ErrorCount write set_ErrorCount; + function get_RunCount: integer; + procedure set_RunCount(const Value: integer); + property RunCount: integer read get_RunCount write set_RunCount; + function get_FailureCount: integer; + procedure set_FailureCount(const Value: integer); + property FailureCount: integer read get_FailureCount write set_FailureCount; + function get_ChecksCalledCount: integer; + procedure set_ChecksCalledCount(const Value: integer); + property ChecksCalledCount: integer read get_ChecksCalledCount write set_ChecksCalledCount; + procedure Stop; + procedure AddListener(const Listener: ITestListener); + procedure RemoveListener(const Listener: ITestListener); + property Failures[i :Integer] :TTestFailure read GetFailure write SetFailure; + property Errors[i :Integer] :TTestFailure read GetError write SetError; + property Warnings[i :Integer] :TTestFailure read GetWarning write SetWarning; + function WasSuccessful: Boolean; + function get_WasStopped :Boolean; + procedure set_WasStopped(const Value: Boolean); + property WasStopped:Boolean read get_WasStopped write set_WasStopped; + function get_WarningCount: integer; + procedure set_WarningCount(const Value: integer); + property WarningCount: integer read get_WarningCount write set_WarningCount; + function get_ExcludedCount: Integer; + procedure set_ExcludedCount(const Value: integer); + property ExcludedCount: integer read get_ExcludedCount write set_ExcludedCount; + function get_Overrides: integer; + procedure set_Overrides(const Value: integer); + property Overrides: integer read get_Overrides write set_Overrides; + function get_TotalTime: Extended; + procedure set_TotalTime(const Value: Extended); + property TotalTime: Extended read get_TotalTime write set_TotalTime; + + function get_BreakOnFailures: boolean; + procedure set_BreakOnFailures(const Value: boolean); + property BreakOnFailures :Boolean read get_BreakOnFailures write set_BreakOnFailures; + + function get_FailsIfNoChecksExecuted: boolean; + procedure set_FailsIfNoChecksExecuted(const Value: boolean); + property FailsIfNoChecksExecuted :Boolean read get_FailsIfNoChecksExecuted + write set_FailsIfNoChecksExecuted; + function get_InhibitSummaryLevelChecks: boolean; + procedure set_InhibitSummaryLevelChecks(const Value: boolean); + property InhibitSummaryLevelChecks: boolean read get_InhibitSummaryLevelChecks + write set_InhibitSummaryLevelChecks; + + function get_FailsIfMemoryLeaked: boolean; + procedure set_FailsIfMemoryLeaked(const Value: boolean); + property FailsIfMemoryLeaked :Boolean read get_FailsIfMemoryLeaked + write set_FailsIfMemoryLeaked; + function get_IgnoresMemoryLeakInSetUpTearDown: boolean; + procedure set_IgnoresMemoryLeakInSetUpTearDown(const Value: boolean); + property IgnoresMemoryLeakInSetUpTearDown: Boolean + read get_IgnoresMemoryLeakInSetUpTearDown + write set_IgnoresMemoryLeakInSetUpTearDown; + end; + + +implementation + +end. diff --git a/tests/fptest/src/TestListenerIface.pas b/tests/fptest/src/TestListenerIface.pas new file mode 100644 index 00000000..cf64a731 --- /dev/null +++ b/tests/fptest/src/TestListenerIface.pas @@ -0,0 +1,86 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is DUnit. + + The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + and Juancarlo Añez. + Portions created The Initial Developers are Copyright (C) 1999-2000. + Portions created by The DUnit Group are Copyright (C) 2000-2007. + All rights reserved. + + Contributor(s): + Kent Beck + Erich Gamma + Juanco Añez + Chris Morris + Jeff Moore + Uberto Barbini + Brett Shearer + Kris Golko + The DUnit group at SourceForge + Peter McNab + Graeme Geldenhuys +} + +unit TestListenerIface; + +{$IFDEF FPC} + {$mode delphi}{$H+} +{$ENDIF} + +interface + +uses + TestFrameworkIfaces, + TestFrameworkProxyIfaces; + +type + IProgressSummary = interface + ['{9F32649C-6E3B-46E6-A94F-9E17A2A8175A}'] + + function get_Errors: Integer; + function get_Failures: Integer; + function get_Warnings: Integer; + function get_TestsExcluded: Integer; + function get_TestsExecuted: Cardinal; + function Updated: boolean; + procedure UpdateSummary(const ExecControl: ITestExecControl); + property Errors: Integer read get_Errors; + property Failures: Integer read get_Failures; + property Warnings: Integer read get_Warnings; + property TestsExecuted: Cardinal read get_TestsExecuted; + property TestsExcluded: Integer read get_TestsExcluded; + end; + + ITestListenerProxy = interface + ['{0B14441B-7193-4250-94B3-216F802ED665}'] + + procedure AddListener(const Listener: ITestListener); overload; + procedure TestingStarts; + procedure StartSuite(Suite: ITest); + procedure StartTest(Test: ITest); + procedure EndTest(Test: ITest); + procedure EndSuite(Suite: ITest); + procedure TestingEnds; + procedure ReleaseListeners; + function ShouldRunTest(const ATest :ITest) :Boolean; + procedure Status(const ATest: ITest; const AMessage: string); + end; + +const + cnRunners = 'DUnitCommon'; + +implementation + +end. diff --git a/tests/fptest/src/TestModules.pas b/tests/fptest/src/TestModules.pas new file mode 100644 index 00000000..6e2e32d0 --- /dev/null +++ b/tests/fptest/src/TestModules.pas @@ -0,0 +1,133 @@ +{ $Id: TestModules.pas,v 1.7 2006/07/19 02:45:55 judc Exp $ } +{: DUnit: An XTreme testing framework for Delphi programs. + @author The DUnit Group. + @version $Revision: 1.7 $ 2001/03/08 uberto +} +{#(@)$Id: $ } +{ DUnit: An XTreme testing framework for Delphi programs. } +(* + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is DUnit. + * + * The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + * and Juancarlo Añez. + * Portions created The Initial Developers are Copyright (C) 1999-2000. + * Portions created by The DUnit Group are Copyright (C) 2000-2008. + * All rights reserved. + * + * Contributor(s): + * Kent Beck + * Erich Gamma + * Juanco Añez + * Chris Morris + * Jeff Moore + * Uberto Barbini + * Brett Shearer + * Kris Golko + * The DUnit group at SourceForge + * Peter McNab + * + ******************************************************************************* +*) +unit TestModules; + +interface +uses + Windows, + TestFrameworkIFaces; + +const + rcs_id :string = '#(@)$Id: TestModules.pas,v 1.7 2006/07/19 02:45:55 judc Exp $'; + +type + TModuleRecord = record + Handle :THandle; + Test :ITestCase; + end; + + TGetTestFunc = function :ITestProject; + +var + __Modules :array of TModuleRecord = nil; + +function LoadModuleTests(LibName: string) :ITestProject; +procedure RegisterModuleTests(LibName: string); +procedure UnloadTestModules; + +implementation +uses + TestFramework, + SysUtils; + +function LoadModuleTests(LibName: string) :ITestProject; +var + LibHandle: THandle; + GetTest: TGetTestFunc; + U: IUnknown; +begin + Result := nil; + if ExtractFileExt(LibName) = '' then + begin + LibName := ChangeFileExt(LibName, '.dll'); + if not FileExists(LibName) then + LibName := ChangeFileExt(LibName, '.dtl'); + end; + + LibHandle := LoadLibrary(PChar(LibName)); + if LibHandle = 0 then + raise EDUnitException.Create(Format('Could not load module %s: %s', [LibName, SysErrorMessage(GetLastError)])) + else + begin + GetTest := GetProcAddress(LibHandle, 'Test'); + if not Assigned(GetTest) then + raise EDUnitException.Create(Format('Module "%s" does not export a "Test" function: %s', [LibName, SysErrorMessage(GetLastError)])) + else + begin + U := GetTest; + Assert(U <> nil, 'Cannot retrieve interface from DLL ' + LibName); + + try + Result := (U as ITestProject); + Result.DisplayedName := LibName; + SetLength(__Modules, 1 + Length(__Modules)); + __Modules[High(__Modules)].Handle := LibHandle; + __Modules[High(__Modules)].Test := Result; + except + on E: Exception do + raise EDUnitException.Create(Format('Module "%s.Test" did not return an ITestProject', [LibName])) + end; + end; + end; +end; + +procedure RegisterModuleTests(LibName: string); +begin + RegisterProject(ExtractFileName(LibName), LoadModuleTests(LibName)); +end; + +procedure UnloadTestModules; +var + i :Integer; +begin + for i := Low(__Modules) to High(__Modules) do + begin + __Modules[i].Test := nil; + FreeLibrary(__Modules[i].Handle); + end; + __Modules := nil; +end; + +initialization + +finalization + UnloadTestModules; +end. diff --git a/tests/fptest/src/TextTestRunner.pas b/tests/fptest/src/TextTestRunner.pas new file mode 100644 index 00000000..4c5882e4 --- /dev/null +++ b/tests/fptest/src/TextTestRunner.pas @@ -0,0 +1,500 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is DUnit. + + The Initial Developers of the Original Code are Kent Beck, Erich Gamma, + and Juancarlo Añez. + Portions created The Initial Developers are Copyright (C) 1999-2000. + Portions created by The DUnit Group are Copyright (C) 2000-2007. + All rights reserved. + + Contributor(s): + Kent Beck + Erich Gamma + Juanco Añez + Chris Morris + Jeff Moore + Uberto Barbini + Brett Shearer + Kris Golko + The DUnit group at SourceForge + Peter McNab + Graeme Geldenhuys +} + +unit TextTestRunner; + +{$IFDEF FPC} + {$mode delphi}{$H+} + {$UNDEF FASTMM} +{$ENDIF} + +{.$DEFINE XMLLISTENER} + +interface + +uses + Classes, + TestFrameworkProxyIfaces; + +type + TRunnerExitBehavior = ( + rxbContinue, + rxbPause, + rxbHaltOnFailures + ); + +type + TTextTestListener = class(TInterfacedObject, ITestListener, ITestListenerX) + private + FErrors: IInterfaceList; + FFailures: IInterfaceList; + FWarnings: IInterfaceList; + FStartTime: TDateTime; + FEndTime: TDateTime; + FRunTime: TDateTime; + function FailedTestInfo(const AFailure: TTestFailure): string; + class function IniFileName: string; + protected + // implement the IStatusListener interface + procedure Status(const ATest: ITestProxy; AMessage: string); + + // implement the ITestListener interface + procedure AddSuccess(Test: ITestProxy); virtual; + procedure AddError(Error: TTestFailure); virtual; + procedure AddFailure(Failure: TTestFailure); virtual; + procedure AddWarning(AWarning: TTestFailure); virtual; + procedure TestingStarts; virtual; + procedure StartTest(Test: ITestProxy); virtual; + procedure EndTest(Test: ITestProxy); virtual; + procedure TestingEnds(ATestResult: ITestResult); virtual; + function ShouldRunTest(const ATest :ITestProxy):boolean; virtual; + + // Implement the ITestListenerX interface + procedure StartSuite(Suite: ITestProxy); virtual; + procedure EndSuite(Suite: ITestProxy); virtual; + + property Errors: IInterfaceList read FErrors; + property Failures: IInterfaceList read FFailures; + property Warnings: IInterfaceList read FWarnings; + function Report(r: ITestResult): string; + function PrintErrors(r: ITestResult): string; virtual; + function PrintFailures(r: ITestResult): string; virtual; + function PrintWarnings(r: ITestResult): string; virtual; + function PrintHeader(r: iTestResult): string; virtual; + function PrintSettings(r: ITestResult): string; virtual; + function PrintWarningItems(r: iTestResult): string; virtual; + function PrintFailureItems(r: ITestResult): string; virtual; + function PrintErrorItems(r: ITestResult): string; virtual; + property StartTime: TDateTime read FStartTime write FStartTime; + property EndTime: TDateTime read FEndTime write FEndTime; + property RunTime: TDateTime read FRunTime write FRunTime; + public + constructor Create; + destructor Destroy; override; + end; + + {: This type defines what the RunTest and RunRegisteredTests methods will do when + testing has ended. + @enum rxbContinue Just return the TestResult. + @enum rxbPause Pause with a ReadLn before returnng the TestResult. + @enum rxbHaltOnFailures Halt the program if errors or failures occurred, setting + the program exit code to FailureCount+ErrorCount; + behave like rxbContinue if all tests suceeded. + @seeAlso + @seeAlso + } + +{ Run the given Test Suite } +function RunTest(Suite: ITestProxy; exitBehavior: TRunnerExitBehavior = rxbContinue): ITestResult; overload; +function RunRegisteredTests: ITestResult; overload; +function RunRegisteredTests(const AExitBehavior: TRunnerExitBehavior): ITestResult; overload; + +implementation +uses + TestFrameworkProxy, + {$IFDEF XMLLISTENER} + XMLListener, + {$ENDIF} + SysUtils, + strutils, + TimeManager; + +const + {$IFDEF FPC} + CRLF = LineEnding; + {$ELSE} + CRLF = #13#10; + {$ENDIF} + +var + uIndent: integer; + +function Indent: string; +begin + Result := DupeString(' ', uIndent); +end; + +procedure _PrintTestTree(ATest: ITestProxy); +var + TestTests: IInterfaceList; + i: Integer; + lStatus: string; +begin + if ATest = nil then + Exit; //==> + if ATest.Enabled then + lStatus := '[x] ' + else + lStatus := '[ ] '; + writeln(Indent + lStatus + ATest.Name); + Inc(uIndent, 2); + TestTests := ATest.Tests; + for i := 0 to TestTests.count - 1 do + _PrintTestTree(TestTests[i] as ITestProxy); + Dec(uIndent, 2); +end; + +procedure PrintTestTree; +begin + uIndent := 0; + RegisteredTests.LoadConfiguration(TTextTestListener.IniFileName, False, False); + _PrintTestTree(RegisteredTests); +end; + + +class function TTextTestListener.IniFileName: string; +const + TEST_INI_FILE = 'fptest.ini'; +begin + { TODO : Find writeable output path } + result := {LocalAppDataPath +} TEST_INI_FILE; +end; + +procedure TTextTestListener.AddSuccess(Test: ITestProxy); +begin + // No display for successes +end; + +constructor TTextTestListener.Create; +begin + inherited Create; + FErrors := TInterfaceList.Create; + FFailures := TInterfaceList.Create; + FWarnings := TInterfaceList.Create; +end; + +destructor TTextTestListener.Destroy; +begin + FWarnings := nil; + FErrors := nil; + FFailures := nil; + inherited; +end; + +procedure TTextTestListener.AddError(Error: TTestFailure); +begin + FErrors.Add(Error); + write('E'); +end; + +procedure TTextTestListener.AddFailure(Failure: TTestFailure); +begin + FFailures.Add(Failure); + write('F'); +end; + +procedure TTextTestListener.AddWarning(AWarning: TTestFailure); +begin + FWarnings.Add(AWarning); + write('W'); +end; + +{ Prints failures to the standard output } +function TTextTestListener.Report(r: ITestResult): string; +var + LHeader: string; + LErrors: string; + LFailures: string; + LWarnings: string; +begin + LHeader := PrintHeader(r); + LErrors := PrintErrors(r); + LFailures := PrintFailures(r); + LWarnings := PrintWarnings(r); + + Result := LHeader + + LErrors + + LFailures + + LWarnings; +end; + +function TTextTestListener.FailedTestInfo(const AFailure: TTestFailure): string; +begin + Result := format('%s: %s'+ CRLF +' at %s'+ CRLF +'%s', + [ + AFailure.failedTest.ParentPath + '.' + AFailure.FailedTest.Name, + AFailure.thrownExceptionName, + AFailure.LocationInfo, + AFailure.thrownExceptionMessage + ]) + CRLF + CRLF; +end; + +function TTextTestListener.PrintWarningItems(r: ITestResult): string; +var + i: Integer; + Failure: TTestFailure; +begin + Result := ''; + for i := 0 to FWarnings.Count-1 do + begin + Failure := FWarnings.Items[i] as TTestFailure; + Result := Result + format('%3d) ', [i+1]) + FailedTestInfo(Failure); + end; +end; + +function TTextTestListener.PrintFailureItems(r: ITestResult): string; +var + i: Integer; + Failure: TTestFailure; +begin + Result := ''; + for i := 0 to r.FailureCount-1 do + begin + Failure := r.Failures[i]; + Result := Result + format('%3d) ', [i+1]) + FailedTestInfo(Failure); + end; +end; + +function TTextTestListener.PrintErrorItems(r: ITestResult): string; +var + i: Integer; + Failure: TTestFailure; +begin + Result := ''; + for i := 0 to FErrors.Count-1 do + begin + Failure := FErrors.Items[i] as TTestFailure; + Result := Result + format('%3d) ', [i+1]) + FailedTestInfo(Failure); + end; +end; + +{ Prints the errors to the standard output } +function TTextTestListener.PrintErrors(r: ITestResult): string; +begin + Result := ''; + if (r.ErrorCount <> 0) then begin + if (r.ErrorCount = 1) then + Result := Result + format('There was %d error:', [r.ErrorCount]) + CRLF + else + Result := Result + format('There were %d errors:', [r.ErrorCount]) + CRLF; + + Result := Result + CRLF + PrintErrorItems(r); + Result := Result + CRLF; + end +end; + +{ Prints failures to the standard output } +function TTextTestListener.PrintFailures(r: ITestResult): string; +begin + Result := ''; + if (r.FailureCount <> 0) then + begin + if (r.FailureCount = 1) then + Result := Result + format('There was %d failure:', [r.FailureCount]) + CRLF + else + Result := Result + format('There were %d failures:', [r.FailureCount]) + CRLF; + + Result := Result + CRLF + PrintFailureItems(r); + Result := Result + CRLF; + end +end; + +{ Prints warnings to the standard output } +function TTextTestListener.PrintWarnings(r: ITestResult): string; +begin + Result := ''; + if (r.WarningCount <> 0) then begin + if (r.WarningCount = 1) then + Result := Result + format('There was %d warning:', [r.WarningCount]) + CRLF + else + Result := Result + format('There were %d warnings:', [r.WarningCount]) + CRLF; + + Result := Result + CRLF + PrintWarningItems(r); + Result := Result + CRLF; + end +end; + +{ Prints the setting used } +function TTextTestListener.PrintSettings(r: ITestResult): string; +begin + Result := ''; + if RegisteredTests = nil then + Exit; + + if r.FailsIfNoChecksExecuted then + Result := Result + 'Test fails if Check() not executed in test' + CRLF; +{$IFDEF FASTMM} + if r.FailsIfMemoryLeaked then + begin + if r.IgnoresMemoryLeakInSetUpTearDown then + Result := Result + 'Test fails if memory leak detected in test method excluding SetUp and TearDown' + CRLF + else + Result := Result + 'Test fails if memory leak detected in test' + CRLF; + end; +{$ENDIF} + Result := Result + CRLF; +end; + +{ Prints the header of the Report } +function TTextTestListener.PrintHeader(r: ITestResult): string; +begin + Result := ''; + if r.wasSuccessful then + begin + Result := Result + CRLF; + Result := Result + PrintSettings(r); + Result := Result + format('OK: %d tests'+CRLF, [r.RunCount]); + end + else + begin + Result := Result + CRLF; + Result := Result + PrintSettings(r); + Result := Result + 'Test Results:'+CRLF; + Result := Result + format('Run: %8d'+CRLF+'Errors: %8d'+CRLF+'Failures: %8d'+CRLF+'Warnings: %8d'+CRLF, + [r.RunCount, r.ErrorCount, r.FailureCount, r.WarningCount] + ) + CRLF; + end +end; + +procedure TTextTestListener.StartTest(Test: ITestProxy); +begin + if Test.IsTestMethod then + write('.'); +end; + +procedure TTextTestListener.EndTest(Test: ITestProxy); +begin + // Nothing to do here +end; + +procedure TTextTestListener.TestingStarts; +begin + writeln; + writeln('FPTest / Testing'); + FStartTime := now; +end; + +procedure TTextTestListener.TestingEnds(ATestResult: ITestResult); +begin + FEndTime := now; + FRunTime := FEndTime - FStartTime; + writeln; + if Assigned(ATestResult) then + begin + writeln('Time: ' + ElapsedDHMS(ATestResult.TotalTime)); + writeln(Report(ATestResult)); + end; +end; + +function RunTest(Suite: ITestProxy; exitBehavior: TRunnerExitBehavior = rxbContinue): ITestResult; +begin + Result := nil; + try + if Suite = nil then + writeln('No tests registered') + else + try + Suite.LoadConfiguration(TTextTestListener.IniFileName, False, False); + Result := RunTest(Suite,[TTextTestListener.Create + {$IFDEF XMLLISTENER} + , TXMLListener.Create({LocalAppDataPath +} Suite.Name + {, 'type="text/xsl" href="fpcunit2.xsl"'}) + {$ENDIF} + ]); + finally + Suite.SaveConfiguration(TTextTestListener.IniFileName, False, False); + Result.ReleaseListeners; + Suite.ReleaseTests; + end; + finally + case exitBehavior of + rxbPause: + begin + writeln('Press to continue.'); + readln; + end; + rxbHaltOnFailures: + if Assigned(Result) then + with Result do + begin + if not WasSuccessful then + System.Halt(ErrorCount+FailureCount); + end + end; + end; +end; + +function RunRegisteredTests: ITestResult; +var + LExitBehavior: TRunnerExitBehavior; +begin + // To run with rxbPause, use -p switch + // To run with rxbHaltOnFailures, use -h switch + // No switch runs as rxbContinue + if FindCmdLineSwitch('p', ['-', '/'], true) then + LExitBehavior := rxbPause + else if FindCmdLineSwitch('h', ['-', '/'], true) then + LExitBehavior := rxbHaltOnFailures + else + LExitBehavior := rxbContinue; + + // list the registered tests and exit + if FindCmdLineSwitch('l', ['-', '/'], True) then + begin + PrintTestTree; + Exit; //==> + end; + + Result := RunTest(RegisteredTests, LExitBehavior); +end; + +function RunRegisteredTests(const AExitBehavior: TRunnerExitBehavior): ITestResult; +begin + Result := RunTest(RegisteredTests, AExitBehavior); +end; + +procedure TTextTestListener.Status(const ATest: ITestProxy; AMessage: string); +begin + writeln(Format('%s: %s', [ATest.Name, AMessage])); +end; + +function TTextTestListener.ShouldRunTest(const ATest :ITestProxy):boolean; +begin + Result := not ATest.Excluded ; // Call here for every enabled Test. + if not Result then + Write('x'); +end; + +procedure TTextTestListener.EndSuite(Suite: ITestProxy); +begin + // Nothing to do here +end; + +procedure TTextTestListener.StartSuite(Suite: ITestProxy); +begin + // Nothing to do here +end; + +end. diff --git a/tests/fptest/src/XMLListener.pas b/tests/fptest/src/XMLListener.pas new file mode 100644 index 00000000..9e714cbe --- /dev/null +++ b/tests/fptest/src/XMLListener.pas @@ -0,0 +1,505 @@ +{ + DUnit: An XTreme testing framework for Delphi and Free Pascal programs. + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + All rights reserved. + + Contributor(s): + Peter McNab + Graeme Geldenhuys +} + +unit XMLListener; + +{$IFDEF FPC} + {$mode delphi}{$H+} +{$ENDIF} + +{$ifdef selftest} + {$define ShowClass} +{$endif} + +interface + +uses + Contnrs, + {$IFDEF FPC} + dom, XMLWrite, + {$ELSE} + // Chosen because it does not drag in any other units e.g. TComponent + xdom, + {$ENDIF} + TestFrameworkProxyIfaces; + +type + + IXMLStack = interface + ['{CC96971E-E712-475D-A8AB-1BE7EB96092D}'] + function Pop: TDomElement; + procedure Push(const ANode: TDomElement); + function Empty: boolean; + function Top: TDomElement; + end; + + + TXMLListener = class(TInterfacedObject, ITestListener, ITestListenerX) + private + FAppPath: string; + FAppName: string; + FDocName: string; + FStack: IXMLStack; + FXMLDoc: TdomDocument; + procedure AppendComment(const AComment: string); + procedure AppendElement(const AnElement: string); + function CurrentElement: TDomElement; + procedure MakeElementCurrent(const AnElement: TDomElement); + function PreviousElement: TDomElement; + procedure AddResult(const ATitle, AValue: string); + procedure AppendLF; + procedure AddNamedValue(const AnAttrib: TDomElement; const AName: string; AValue: string); + procedure AddNamedText(const ANode: TDomElement; const AName: string; const AMessage: string); + procedure AddFault(const AnError: TTestFailure; const AFault: string); + protected + function UnEscapeUnknownText(const UnKnownText: string): string; virtual; + procedure AddSuccess(Test: ITestProxy); virtual; + procedure AddError(AnError: TTestFailure); virtual; + procedure AddFailure(AnError: TTestFailure); virtual; + procedure AddWarning(AnError: TTestFailure); virtual; + procedure TestingStarts; virtual; + procedure StartSuite(Suite: ITestProxy); virtual; + procedure StartTest(Test: ITestProxy); virtual; + procedure EndTest(Test: ITestProxy); virtual; + procedure EndSuite(Suite: ITestProxy); virtual; + procedure TestingEnds(TestResult: ITestResult); virtual; + function ShouldRunTest(const ATest :ITestProxy):Boolean; virtual; + procedure Status(const ATest: ITestProxy; AMessage: string); virtual; + public + constructor Create(const ExePathFileName: string); overload; + constructor Create(const ExePathFileName: string; const PIContent: string); overload; + destructor Destroy; override; + end; + + +implementation +uses + TestFrameworkIfaces, + Classes, + SysUtils, + TimeManager; + +const + milliSecsToDays = 1/86400000; + cxmlExt = '.xml'; + cxmlStylesheet = 'xml-stylesheet'; + cElapsedTime = 'ElapsedTime'; + cNumberOfErrors = 'NumberOfErrors'; + cNumberOfFailures = 'NumberOfFailures'; + cNumberOfRunTests = 'NumberOfRunTests'; + cNumberOfWarnings = 'NumberOfWarnings'; + cNumberOfExcludedTests = 'NumberOfExcludedTests'; + cNumberOfChecksCalled = 'NumberOfChecksCalled'; + cTotalElapsedTime = 'TotalElapsedTime'; + cDateTimeRan = 'DateTimeRan'; + cyyyymmddhhmmss = 'yyyy-mm-dd hh:mm:ss'; + chhnnsszz = 'hh:nn:ss.zzz'; + cTestResults = 'TestResults'; + cTestListing = 'TestListing'; + cName = 'Name'; + cExceptionClass = 'ExceptionClass'; + cExceptionMessage = 'ExceptionMessage'; + cMessage = 'Message'; + cTest = 'Test'; + cResult = 'Result'; + cError = 'Error'; + cFailed = 'Failed'; + cWarning = 'Warning'; + cOK = 'OK'; + cTitle = 'Title'; + cTitleText = 'FPTest XML test report'; + cGeneratedBy = 'Generated using FPTest on '; + cEncoding = 'UTF-8'; + cTestSuite = 'TestSuite'; + cTestCase = {$ifdef ShowClass} 'TestCase' {$else} cTestSuite {$endif}; + cTestDecorator = {$ifdef ShowClass} 'TestDecorator' {$else} cTestSuite {$endif}; + cTestProject = {$ifdef ShowClass} 'TestProject' {$else} cTestSuite {$endif}; + + +{ TXMLStack } + +type + TXMLStack = class(TInterfacedObject, IXMLStack) + private + FStack: TFPObjectList; + protected + function Pop: TDomElement; + procedure Push(const ANode: TDomElement); + function Empty: boolean; + function Top: TDomElement; + public + constructor Create; + destructor Destroy; override; + end; + +constructor TXMLStack.Create; +begin + inherited Create; + FStack := TFPObjectList.Create(False); +end; + +destructor TXMLStack.Destroy; +begin + FStack.Destroy; + inherited Destroy; +end; + +function TXMLStack.Empty: boolean; +begin + Result := FStack.Count = 0; +end; + +function TXMLStack.Pop: TDomElement; +var + idx: integer; +begin + if Empty then + Result := nil + else + begin + idx := FStack.Count-1; + Result := FStack.Items[idx] as TDomElement; + FStack.Delete(idx); + end; +end; + +procedure TXMLStack.Push(const ANode: TDomElement); +begin + FStack.Add(ANode); +end; + +function TXMLStack.Top: TDomElement; +begin + if Empty then + Result := nil + else + Result := FStack.Items[FStack.Count-1] as TDomElement; +end; + + +{ TXMLListener } + +constructor TXMLListener.Create(const ExePathFileName: string); +begin + Create(ExePathFileName, ''); +end; + +constructor TXMLListener.Create(const ExePathFileName: string; const PIContent: string); +var + LDomElement: TDomElement; +begin + inherited Create; + FStack := TXMLStack.Create; + FAppPath := ExtractFilePath(ExePathFileName); + FAppName := ExtractFileName(ExePathFileName); + FDocName := ChangeFileExt(FAppName, cxmlExt); + FXMLDoc := TDOMDocument.Create{$IFNDEF FPC}(nil){$ENDIF}; + {$IFNDEF FPC} + { TODO -cFPC : XMLDoc needs an Encoding parameter. } + FXMLDoc.Encoding := cEncoding; + {$ENDIF} + if PIContent <> '' then + FXMLDoc.AppendChild(FXMLDoc.CreateProcessingInstruction(cxmlStylesheet, PIContent)); + LDomElement := FXMLDoc.CreateElement(cTestResults); + FXMLDoc.AppendChild(LDomElement); + MakeElementCurrent(LDomElement); + AppendLF; + AppendComment(cGeneratedBy + FormatDateTime(cyyyymmddhhmmss, Now)); +end; + +destructor TXMLListener.Destroy; +var + Stream: TFileStream; + S: string; + sl: TStringList; +begin + {$IFDEF FPC} + WriteXML(FXMLDoc, FAppPath + FDocName); +// S := FXMLDoc.TextContent; + {$ELSE} + Stream := TFileStream.Create(FAppPath + FDocName, fmCreate or fmOpenWrite); + try + S := FXMLDoc.code; + Stream.Write(S[1], Length(S)); + finally + FreeAndNil(Stream); + end; + {$ENDIF} + FStack := nil; + FreeAndNil(FXMLDoc); + inherited Destroy; +end; + +{------------------- Functions that operate on the stack ----------------------} + +function TXMLListener.CurrentElement: TDomElement; +begin + Result := FStack.Top; +end; + +procedure TXMLListener.MakeElementCurrent(const AnElement: TDomElement); +begin + FStack.Push(AnElement); +end; + +function TXMLListener.PreviousElement: TDomElement; +begin + Result := FStack.Pop; +end; + +{------------------- Functions that collect associated actions ----------------} + +procedure TXMLListener.AppendLF; +begin + CurrentElement.appendChild(FXMLDoc.createTextNode(#10)); +end; + +procedure TXMLListener.AppendElement(const AnElement: string); +var + LDomElement: TDomElement; +begin + LDomElement := FXMLDoc.createElement(AnElement); + CurrentElement.appendChild(LDomElement); + AppendLF; + MakeElementCurrent(LDomElement); +end; + +procedure TXMLListener.AppendComment(const AComment: string); +begin + CurrentElement.appendChild(FXMLDoc.CreateComment(AComment)); + AppendLF; +end; + +procedure TXMLListener.AddResult(const ATitle: string; const AValue: string); +var + LElement: TDomElement; + E: Exception; +begin + LElement := FXMLDoc.createElement(ATitle); + LElement.appendChild(FXMLDoc.createTextNode(UnEscapeUnknownText(AValue))); + if (CurrentElement <> nil) then + begin + CurrentElement.appendChild(LElement); + AppendLF; + end + else + begin + E := Exception.Create('XMLListener: No corresponding opening tag for ' + + ATitle + ' Final value = ' + AValue); + raise E; + end; +end; + +procedure TXMLListener.AddNamedValue(const AnAttrib: TDomElement; const AName: string; AValue: string); +var + LAttrib: TdomAttr; +begin + LAttrib := FXMLDoc.createAttribute(AName); + LAttrib.value := AValue; + AnAttrib.setAttributeNode(LAttrib); +end; + +procedure TXMLListener.AddNamedText(const ANode: TDomElement; const AName: string; const AMessage: string); +var + LDomElement: TDomElement; +begin + LDomElement := FXMLDoc.createElement(AName); + LDomElement.appendChild(FXMLDoc.createTextNode(UnEscapeUnknownText(AMessage))); + ANode.appendChild(LDomElement); + AppendLF; +end; + +{--------------------- These are ITestListener functions ----------------------} + +function TXMLListener.ShouldRunTest(const ATest: ITestProxy): Boolean; +begin + Result := True; +end; + +procedure TXMLListener.StartSuite(Suite: ITestProxy); +begin +// Nothing required here but the procedure must be includes to match the interface. +end; + +procedure TXMLListener.Status(const ATest: ITestProxy; AMessage: string); +begin +// Nothing required here but the procedure must be includes to match the interface. +end; + +procedure TXMLListener.EndSuite(Suite: ITestProxy); +begin +// Nothing required here but the procedure must be includes to match the interface. +end; + +{--------------------- Active ITestListener functions -------------------------} + +procedure TXMLListener.TestingStarts; +begin + AppendElement(cTestListing); +end; + +function TXMLListener.UnEscapeUnknownText(const UnKnownText: string): string; +begin + Result := UnKnownText; +end; + +procedure TXMLListener.StartTest(Test: ITestProxy); +var + LTestElement: TDomElement; + + procedure AddClassName(const AClassName: string); + begin + LTestElement := FXMLDoc.createElement(AClassName); + AddNamedValue(LTestElement, cName, UnEscapeUnknownText(Test.Name)); + CurrentElement.appendChild(LTestElement); + MakeElementCurrent(LTestElement); + AppendLF; + end; + + +begin {TXMLListener.StartTest(Test: ITestProxy);} + if not Assigned(Test) or (CurrentElement = nil) then + Exit; + + if not Test.IsTestMethod then + begin + case Test.SupportedIfaceType of + _isTestCase: AddClassName(cTestCase); + _isTestSuite: AddClassName(cTestSuite); + _isTestDecorator: AddClassName(cTestDecorator); + _isTestProject: AddClassName(cTestProject); + end; + end; +end; + +procedure TXMLListener.EndTest(Test: ITestProxy); +begin + if not Assigned(Test) then + Exit; + + if Ord(Test.ExecutionStatus) > Ord(_Running) then + begin + if (CurrentElement = nil) then + Exit; + + case Test.SupportedIfaceType of + _isTestCase, + _isTestSuite, + _isTestProject, + _isTestDecorator: + begin + AddNamedValue(CurrentElement, cElapsedTime, ElapsedDHMS(Test.ElapsedTestTime)); + if Test.Updated then + begin + AddNamedValue(CurrentElement, cNumberOfErrors, IntToStr(Test.Errors)); + AddNamedValue(CurrentElement, cNumberOfFailures, IntToStr(Test.Failures)); + AddNamedValue(CurrentElement, cNumberOfWarnings, IntToStr(Test.Warnings)); + AddNamedValue(CurrentElement, cNumberOfRunTests, IntToStr(Test.TestsExecuted)); + end; + PreviousElement; + end; + end; {case} + end; +end; + +procedure TXMLListener.TestingEnds(TestResult: ITestResult); +begin + if not Assigned(TestResult) or (CurrentElement = nil) then + Exit; + + AddNamedValue(CurrentElement, cElapsedTime, ElapsedDHMS(TestResult.TotalTime)); + AddNamedValue(CurrentElement, cNumberOfErrors, IntToStr(TestResult.ErrorCount)); + AddNamedValue(CurrentElement, cNumberOfFailures, IntToStr(TestResult.FailureCount)); + AddNamedValue(CurrentElement, cNumberOfRunTests, IntToStr(TestResult.RunCount)); + AddNamedValue(CurrentElement, cNumberOfWarnings, IntToStr(TestResult.WarningCount)); + AddNamedValue(CurrentElement, cNumberOfChecksCalled, IntToStr(TestResult.ChecksCalledCount)); + + while (CurrentElement <> nil) and (CurrentElement.tagName <> cTestResults) do + PreviousElement; + + AddResult(cTitle, cTitleText); + AddResult(cNumberOfRunTests, IntToStr(TestResult.RunCount)); + AddResult(cNumberOfErrors, IntToStr(TestResult.ErrorCount)); + AddResult(cNumberOfFailures, IntToStr(TestResult.FailureCount)); + AddResult(cNumberOfWarnings, IntToStr(TestResult.WarningCount)); + AddResult(cNumberOfExcludedTests, IntToStr(TestResult.ExcludedCount)); + AddResult(cNumberOfChecksCalled, IntToStr(TestResult.ChecksCalledCount)); + AddResult(cTotalElapsedTime, ElapsedDHMS(TestResult.TotalTime)); + AddResult(cDateTimeRan, FormatDateTime(cyyyymmddhhmmss, Now)); +end; + +procedure TXMLListener.AddSuccess(Test: ITestProxy); +var + LOKTest: TDomElement; +begin + if not Assigned(Test) or (CurrentElement = nil) then + Exit; + + if Test.IsTestMethod then + begin + LOKTest := FXMLDoc.createElement(cTest); + AddNamedValue(LOKTest, cName, UnEscapeUnknownText(Test.Name)); + AddNamedValue(LOKTest, cResult, cOK); + AddNamedValue(LOKTest, cElapsedTime, ElapsedDHMS(Test.ElapsedTestTime)); + CurrentElement.appendChild(LOKTest); + AppendLF; + end; +end; + +procedure TXMLListener.AddFault(const AnError: TTestFailure; + const AFault: string); +var + LBadTest: TDomElement; +begin + if not Assigned(AnError) or (CurrentElement = nil) then + Exit; + LBadTest := FXMLDoc.createElement(cTest); + AddNamedValue(LBadTest, cName, UnEscapeUnknownText(AnError.FailedTest.Name)); + AddNamedValue(LBadTest, cResult, AFault); + AddNamedValue(LBadTest, cElapsedTime, ElapsedDHMS(AnError.FailedTest.ElapsedTestTime)); + AppendLF; + + AddNamedText(LBadTest, cMessage, AnError.FailedTest.ParentPath + '.' + + AnError.FailedTest.Name + ': ' + AnError.ThrownExceptionMessage); + AddNamedText(LBadTest, cExceptionClass, AnError.ThrownExceptionName); + AddNamedText(LBadTest, cExceptionMessage, AnError.ThrownExceptionMessage); + CurrentElement.appendChild(LBadTest); + AppendLF; +end; + +procedure TXMLListener.AddWarning(AnError: TTestFailure); +begin + AddFault(AnError, cWarning); +end; + +procedure TXMLListener.AddError(AnError: TTestFailure); +begin + AddFault(AnError, cError); +end; + +procedure TXMLListener.AddFailure(AnError: TTestFailure); +begin + AddFault(AnError, cFailed); +end; + + +end. + + diff --git a/tests/fptest/src/fpchelper.pas b/tests/fptest/src/fpchelper.pas new file mode 100644 index 00000000..9aa604be --- /dev/null +++ b/tests/fptest/src/fpchelper.pas @@ -0,0 +1,74 @@ +{ + This unit only applies to the Free Pascal Compiler. + + Copyright (c) 2009 by Graeme Geldenhuys + All rights reserved. +} +unit fpchelper; + +{$mode objfpc}{$H+} + +interface + +uses + Classes, SysUtils; + +procedure GetMethodList(AObject: TObject; AList: TStrings); overload; +procedure GetMethodList(AClass: TClass; AList: TStrings); overload; + + +implementation + + +// Get a list of published methods for a given class or object +procedure GetMethodList(AObject: TObject; AList: TStrings); +begin + GetMethodList(AObject.ClassType, AList); +end; + +// Code copied form objpas.inc: class function TObject.MethodAddress() +{$PUSH} +{$RANGECHECKS OFF} +procedure GetMethodList(AClass: TClass; AList: TStrings); +type + TMethodNameRec = packed record + name: pshortstring; + addr: pointer; + end; + + TMethodNameTable = packed record + count: dword; + entries: packed array[0..0] of TMethodNameRec; + end; + + PMethodNameTable = ^TMethodNameTable; + +var + MethodTable: PMethodNameTable; + i: dword; + ovmt: PVmt; + idx: integer; +begin + AList.Clear; + ovmt := PVmt(aClass); + while Assigned(ovmt) do + begin + MethodTable := PMethodNameTable(ovmt^.vMethodTable); + if Assigned(MethodTable) then + begin + for i := 0 to MethodTable^.count - 1 do + begin + idx := AList.IndexOf(MethodTable^.entries[i].name^); + if (idx <> - 1) then + //found overridden method so delete it + AList.Delete(idx); + AList.AddObject(MethodTable^.entries[i].name^, TObject(MethodTable^.entries[i].addr)); + end; + end; + ovmt := ovmt^.vParent; + end; +end; +{$POP} + +end. + diff --git a/tests/fptest/src/timemanager.pas b/tests/fptest/src/timemanager.pas new file mode 100644 index 00000000..b3c0aa0f --- /dev/null +++ b/tests/fptest/src/timemanager.pas @@ -0,0 +1,72 @@ +{ + This unit pulls in the EpikTimer dependency. EpikTimer is platform + independent and replaces Windows.QueryPerformanceCounter() calls. +} +unit TimeManager; + +{$mode objfpc}{$H+} + +interface + +uses + EpikTimer; + +// Simple singleton to access the timer. +function gTimer: TEpikTimer; + +// Convert elapsed time in seconds.milliseconds into human readable DD:HH:MM:SS.zzz string format +function ElapsedDHMS(const AElapsed: Extended; const APrecision: integer = 3; const AWantDays: boolean = false; const AWantMS: boolean = True): String; + + +implementation + +uses + SysUtils; + +var + uTimer: TEpikTimer; + +function gTimer: TEpikTimer; +begin + if not Assigned(uTimer) then + uTimer := TEpikTimer.Create(nil); + Result := uTimer; +end; + + +// Convert elapsed time in seconds.milliseconds into human readable DD:HH:MM:SS.zzz string format +function ElapsedDHMS(const AElapsed: Extended; const APrecision: integer = 3; const AWantDays: boolean = false; const AWantMS: boolean = True): String; +var + Tmp, MS: extended; + D, H, M, S: Integer; + P, SM: string; +begin + Tmp := AElapsed; + P := inttostr(APrecision); + MS := frac(Tmp); + SM:=format('%0.'+P+'f',[MS]); + delete(SM,1,1); + D := trunc(Tmp / 84600); + Tmp:=Trunc(tmp) mod 84600; + H := trunc(Tmp / 3600); + Tmp:=Trunc(Tmp) mod 3600; + M := Trunc(Tmp / 60); + S:=(trunc(Tmp) mod 60); + If AWantDays then + Result := format('%2.3d:%2.2d:%2.2d:%2.2d',[D,H,M,S]) + else + Result := format('%2.2d:%2.2d:%2.2d',[H,M,S]); + If AWantMS then + Result := Result+SM; +end; + + + +initialization + uTimer := nil; + +finalization + uTimer.Free; + +end. + From 1efa7f48764f84fc9358e43e35ee5e9f3b90b8ec Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 1 Jan 2024 12:12:57 +0100 Subject: [PATCH 03/12] Remove old test files --- tests/testinit.pas | 56 ------------------------------------------- tests/testversion.pas | 56 ------------------------------------------- 2 files changed, 112 deletions(-) delete mode 100644 tests/testinit.pas delete mode 100644 tests/testversion.pas diff --git a/tests/testinit.pas b/tests/testinit.pas deleted file mode 100644 index eefd363d..00000000 --- a/tests/testinit.pas +++ /dev/null @@ -1,56 +0,0 @@ -program testinit; - -{ - - Test initilization of SDL2 system with a sample of flags. - - This file is part of - - SDL2-for-Pascal - Copyright (C) 2020-2022 PGD Community - Visit: https://github.com/PascalGameDevelopment/SDL2-for-Pascal - -} - -{$I testsettings.inc} - -uses - Classes, SysUtils, SDL2; - -type - ESDL2Error = class(Exception); - -const - Flags: array[0..12] of TSDL_Init = ( - { single flags } - SDL_INIT_TIMER, SDL_INIT_AUDIO, SDL_INIT_VIDEO, - SDL_INIT_JOYSTICK, SDL_INIT_HAPTIC, SDL_INIT_GAMECONTROLLER, - SDL_INIT_EVENTS, SDL_INIT_SENSOR, SDL_INIT_NOPARACHUTE, - SDL_INIT_EVERYTHING, - { typically combined flags } - SDL_INIT_AUDIO or SDL_INIT_VIDEO, - SDL_INIT_VIDEO or SDL_INIT_JOYSTICK, - SDL_INIT_VIDEO or SDL_INIT_GAMECONTROLLER or SDL_INIT_AUDIO); - -var - Flag: TSDL_Init; -begin - write('Start SDL2 inilization test... '); - for Flag in Flags do - begin - try - if SDL_Init(Flag) <> 0 then - raise ESDL2Error.Create('SDL_Init failed: Flag = ' + IntToStr(Flag)); - except - on E: ESDL2Error do - try - SDL_Quit; - except - raise; - end; - end; - SDL_Quit; - end; - writeln(' finished.'); -end. - diff --git a/tests/testversion.pas b/tests/testversion.pas deleted file mode 100644 index 5526b28c..00000000 --- a/tests/testversion.pas +++ /dev/null @@ -1,56 +0,0 @@ -program testversion; - -{ - - Test version macros/functions of SDL2 system. - - This file is part of - - SDL2-for-Pascal - Copyright (C) 2020-2022 PGD Community - Visit: https://github.com/PascalGameDevelopment/SDL2-for-Pascal - -} - -{$I testsettings.inc} - -uses - Classes, SysUtils, SDL2; - -type - ESDL2Error = class(Exception); - -var - CompiledVersion: TSDL_Version = (major: 0; minor: 0; patch: 0); - LinkedVersion: TSDL_Version = (major: 0; minor: 0; patch: 0); - VersionNum: Cardinal = 0; -begin - write('Start SDL2 version test... '); - - try - VersionNum := SDL_VERSIONNUM(1,2,3); - if (VersionNum <> 1203) then - raise ESDL2Error.Create('SDL_VERSIONNUM failed: 1203 expected, found: ' + IntToStr(VersionNum)); - - SDL_VERSION(CompiledVersion); - if (SDL_COMPILEDVERSION <> SDL_VERSIONNUM(CompiledVersion.major, CompiledVersion.minor, CompiledVersion.patch)) then - raise ESDL2Error.Create('SDL_VERSION or SDL_COMPILEDVERSION failed: Version results do not match!'); - - if not SDL_VERSION_ATLEAST(2,0,0) then - raise ESDL2Error.Create('SDL_VERSION_ATLEAST failed: Version at least 2.0.0 should be true!'); - - if SDL_VERSION_ATLEAST(3,0,0) then - raise ESDL2Error.Create('SDL_VERSION_ATLEAST failed: Version at least 3.0.0 should be false!'); - - SDL_GetVersion(@LinkedVersion); - if @LinkedVersion = nil then - raise ESDL2Error.Create('SDL_GetVersion failed: ' + SDL_GetError()); - - if SDL_VERSIONNUM(LinkedVersion.major, LinkedVersion.minor, LinkedVersion.patch) = 0 then - raise ESDL2Error.Create('SDL_GetVersion failed: Returns 0.0.0 .'); - except - end; - - writeln('finished.'); -end. - From 95d75269d686862f1b664ccc4868d4f29b4c689b Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 1 Jan 2024 12:26:02 +0100 Subject: [PATCH 04/12] Compile and run fptest test framework on Linux - trigger GHAction on test branch (temporarily) - run on Linux only (temporarily) - removed old tests from workflow --- .github/workflows/ci.yml | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f789c40e..aea841fc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2,12 +2,14 @@ name: CI on: push: - branches: [ master ] + branches: [ master, use-fptest ] pull_request: branches: [ master ] jobs: macos-11-big-sur: + # skip job temporarily + if: false runs-on: macos-11 steps: - name: Install FPC @@ -112,25 +114,18 @@ jobs: verbosity: ewnh - name: Install SDL2 library run: sudo apt-get install libsdl2-dev - - name: Test 1 - Compile Init Test + - name: Compile SDL2-for-Pascal Test Framework (fptest) and Test Cases uses: suve/GHActions-FPC@v0.4.0 with: - source: tests/testinit.pas + source: tests/sdl2forpascaltests.pas + flags: Fuunits Futests/fptest/src Futests/fptest/3rdparty/epiktimer verbosity: ewnh - - name: Test 1 - Run Init Test + - name: Run SDL2-for-Pascal Tests run: | - mkdir ~/tmp - export XDG_RUNTIME_DIR=~/tmp - ./tests/testinit - - name: Test 2 - Compile Version Test - uses: suve/GHActions-FPC@v0.4.0 - with: - source: tests/testversion.pas - verbosity: ewnh - - name: Test 2 - Run Version Test - run: | - ./tests/testversion + ./tests/sdl2forpascaltests windows-2022: + # skip job temporarily + if: false runs-on: windows-2022 steps: - name: Install Lazarus From 0e3b81c797d0566f701843094ea06e8aab2cc7f2 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 1 Jan 2024 19:49:53 +0100 Subject: [PATCH 05/12] Compile and run fptest test framework on Mac --- .github/workflows/ci.yml | 22 ++++++---------------- 1 file changed, 6 insertions(+), 16 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index aea841fc..dfc428da 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -8,8 +8,7 @@ on: jobs: macos-11-big-sur: - # skip job temporarily - if: false + # if: false (uncomment to skip job) runs-on: macos-11 steps: - name: Install FPC @@ -54,24 +53,15 @@ jobs: run: | sdl2-config --version sdl2-config --libs - - name: Test 1 - Compile Init Test - uses: suve/GHActions-FPC@v0.4.0 - with: - source: tests/testinit.pas - flags: Fl/usr/local/lib - verbosity: ewnh - - name: Test 1 - Run Init Test - run: | - ./tests/testinit - - name: Test 2 - Compile Version Test + - name: Compile SDL2-for-Pascal Test Framework (fptest) and Test Cases uses: suve/GHActions-FPC@v0.4.0 with: - source: tests/testversion.pas - flags: Fl/usr/local/lib + source: tests/sdl2forpascaltests.pas + flags: Fl/usr/local/lib Fuunits Futests/fptest/src Futests/fptest/3rdparty/epiktimer verbosity: ewnh - - name: Test 2 - Run Version Test + - name: Run SDL2-for-Pascal Tests run: | - ./tests/testversion + ./tests/sdl2forpascaltests ubuntu-20-04: runs-on: ubuntu-20.04 steps: From 930c9ea2094580b272253bc2119895c0032ca6e7 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 1 Jan 2024 20:18:05 +0100 Subject: [PATCH 06/12] Fix Mac compilation - this fix is identical to this unmerged pull request: https://github.com/graemeg/epiktimer/pull/4 --- tests/fptest/3rdparty/epiktimer/epiktimer.pas | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/fptest/3rdparty/epiktimer/epiktimer.pas b/tests/fptest/3rdparty/epiktimer/epiktimer.pas index ac29d34c..16d5bd0d 100644 --- a/tests/fptest/3rdparty/epiktimer/epiktimer.pas +++ b/tests/fptest/3rdparty/epiktimer/epiktimer.pas @@ -416,6 +416,7 @@ function SystemTicks: TickType; begin Result := _GetTickCount; {$ELSE} +begin Result := GetTickCount64; {$ENDIF} {$ENDIF} From b0b9f8c57520cb3e4ec91a94fa6aa24abebf7723 Mon Sep 17 00:00:00 2001 From: Matthias Date: Tue, 2 Jan 2024 01:35:24 +0100 Subject: [PATCH 07/12] Compile fptest test framework on Win --- .github/workflows/ci.yml | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index dfc428da..20ae986d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -63,6 +63,7 @@ jobs: run: | ./tests/sdl2forpascaltests ubuntu-20-04: + # if: false (uncomment to skip job) runs-on: ubuntu-20.04 steps: - name: Install FPC @@ -114,8 +115,7 @@ jobs: run: | ./tests/sdl2forpascaltests windows-2022: - # skip job temporarily - if: false + # if: false (uncomment to skip job) runs-on: windows-2022 steps: - name: Install Lazarus @@ -153,14 +153,14 @@ jobs: with: source: units/sdl2_ttf.pas verbosity: ewnh - - name: Test 1 - Compile Init Test + - name: Compile SDL2-for-Pascal Test Framework (fptest) and Test Cases uses: suve/GHActions-FPC@v0.4.0 with: - source: tests/testinit.pas - flags: Flunits + source: tests/sdl2forpascaltests.pas + flags: Fuunits Futests/fptest/src Futests/fptest/3rdparty/epiktimer verbosity: ewnh # !!! Since no SDL2.DLL is available via chocolatey, the run will fail. # TODO: Find solution to install SDL2 binary. - # - name: Test 1 - Run Init Test - # run: | - # ./tests/testinit.exe + #- name: Run SDL2-for-Pascal Tests + # run: | + # ./tests/sdl2forpascaltests.exe From 45b44f936bc51e696a6a30c1aaa805299f208fc2 Mon Sep 17 00:00:00 2001 From: Matthias Date: Tue, 2 Jan 2024 01:36:36 +0100 Subject: [PATCH 08/12] Use checkout-action version 4 --- .github/workflows/ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 20ae986d..34cdd8fd 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -16,7 +16,7 @@ jobs: brew update brew install fpc - name: Checkout code - uses: actions/checkout@v2 + uses: actions/checkout@v4 - name: Compile SDL2 unit uses: suve/GHActions-FPC@v0.4.0 with: @@ -72,7 +72,7 @@ jobs: sudo apt update sudo apt install fpc - name: Checkout code - uses: actions/checkout@v2 + uses: actions/checkout@v4 - name: Compile SDL2 unit uses: suve/GHActions-FPC@v0.4.0 with: @@ -122,7 +122,7 @@ jobs: run: | choco install lazarus - name: Checkout code - uses: actions/checkout@v2 + uses: actions/checkout@v4 - name: Compile SDL2 unit uses: suve/GHActions-FPC@v0.4.0 with: From 02f0f2549e0b7f690b922d729642167f96ca1435 Mon Sep 17 00:00:00 2001 From: Matthias Date: Tue, 2 Jan 2024 02:26:01 +0100 Subject: [PATCH 09/12] Add SDL2.dll for Win tests --- tests/dll/README-SDL.txt | 13 +++++++++++++ tests/dll/SDL2.dll | Bin 0 -> 2500096 bytes 2 files changed, 13 insertions(+) create mode 100644 tests/dll/README-SDL.txt create mode 100644 tests/dll/SDL2.dll diff --git a/tests/dll/README-SDL.txt b/tests/dll/README-SDL.txt new file mode 100644 index 00000000..8d92955a --- /dev/null +++ b/tests/dll/README-SDL.txt @@ -0,0 +1,13 @@ + +Please distribute this file with the SDL runtime environment: + +The Simple DirectMedia Layer (SDL for short) is a cross-platform library +designed to make it easy to write multi-media software, such as games +and emulators. + +The Simple DirectMedia Layer library source code is available from: +https://www.libsdl.org/ + +This library is distributed under the terms of the zlib license: +http://www.zlib.net/zlib_license.html + diff --git a/tests/dll/SDL2.dll b/tests/dll/SDL2.dll new file mode 100644 index 0000000000000000000000000000000000000000..e26bcb1c3be11930053e594bc070df85b68d7b89 GIT binary patch literal 2500096 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 z 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

p8THZl>=Z*WV>>e!jO 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

`xC#E0b* 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

qAy3zD@$9HyC!Q5ERU|eOAz7Nm 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¥j_1e#wb-0+ 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 EBiywM6uI@4kz*WW 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

<>oJ>g3J=k%=qWKwlk0u}y7}9S#%j=v8TP#(H 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%0Ae&f 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

ECnrBxpR7 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 FaVw2SrPo#I{M67g>F9&xGI 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 Tf`~3v_adw(D9G~vLx2AVOrMt) literal 0 HcmV?d00001 From f27f48cd8f84a8cf9e301e77b48182bbf96dd43f Mon Sep 17 00:00:00 2001 From: Matthias Date: Tue, 2 Jan 2024 02:26:55 +0100 Subject: [PATCH 10/12] Run tests under Win --- .github/workflows/ci.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 34cdd8fd..94790f12 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -153,14 +153,14 @@ jobs: with: source: units/sdl2_ttf.pas verbosity: ewnh + - name: Copy SDL2 library file to execution folder + run: copy tests/dll/SDL2.dll tests - name: Compile SDL2-for-Pascal Test Framework (fptest) and Test Cases uses: suve/GHActions-FPC@v0.4.0 with: source: tests/sdl2forpascaltests.pas flags: Fuunits Futests/fptest/src Futests/fptest/3rdparty/epiktimer verbosity: ewnh - # !!! Since no SDL2.DLL is available via chocolatey, the run will fail. - # TODO: Find solution to install SDL2 binary. - #- name: Run SDL2-for-Pascal Tests - # run: | - # ./tests/sdl2forpascaltests.exe + - name: Run SDL2-for-Pascal Tests + run: | + ./tests/sdl2forpascaltests.exe From 479806b069b467f260514a5622bc58a038bb5d85 Mon Sep 17 00:00:00 2001 From: Matthias Date: Tue, 2 Jan 2024 14:09:17 +0100 Subject: [PATCH 11/12] Add infos about tests --- tests/README.md | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/tests/README.md b/tests/README.md index 018847a0..62d0b20d 100644 --- a/tests/README.md +++ b/tests/README.md @@ -1,5 +1,18 @@ -# Tests folder +# Tests for SDL2-for-Pascal Units + +## Goal +These test cases are meant to ensure a basic quality of the +SDL2-for-Pascal units. + +## Testing Framework +We use the [fptest](https://github.com/graemeg/fptest) testing framework to +perform the testing. We modified it slightly in that it allows for checking +of (classic) pointers. Also we applied a +[fix](https://github.com/graemeg/epiktimer/pull/4) to the +[EpikTimer](https://wiki.freepascal.org/EpikTimer) unit. + +## Write a test +Just add a test case to *sdl2testcases.pas*. + -See issue #22. -Delete this file if the first test has been added. From d35d3200811a062386df64b58a58a082597f0f32 Mon Sep 17 00:00:00 2001 From: Matthias Date: Wed, 3 Jan 2024 01:39:42 +0100 Subject: [PATCH 12/12] update README.md --- tests/README.md | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/tests/README.md b/tests/README.md index 62d0b20d..f40fc32a 100644 --- a/tests/README.md +++ b/tests/README.md @@ -2,17 +2,22 @@ ## Goal These test cases are meant to ensure a basic quality of the -SDL2-for-Pascal units. +[SDL2-for-Pascal Units](https://github.com/PascalGameDevelopment/SDL2-for-Pascal). ## Testing Framework We use the [fptest](https://github.com/graemeg/fptest) testing framework to -perform the testing. We modified it slightly in that it allows for checking -of (classic) pointers. Also we applied a -[fix](https://github.com/graemeg/epiktimer/pull/4) to the -[EpikTimer](https://wiki.freepascal.org/EpikTimer) unit. +perform the testing. For more details on this framework see the _README.adoc_ file. -## Write a test -Just add a test case to *sdl2testcases.pas*. +We modified it: +- many accompanied files (e. g. demo files) are not shipped (go to +[fptest](https://github.com/graemeg/fptest) to get the full package) +- it allows for checking of (classic) pointers now +- we applied a [fix](https://github.com/graemeg/epiktimer/pull/4) to the +[EpikTimer](https://wiki.freepascal.org/EpikTimer) unit + +## Writing a test +Just add a test case to *sdl2testcases.pas* by extending the test classes or +add a new test class if suitable.