//#define UseMutable
template<typename DataType>
class ObjCObjectHolder {
protected:
DataType rData = nil;
protected:
#ifdef UseMutable
virtual
#endif
void setData (DataType aData)
{
ASSIGN(rData, aData);
}
public:
ObjCObjectHolder () : rData(nil)
{
}
ObjCObjectHolder (DataType aData) : rData(nil)
{
setData(aData);
}
ObjCObjectHolder (const ObjCObjectHolder & aCopy) : rData(nil)
{
setData(aCopy.rData);
}
const ObjCObjectHolder & operator = (const ObjCObjectHolder & aCopy)
{
setData(aCopy.rData);
return *this;
}
const ObjCObjectHolder & operator = (DataType aCopy)
{
setData(aCopy);
return *this;
}
virtual ~ObjCObjectHolder ()
{
DESTROY(rData);
}
}; // ObjCObjectHolder
; // template<typename DataType>
#ifdef UseMutable
typedef NSMutableString NSStringHolderString;
#else
typedef NSString NSStringHolderString;
#endif
typedef ObjCObjectHolder<NSStringHolderString *> NSStringHolderPrim;
class NSStringHolder : public NSStringHolderPrim
{
#ifdef UseMutable
protected:
virtual void setData (NSMutableString * aData) override
{
if (aData)
ASSIGN(rData, [NSMutableString stringWithString: aData]);
else
ASSIGN(rData, [NSMutableString stringWithCapacity: 1024]);
}
void setData (NSString * aData)
{
assert(aData);
ASSIGN(rData, [NSMutableString stringWithString: aData]);
}
#endif
public:
NSStringHolder ()
{
}
NSStringHolder (NSString * aString)
{
setData(aString);
}
NSStringHolder (const std::string & aValue)
{
NSStringHolderString *vStr = [[NSStringHolderString alloc] initWithBytes: aValue.c_str() length: aValue.length() encoding: NSWindowsCP1251StringEncoding];
@try {
setData(vStr);
}
@finally {
DESTROY(vStr);
}
}
NSStringHolder (const char * aValue)
{
NSStringHolderString *vStr = [[NSStringHolderString alloc] initWithBytes: aValue length: strlen(aValue) encoding: NSWindowsCP1251StringEncoding];
@try {
setData(vStr);
}
@finally {
DESTROY(vStr);
}
}
size_t length () const
{
return [rData length];
}
__strong const char * c_str() const
{
if (rData)
return [rData cStringUsingEncoding: NSWindowsCP1251StringEncoding];
else
return "";
}
operator NSString * () const
{
return rData;
}
operator std::string () const
{
if (rData)
return std::string([rData cStringUsingEncoding: NSWindowsCP1251StringEncoding]);
else
return std::string("");
}
const NSStringHolder & operator = (NSString * aValue)
{
setData(aValue);
return *this;
}
const NSStringHolder & operator = (const char * aValue)
{
NSStringHolderString *vStr = [[NSStringHolderString alloc] initWithBytes: aValue length: strlen(aValue) encoding: NSWindowsCP1251StringEncoding];
@try {
setData(vStr);
}
@finally {
DESTROY(vStr);
}
return *this;
}
const NSStringHolder & operator = (const std::string & aValue)
{
NSStringHolderString *vStr = [[NSStringHolderString alloc] initWithBytes: aValue.c_str() length: aValue.length() encoding: NSWindowsCP1251StringEncoding];
@try {
setData(vStr);
}
@finally {
DESTROY(vStr);
}
return *this;
}
void append (NSString * aValue)
{
if (aValue) {
if (rData) {
#ifdef UseMutable
[rData appendString: aValue];
#else
setData([rData stringByAppendingString: aValue]);
#endif
}
else
setData(aValue);
}
}
void append (const NSStringHolder & aValue)
{
append(aValue.rData);
}
const NSStringHolder & operator += (NSString * aValue)
{
append(aValue);
return *this;
}
const NSStringHolder & operator += (const NSStringHolder & aValue)
{
append(aValue);
return *this;
}
void trim ()
{
assert(rData);
setData([rData stringByTrimmingCharactersInSet: [NSCharacterSet whitespaceCharacterSet]]);
}
NSStringHolder substringToIndex (size_t aPos) const
{
assert(rData);
NSStringHolder vSubstr ([rData substringToIndex: aPos]);
return vSubstr;
}
NSStringHolder substringFromIndex (size_t aPos) const
{
assert(rData);
NSStringHolder vSubstr ([rData substringFromIndex: aPos]);
return vSubstr;
}
void insert (size_t aPos, const NSStringHolder & aValue)
{
if (aValue.rData) {
if (rData) {
if (aPos == 0) {
setData([(NSString *)aValue stringByAppendingString: rData]);
}
else
if (aPos == rData.length) {
setData([rData stringByAppendingString: aValue]);
}
else {
NSString *vStr = [rData substringToIndex: aPos];
vStr = [vStr stringByAppendingString: aValue];
vStr = [vStr stringByAppendingString: [rData substringFromIndex: aPos]];
setData(vStr);
}
}
else
setData(aValue.rData);
}
}
const NSStringHolder & operator += (const char * aValue)
{
append(aValue);
return *this;
}
const NSStringHolder & operator += (const std::string & aValue)
{
append(aValue);
return *this;
}
void resize (size_t aNewLength)
{
if (aNewLength < [rData length])
setData([rData substringToIndex: aNewLength/* + 1*/]);
else
if (aNewLength > [rData length])
assert(false);
}
size_t find_last (NSString * aWhatFind, size_t aPos) const
{
NSRange vRange = [rData rangeOfString: aWhatFind options: NSBackwardsSearch range: NSMakeRange(0, aPos + 1)];
if (vRange.location == NSNotFound)
return std::string::npos;
else
return vRange.location;
}
size_t find_first (NSString * aWhatFind, size_t aPos) const
{
if (aPos == std::string::npos)
return std::string::npos;
NSRange vRange = [rData rangeOfString: aWhatFind options: 0 range: NSMakeRange(aPos, rData.length - aPos)];
if (vRange.location == NSNotFound)
return std::string::npos;
else
return vRange.location;
}
size_t find_first (const NSStringHolder & aWhatFind, size_t aPos) const
{
if (aPos == std::string::npos)
return std::string::npos;
NSRange vRange = [rData rangeOfString: aWhatFind options: 0 range: NSMakeRange(aPos, rData.length - aPos)];
if (vRange.location == NSNotFound)
return std::string::npos;
else
return vRange.location;
}
size_t find (const NSStringHolder & aWhatFind) const
{
NSRange vRange = [rData rangeOfString: aWhatFind];
if (vRange.location == NSNotFound)
return std::string::npos;
else
return vRange.location;
}
bool operator != (const NSStringHolder & aValue) const
{
return ![rData isEqualToString: aValue.rData];
}
bool operator != (NSString * aValue) const
{
return ![rData isEqualToString: aValue];
}
bool operator == (const NSStringHolder & aValue) const
{
return [rData isEqualToString: aValue.rData];
}
bool operator == (NSString * aValue) const
{
return [rData isEqualToString: aValue];
}
const unichar operator [] (size_t anIndex) const
{
return [rData characterAtIndex: anIndex];
}
const NSStringHolder operator + (const NSStringHolder & anOther) const
{
NSStringHolder vOther (*this);
vOther += anOther;
return vOther;
}
const NSStringHolder operator + (const char * anOther) const
{
NSStringHolder vOther (*this);
vOther += anOther;
return vOther;
}
void appendLong (long aValue)
{
append([NSString stringWithFormat: @"%ld", aValue]);
}
void appendLongLong (long long aValue)
{
append([NSString stringWithFormat: @"%lld", aValue]);
}
void appendUnsignedLong (unsigned long aValue)
{
append([NSString stringWithFormat: @"%ld", aValue]);
}
void appendUnsignedLongLong (unsigned long long aValue)
{
append([NSString stringWithFormat: @"%lld", aValue]);
}
}; // NSStringHolder
- всё.class SomeClass
{
public:
std::string a;
}; // SomeClass
SomeClass X; std::string Y = X.a; X.a = "SomeString";
class SomeClass
{
private:
std::string m_a;
public:
const std::string get_a () const
{
return m_a;
}
void set_a (const std::string & aValue)
{
m_a = aValue;
}
}; // SomeClass
SomeClass X;
std::string Y = X.get_a();
X.set_a("SomeString");
class SomeClass
{
private:
std::string m_a;
public:
const std::string & get_a () const
{
return m_a;
}
void set_a (const std::string & aValue)
{
m_a = aValue;
}
}; // SomeClass
class SomeClass
{
private:
std::string m_a;
private:
const std::string get_a () const
{
return m_a;
}
void set_a (const std::string & aValue)
{
m_a = aValue;
}
public:
property std::string a
read get_a
write set_a;
}; // SomeClass
SomeClass X; std::string Y = X.a; X.a = "SomeString";
class SomeClass
{
private:
std::string m_a;
public:
const std::string a () const
// - это getter
{
return m_a;
}
std::string & a ()
// - это setter
{
return m_a;
}
}; // SomeClass
SomeClass X; std::string Y = X.a(); X.a() = "SomeString";
void set_a (const std::string & aValue)
{
if (this->someCondition(aValue))
m_a = aValue;
}
class SomeClass
{
private:
std::string m_a;
public:
const std::string a () const
// - это getter
{
return m_a;
}
void set_a (const std::string & aValue)
// - это setter
{
if (this->someCondition(aValue))
m_a = aValue;
}
}; // SomeClass
SomeClass X;
std::string Y = X.a();
X.set_a("SomeString");
template<class DataOwner, typename DataType>
class ValueSetter
{
private:
DataType & m_data;
DataOwner * m_owner;
public
ValueSetter (DataOwner * aOwner, DataType & aData) : m_data(aData), m_owner(aOwner)
// - инициализирующий конструктор
{
}
ValueSetter (const ValueSetter & anOther) : m_data(anOther.m_data), m_owner(anOther.m_owner)
// - копирующий конструктор
{
}
ValueSetter & operator= (const DataType & aValue)
// - оператор присваивания
{
if (m_owner->someCondition(aValue))
m_data = aValue;
return *this;
}
} ; // ValueSetter
; //template
class SomeClass
{
private:
std::string m_a;
public:
const std::string a () const
// - это getter
{
return m_a;
}
typedef ValueSetter<SomeClass, std::string> Setter_for_a;
Setter_for_a & a ()
// - это setter
{
Setter_for_a vSetter(this, a);
return vSetter;
}
}; // SomeClass
SomeClass X; std::string Y = X.a(); X.a() = "SomeString";
template<class DataOwner, typename DataType, typename Condition>
class ValueSetter
{
private:
DataType & m_data;
DataOwner * m_owner;
public
ValueSetter (DataOwner * aOwner,DataType & aData) : m_data(aData), m_owner(aOwner)
// - инициализирующий конструктор
{
}
ValueSetter (const ValueSetter & anOther) : m_data(anOther.m_data), m_owner(anOther.m_owner)
// - копирующий конструктор
{
}
ValueSetter & operator= (const DataType & aValue)
// - оператор присваивания
{
if (Condition(m_owner, aValue))
m_data = aValue;
return *this;
}
} ; // ValueSetter
; //template
class SomeClass
{
private:
std::string m_a;
static bool condition_for_a (const SomeClass & aThis, const std::string & aValue)
{
return aThis.someCondition(aValue);
}
public:
const std::string a () const
// - это getter
{
return m_a;
}
typedef ValueSetter<SomeClass, std::string, condition_for_a> Setter_for_a;
Setter_for_a & a ()
// - это setter
{
Setter_for_a vSetter(this, a);
return vSetter;
}
}; // SomeClass
template<typename DataType, typename Condition>
class ValueSetter
{
private:
DataType & m_data;
public
ValueSetter (DataType & aData) : m_data(aData)
// - инициализирующий конструктор
{
}
ValueSetter (const ValueSetter & anOther) : m_data(anOther.m_data)
// - копирующий конструктор
{
}
ValueSetter & operator= (const DataType & aValue)
// - оператор присваивания
{
if (Condition(aValue))
m_data = aValue;
return *this;
}
} ; // ValueSetter
; //template
class SomeClass
{
private:
std::string m_a;
public:
const std::string a () const
// - это getter
{
return m_a;
}
typedef ValueSetter<std::string, [&] (const std::string & aValue) ->bool { return this->someCondition(aValue); }> Setter_for_a;
Setter_for_a & a ()
// - это setter
{
Setter_for_a vSetter(a);
return vSetter;
}
}; // SomeClass
class SomeClass1
{
private:
std::vector<std::string> m_a;
public:
const std::string & a () const
{
return m_a;
}
std::string & a ()
{
return m_a;
}
}; // SomeClass1
SomeClass1 X; std::string Y = X.a()[0]; X.a()[1] = "Some Value";
class SomeClass1
{
private:
std::vector<std::string> m_a;
public:
const std::string & a () const
{
return m_a;
}
std::string & a ()
{
return m_a;
}
const std::string & operator[] (size_t anIndex) const
{
return m_a[anIndex];
}
std::string & operator[] (size_t anIndex)
{
return m_a[anIndex];
}
}; // SomeClass1
SomeClass1 X; std::string Y = X[0]; X[1] = "Some Value";
SomeClass1 X; char Y = X[0][1]; X[1][0] = 'c';
return expression. Это ограничивает размер лямбда-функции до одного выражения.class A
{
private:
char * m_String;
public
A (char * aString)
{
m_String = strnew(aString);
// - получили копию строки
}
~A()
{
strdispose(m_String);
// - освободили строку
}
const char * getString()
{
return m_String;
}
};
A x ("Hello world");
char * y;
std::vector<int> someList = {1};
// - просто чтобы вектор был не пуст, хотя это и не так важно
std::for_each(someList.begin(), someList.end(), [](int anItem) {
y := x.getString();
// - типа просто получили ссылку на строку и ничего с ней не делаем
});
y := x.getString();
A x ("Hello world");
char * y;
std::vector<int> someList = {1};
// - просто чтобы вектор был не пуст, хотя это и не так важно
std::for_each(someList.begin(), someList.end(), [&x](int anItem) {
y := x.getString();
// - типа просто получили ссылку на строку и ничего с ней не делаем
});
class A
{
private:
char * m_String;
public
A (char * aString)
{
m_String = strnew(aString);
// - получили копию строки
}
A (const A & anOther)
{
m_String = strnew(anOther.m_String);
// - получили копию строки
}
~A()
{
strdispose(m_String);
// - освободили строку
}
const char * getString()
{
return m_String;
}
};
class A
{
private:
char * m_String;
public
A (char * aString)
{
m_String = strnew(aString);
// - получили копию строки
}
private:
A (const A & anOther);
public:
~A()
{
strdispose(m_String);
// - освободили строку
}
const char * getString()
{
return m_String;
}
};
class A
{
private:
char * m_String;
public
A (char * aString)
{
m_String = strnew(aString);
// - получили копию строки
}
A (const A & anOther) = delete;
~A()
{
strdispose(m_String);
// - освободили строку
}
const char * getString()
{
return m_String;
}
};
A x ("Hello world");
char * y;
[m_HiddenTextIndex enumerateKeysAndObjectsUsingBlock:^(id docId, id data, BOOL *) {
y := x.getString();
// - типа просто получили ссылку на строку и ничего с ней не делаем
}];
-- ^(id docId, id data, BOOL *) - это тоже анонимная функция.
std::string theValue = theContainer.getRef(); // - тут копирование данных
const std::string & theValue = theContainer.getRef(); // - тут нет копирования данных
program Project1Tests;
{
Delphi DUnit Test Project
-------------------------
This project contains the DUnit test framework and the GUI/Console test runners.
Add "CONSOLE_TESTRUNNER" to the conditional defines entry in the project options
to use the console test runner. Otherwise the GUI test runner will be used by
default.
}
{$IFDEF CONSOLE_TESTRUNNER}
{$APPTYPE CONSOLE}
{$ENDIF}
uses
DUnitTestRunner,
TestUnit1 in 'TestUnit1.pas',
Unit1 in '..\DUnit.VCL\Unit1.pas';
{$R *.RES}
begin
DUnitTestRunner.RunRegisteredTests;
end.
Then you have to add a TestCase (File-> New-> Other-> Unit Test-> TestCase). And the result will look like:
unit TestUnit1;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
TestFramework, System.SysUtils, Vcl.Graphics, Winapi.Windows, System.Variants,
System.Classes, Vcl.Dialogs, Vcl.Controls, Vcl.Forms, Winapi.Messages, Unit1;
type
// Test methods for class TForm1
TestTForm1 = class(TTestCase)
strict private
FForm1: TForm1;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestDoIt;
end;
implementation
procedure TestTForm1.SetUp;
begin
FForm1 := TForm1.Create;
end;
procedure TestTForm1.TearDown;
begin
FForm1.Free;
FForm1 := nil;
end;
procedure TestTForm1.TestDoIt;
var
ReturnValue: Integer;
begin
ReturnValue := FForm1.DoIt;
// TODO: Validate method results
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestTForm1.Suite);
end.
In general, my example shows how you can easily add unit-testing even to Delphi 7. All we need is to call DUnitTestRunner.RunRegisteredTests and add new files with TestCases to the project. In more detail unit-testing, using DUnit, is considered here.
Implementing GUIRunner for FireMonkey, I decided to repeat the guys who did the original DUnit. The first problem (I will not even tell that TTreeNode and TTreeViewItem classes are not compatible) that I encountered was here:
type
TfmGUITestRunner = class(TForm)
...
protected
FSuite: ITest;
procedure SetSuite(Value: ITest);
...
public
property Suite: ITest read FSuite write SetSuite;
end;
procedure RunTestModeless(aTest: ITest);
var
l_GUI: TfmGUITestRunner;
begin
Application.CreateForm(TfmGUITestRunner, l_GUI);
l_GUI.Suite := aTest;
l_GUI.Show;
end;
procedure TfmGUITestRunner.SetSuite(Value: ITest);
begin
FSuite := Value; // AV here
if FSuite <> nil then
InitTree;
end;
In FireMonkey Application.CreateForm method does not create a form. Yes, it is oddly enough.
Here is another link about that. It does not do what it says it does! I was, to be honest, a bit shocked by the fact that the method called "CreateForm" does not create it.
To solve this issue I create forms explicitly (l_GUI := TfmGUITestRunner.Create (nil);) and go further.
Now we need to build a tests tree based on TestCases we added for testing. If you notice, the construction of the form starts in RunRegisteredTestsModeless method.
procedure RunRegisteredTestsModeless; begin RunTestModeless(registeredTests) end;I decided not to put this method into a separate module, as DUnit developers did, thus to use fmGUITestRunner, you must specify its module in the project code and actually call the appropriate method. In my case, the code is as follows:
program FMX.DUnit;
uses
FMX.Forms,
// GUI Runner
u_fmGUITestRunner in 'u_fmGUITestRunner.pas' {fmGUITestRunner},
// Tests
u_FirstTest in 'u_FirstTest.pas',
u_TCounter in 'u_TCounter.pas',
u_SecondTest in 'u_SecondTest.pas';
{$R *.res}
begin
Application.Initialize;
u_fmGUITestRunner.RunRegisteredTestsModeless;
Application.Run;
end.
The attentive reader will notice that we have not added any registeredTests, and it is never specified what kind of tests will be added. RegisteredTests is a global method of TestFrameWork, which is connected to our form; it returns __TestRegistry: ITestSuite (global variable);
The way how TestRegistry gets TestCases is out of the scope of this article. Moreover, that work has been done by DUnit developer. However, if readers have an interest in this topic, I'll reply to the comments.
So, back to the tree. A method to initialize the tree:
procedure TfmGUITestRunner.InitTree; begin FTests.Clear; FillTestTree(Suite); TestTree.ExpandAll; end;FTests is a list of interface objects, which will store a list of our tests. FillTestTree is overloaded because we do not know if we are working with a root of the tree or with an ordinary node:
...
procedure FillTestTree(aTest: ITest); overload;
procedure FillTestTree(aRootNode: TTreeViewItem; aTest: ITest); overload;
...
procedure TfmGUITestRunner.FillTestTree(aRootNode: TTreeViewItem; aTest: ITest);
var
l_TestTests: IInterfaceList;
l_Index: Integer;
l_TreeViewItem: TTreeViewItem;
begin
if aTest = nil then
Exit;
l_TreeViewItem := TTreeViewItem.Create(self);
l_TreeViewItem.IsChecked := True;
// Add Index to tag property
l_TreeViewItem.Tag := FTests.Add(aTest);
l_TreeViewItem.Text := aTest.Name;
if aRootNode = nil then
TestTree.AddObject(l_TreeViewItem)
else
aRootNode.AddObject(l_TreeViewItem);
l_TestTests := aTest.Tests;
for l_Index := 0 to l_TestTests.Count - 1 do
FillTestTree(l_TreeViewItem, l_TestTests[l_Index] as ITest);
end;
As you can see, in this method, we not only fill the tree, but also add information to each node, which of the tests corresponds to it. In order to get a test by a given node, let’s implement a method named NodeToTest:
function TfmGUITestRunner.NodeToTest(aNode: TTreeViewItem): ITest; var l_Index: Integer; begin assert(aNode.Tag >= 0); l_Index := aNode.Tag; Result := FTests[l_Index] as ITest; end;Now let's add some “knowledge” to a test. There is a variable GUIObject (TObject) in each test. And we will call SetupGUINodes method in FormShow.
procedure TfmGUITestRunner.SetupGUINodes(aNode: TTreeViewItem);
var
l_Test: ITest;
l_Index: Integer;
begin
for l_Index := 0 to Pred(aNode.Count) do
begin
// Give test
l_Test := NodeToTest(aNode.Items[l_Index]);
assert(assigned(l_Test));
// associate node to test
l_Test.GUIObject := aNode.Items[l_Index];
SetupGUINodes(aNode.Items[l_Index]);
end;
end;
In order to get a node corresponding to a test let’s write a method
function TfmGUITestRunner.TestToNode(test: ITest): TTreeViewItem; begin assert(assigned(test)); Result := test.GUIObject as TTreeViewItem; assert(assigned(Result)); end;My senior colleague and I don’t like the way I connect the tests and the tree. I understand why DUnit developer done this that way. DUnit has been developed long ago; Generics were not available. We will change it in the future. At the end of this post, I will write about our upcoming improvements and wishes. So our tree is constructed, all the tests are inside FTests. Tests and the tree are connected. It's time to run the tests and interpret the results. To ensure that the form can do it, let's add to the form an implementation of the ITestListener interface described in TestFrameWork:
{ ITestListeners get notified of testing events.
See TTestResult.AddListener()
}
ITestListener = interface(IStatusListener)
['{114185BC-B36B-4C68-BDAB-273DBD450F72}']
procedure TestingStarts;
procedure StartTest(test: ITest);
procedure AddSuccess(test: ITest);
procedure AddError(error: TTestFailure);
procedure AddFailure(Failure: TTestFailure);
procedure EndTest(test: ITest);
procedure TestingEnds(testResult :TTestResult);
function ShouldRunTest(test :ITest):Boolean;
end;
Let’s add these methods to the class interface and implement them:
procedure TfmGUITestRunner.TestingStarts; begin FTotalTime := 0; end; procedure TfmGUITestRunner.StartTest(aTest: ITest); var l_Node: TTreeViewItem; begin assert(assigned(TestResult)); assert(assigned(aTest)); l_Node := TestToNode(aTest); assert(assigned(l_Node)); end; procedure TfmGUITestRunner.AddSuccess(aTest: ITest); begin assert(assigned(aTest)); SetTreeNodeFont(TestToNode(aTest), c_ColorOk) end; procedure TfmGUITestRunner.AddError(aFailure: TTestFailure); var l_ListViewItem: TListViewItem; begin SetTreeNodeFont(TestToNode(aFailure.failedTest), c_ColorError); l_ListViewItem := AddFailureNode(aFailure); end; procedure TfmGUITestRunner.AddFailure(aFailure: TTestFailure); var l_ListViewItem: TListViewItem; begin SetTreeNodeFont(TestToNode(aFailure.failedTest), c_ColorFailure); l_ListViewItem := AddFailureNode(aFailure); end; procedure TfmGUITestRunner.EndTest(test: ITest); begin // comment this assert because if not comment, we don't have any result // assert(False); end; procedure TfmGUITestRunner.TestingEnds(aTestResult: TTestResult); begin FTotalTime := aTestResult.TotalTime; end; function TfmGUITestRunner.ShouldRunTest(aTest: ITest): Boolean; var l_Test: ITest; begin l_Test := aTest; Result := l_Test.Enabled end;There’s nothing special here to explain. Although if you have some questions, I will give a detailed answer. In the original DUnitRunner after receiving a test result, it changes a picture of the corresponding tree node. I decided not to deal with pictures but change the FontColor and FontStyle for each node. It looks like it takes a minute, but I spent a couple of hours, having dug through all the documentation
procedure TfmGUITestRunner.SetTreeNodeFont(aNode: TTreeViewItem; aColor: TAlphaColor); begin // Set style settings aNode.StyledSettings := aNode.StyledSettings - [TStyledSetting.ssFontColor, TStyledSetting.ssStyle]; aNode.Font.Style := [TFontStyle.fsBold]; aNode.FontColor := aColor; end;To output results, we will use ListView. TListView in FireMonkey is fully optimized for mobile applications but lost his wonderful Columns property. AddFailureNode is a method to add failures:
function TfmGUITestRunner.AddFailureNode(aFailure: TTestFailure): TListViewItem;
var
l_Item: TListViewItem;
l_Node: TTreeViewItem;
begin
assert(assigned(aFailure));
l_Item := lvFailureListView.Items.Add;
l_Item.Text := aFailure.failedTest.Name + '; ' +
aFailure.thrownExceptionName + '; ' +
aFailure.thrownExceptionMessage + '; ' +
aFailure.LocationInfo + '; ' +
aFailure.AddressInfo + '; ' +
aFailure.StackTrace;
l_Node := TestToNode(aFailure.failedTest);
while l_Node <> nil do
begin
l_Node.Expand;
l_Node := l_Node.ParentItem;
end;
Result := l_Item;
end;
It's time to run our tests; we will add a button and a launch method:
procedure TfmGUITestRunner.btRunAllTestClick(Sender: TObject);
begin
if Suite = nil then
Exit;
ClearResult;
RunTheTest(Suite);
end;
procedure TfmGUITestRunner.RunTheTest(aTest: ITest);
begin
TestResult := TTestResult.Create;
try
TestResult.addListener(self);
aTest.run(TestResult);
finally
FreeAndNil(FTestResult);
end;
end;
After running our Runner and clicking the button, we will see the following:
image
procedure TfmGUITestRunner.TestTreeChangeCheck(Sender: TObject);
begin
SetNodeEnabled(Sender as TTreeViewItem, (Sender as TTreeViewItem).IsChecked);
end;
procedure TfmGUITestRunner.SetNodeEnabled(aNode: TTreeViewItem;
aValue: Boolean);
var
l_Test: ITest;
begin
l_Test := NodeToTest(aNode);
if l_Test <> nil then
l_Test.Enabled := aValue;
end;
Changing checkboxes state for some nodes:
image
unit u_SecondTest;
interface
uses
TestFrameWork;
type
TSecondTest = class(TTestCase)
published
procedure DoIt;
procedure OtherDoIt;
procedure ErrorTest;
procedure SecondErrorTest;
end; // TFirstTest
implementation
procedure TSecondTest.DoIt;
begin
Check(true);
end;
procedure TSecondTest.ErrorTest;
begin
raise ExceptionClass.Create('Error Message');
end;
procedure TSecondTest.OtherDoIt;
begin
Check(true);
end;
procedure TSecondTest.SecondErrorTest;
begin
Check(False);
end;
initialization
TestFrameWork.RegisterTest(TSecondTest.Suite);
end.
To summarize: at this moment, we have a fully working application for testing FireMonkey code using the usual GUIRunner. The project is open, so everyone can use.
Plans for the future:
Write a method to traverse the tree which will get a lambda function. The tree has to be around permanently, but the steps are different for each branch, so I think lambda function seems to be appropriate.
Comments and suggestions from my senior colleague:
To rebuild Tests and Nodes connection with TDictionary<TTreeViewItem, ITest> docwiki.embarcadero.com/Libraries/XE7/en/System.Generics.Collections.TDictionary
To add graphic indication of tests execution process. Add buttons: select all, unselect all, and so on, and the output of test results (execution time, the number of successful and failed tests, and so on).
To add the Decorator pattern to get rid of the GUIObject.
In the near future, we will start to cover our MindStream project with unit-tests, and also step by little step bring improvements to the Runner. Thanks to all who have read to the end. Comments and criticism are as always welcome in the comments.
Link to the repository.
p.s. The project is located at MindStream\FMX.DUnit path.
Links that were useful:
http://sourceforge.net/p/radstudiodemos/code/HEAD/tree/branches/RadStudio_XE5_Update/FireMonkey/Delphi/
http://fire-monkey.ru/
http://18delphi.blogspot.ru/
http://www.gunsmoker.ru/
And of course
http://docwiki.embarcadero.com/RADStudio/XE7/en/Main_Page
