T1t0 at 00:42, 14 March 2021

2021-03-14T00:42:15Z

← Older revision		Revision as of 00:42, 14 March 2021
Line 629:		Line 629:
	* [http://sourceforge.net/projects/cppunit/ CppUnit Home site]		* [http://sourceforge.net/projects/cppunit/ CppUnit Home site]
	* [http://www.freedesktop.org/wiki/Software/cppunit/ CppUnit 'continuation' by freedesktop.org]		* [http://www.freedesktop.org/wiki/Software/cppunit/ CppUnit 'continuation' by freedesktop.org]



	[[Category:develop]]		[[Category:develop]]
	[[Category:cpp]]		[[Category:c/cpp]]
	[[Category:test]]		[[Category:test]]

T1t0 at 03:26, 14 February 2021

2021-02-14T03:26:39Z

← Older revision		Revision as of 03:26, 14 February 2021
Line 633:		Line 633:

	[[Category:develop]]		[[Category:develop]]
	[[Category:~~c++~~]]		[[Category:cpp]]
			[[Category:test]]

imported>T1t0 at 19:23, 6 October 2014

2014-10-06T19:23:33Z

← Older revision		Revision as of 19:23, 6 October 2014
Line 622:		Line 622:
	</pre>		</pre>
	//// End ShippingAddress.cpp ////		//// End ShippingAddress.cpp ////



			= References =

			* [http://sourceforge.net/projects/cppunit/ CppUnit Home site]
			* [http://www.freedesktop.org/wiki/Software/cppunit/ CppUnit 'continuation' by freedesktop.org]



			[[Category:develop]]
			[[Category:c++]]

imported>T1t0: 1 revision

2011-08-28T05:54:35Z

1 revision

New page

= CppUnit HowTo =

...This article is a STUB...

First of all, we need dev packages of cppunit library: see your distribution-specific package manager to obtain it. Example: for debian users, a simple <code>apt-get install libcppunit-dev</code> should work.

== Let's go to define some behaviors to check: ==

Our client ask us to implement his online store, and he define some rules for his customers doing an order:

- guest client can do an order with a open state;

- a valid order must indicate a registered customer, at least a product, a shipping address and a payment method.

== So, to implement this behaviors, we can define 5 test: ==

//// TestOrder.h ////
<pre>
#ifndef TEST_ORDER_H_
#define TEST_ORDER_H_

#include <cppunit/extensions/HelperMacros.h>

class TestOrder : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(TestOrder);
CPPUNIT_TEST(testNewOrderStateOpen);
CPPUNIT_TEST(testValidOrderMustHaveCustomer);
CPPUNIT_TEST(testValidOrderMustHaveSomeProduct);
CPPUNIT_TEST(testValidOrderMustHaveShippingAddress);
CPPUNIT_TEST(testValidOrderMustHavePaymentMethod);
CPPUNIT_TEST_SUITE_END();

public:
void testNewOrderStateOpen();
void testValidOrderMustHaveCustomer();
void testValidOrderMustHaveSomeProduct();
void testValidOrderMustHaveShippingAddress();
void testValidOrderMustHavePaymentMethod();
};

#endif

</pre>

//// END TestOrder.h ////

//// TestOrder.cpp ////
<pre>
#include "TestOrder.h"

CPPUNIT_TEST_SUITE_REGISTRATION(TestOrder);

void TestOrder::testNewOrderStateOpen()
{
CPPUNIT_FAIL("Test not implemented");
}

void TestOrder::testValidOrderMustHaveCustomer()
{
CPPUNIT_FAIL("Test not implemented");
}

void TestOrder::testValidOrderMustHaveSomeProduct()
{
CPPUNIT_FAIL("Test not implemented");
}

void TestOrder::testValidOrderMustHaveShippingAddress()
{
CPPUNIT_FAIL("Test not implemented");
}

void TestOrder::testValidOrderMustHavePaymentMethod()
{
CPPUNIT_FAIL("Test not implemented");
}

</pre>
//// END TestOrder.cpp ////

== Now, to use our TestOrder class, we need set up a program to run the test ==

//// test_main.cpp ////
<pre>
#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>

int main(int nArgs, char* aryArgs[])
{
CppUnit::Test* pntCppTest = CppUnit::TestFactoryRegistry::getRegistry().makeTest();

CppUnit::TextUi::TestRunner objCppRunner;
objCppRunner.addTest(pntCppTest);

objCppRunner.setOutputter(new CppUnit::CompilerOutputter(&objCppRunner.result(), std::cerr));

bool bSuccess = objCppRunner.run();

return bSuccess ? 0 : 1;
}

</pre>
//// END test_main.cpp ////

== to compile and run our source we'll doing a simple script: ==

//// testAndRun.sh ////
<pre>
#!/bin/bash

g++ -c test_main.cpp -o test_main.o || exit -1
g++ -c TestOrder.cpp -o TestOrder.o || exit -2
g++ -lcppunit test_main.o TestOrder.o -o testMain || exit -3
./testMain

exit $?

</pre>
//// END testAndRun.sh ////

== if all was ok, executing our script with ==

<code>sh testAndRun.sh</code>
will report 5 failed tests of 5 total tests: wonderful!

== Now, happy refactoring! ==

=== A basic example for an effective TestOrder class: ===

//// TestOrder.cpp ////
<pre>

#include "TestOrder.h"

#include "Order.h"
#include "Customer.h"
#include "PaymentMethod.h"
#include "Product.h"
#include "ShippingAddress.h"

CPPUNIT_TEST_SUITE_REGISTRATION(TestOrder);

void TestOrder::testNewOrderStateOpen()
{
// Arrange, act
Order objOrder(123);

// Assert
CPPUNIT_ASSERT(objOrder.getState() == Order::StateOpened);
}

void TestOrder::testValidOrderMustHaveCustomer()
{
// Arrange
Customer objCustomer(123);
Order objOrder(123);
PaymentMethod objPaymentMethod(123);
Product objProduct(123);
ShippingAddress objShippingAddress(123);

// Act
objOrder.setPaymentMethod(objPaymentMethod);
objOrder.addProduct(objProduct);
objOrder.setShippingAddress(objShippingAddress);

// Assert
CPPUNIT_ASSERT(!(objOrder.isValid()));
objOrder.setCustomer(objCustomer);
CPPUNIT_ASSERT(objOrder.isValid());
}

void TestOrder::testValidOrderMustHaveSomeProduct()
{
// Arrange
Customer objCustomer(123);
Order objOrder(123);
PaymentMethod objPaymentMethod(123);
Product objProduct(123);
ShippingAddress objShippingAddress(123);

// Act
objOrder.setCustomer(objCustomer);
objOrder.setPaymentMethod(objPaymentMethod);
objOrder.setShippingAddress(objShippingAddress);

// Assert
CPPUNIT_ASSERT(!(objOrder.isValid()));
objOrder.addProduct(objProduct);
CPPUNIT_ASSERT(objOrder.isValid());
}

void TestOrder::testValidOrderMustHaveShippingAddress()
{
// Arrange
Customer objCustomer(123);
Order objOrder(123);
PaymentMethod objPaymentMethod(123);
Product objProduct(123);
ShippingAddress objShippingAddress(123);

// Act
objOrder.setCustomer(objCustomer);
objOrder.setPaymentMethod(objPaymentMethod);
objOrder.addProduct(objProduct);

// Assert
CPPUNIT_ASSERT(!(objOrder.isValid()));
objOrder.setShippingAddress(objShippingAddress);
CPPUNIT_ASSERT(objOrder.isValid());
}

void TestOrder::testValidOrderMustHavePaymentMethod()
{
// Arrange
Customer objCustomer(123);
Order objOrder(123);
PaymentMethod objPaymentMethod(123);
Product objProduct(123);
ShippingAddress objShippingAddress(123);

// Act
objOrder.setCustomer(objCustomer);
objOrder.addProduct(objProduct);
objOrder.setShippingAddress(objShippingAddress);

// Assert
CPPUNIT_ASSERT(!(objOrder.isValid()));
objOrder.setPaymentMethod(objPaymentMethod);
CPPUNIT_ASSERT(objOrder.isValid());
}

</pre>
//// END TestOrder.cpp ////

=== we need an Order class ===

//// Order.h ////
<pre>
#ifndef ORDER_H_
#define ORDER_H_

#include <list>

#include "Entity.h"
#include "EntityId.h"

class Customer;
class PaymentMethod;
class Product;
class ShippingAddress;

class Order: public Entity
{
public:
enum eOrderState
{
StateOpened,
StateValidated,
StateAccepted,
StatePayed,
StateShipped
};

public:
explicit Order(EntityId _id);

eOrderState getState();
bool isValid();

bool addProduct(Product& _objProdct);
bool setCustomer(Customer& _objCustomer);
bool setPaymentMethod(PaymentMethod& _objPaymentMethod);
bool setShippingAddress(ShippingAddress& _objShippingAddress);

private:
eOrderState m_state;

std::list<EntityId> m_lstIdProduct;
EntityId m_idCustomer;
EntityId m_idPaymentMethod;
EntityId m_idShippingAddress;
};

#endif

</pre>
//// End Order.h ////

//// Order.cpp ////
<pre>

#include "Order.h"

#include "Customer.h"
#include "PaymentMethod.h"
#include "Product.h"
#include "ShippingAddress.h"

Order::Order(EntityId _id)
: Entity(_id)
{
m_state = Order::StateOpened;
m_idCustomer = 0;
m_idShippingAddress = 0;
m_idPaymentMethod = 0;
}

Order::eOrderState Order::getState()
{
return m_state;
}

bool Order::isValid()
{
return (m_idCustomer != 0 &&
m_lstIdProduct.size() > 0 &&
m_idShippingAddress != 0 &&
m_idPaymentMethod != 0);
}

bool Order::addProduct(Product& _objProdct)
{
if (_objProdct.getId() == 0)
{
return false;
}

m_lstIdProduct.push_back(_objProdct.getId());

return true;
}

bool Order::setCustomer(Customer& _objCustomer)
{
if (_objCustomer.getId() == 0)
{
return false;
}

m_idCustomer = _objCustomer.getId();

return true;
}

bool Order::setPaymentMethod(PaymentMethod& _objPaymentMethod)
{
if (_objPaymentMethod.getId() == 0)
{
return false;
}

m_idPaymentMethod = _objPaymentMethod.getId();

return true;
}

bool Order::setShippingAddress(ShippingAddress& _objShippingAddress)
{
if (_objShippingAddress.getId() == 0)
{
return false;
}

m_idShippingAddress = _objShippingAddress.getId();

return true;
}

</pre>
//// End Order.cpp ////

=== the Entity is common for all the serializable class, the implement an id member and a function to get the id. ===

//// Entity.h ////
<pre>
#ifndef ENTITY_H_
#define ENTITY_H_

#include "EntityId.h"

class Entity
{
public:
explicit Entity(EntityId _id);

EntityId getId();

protected:
void setId(EntityId _id);

private:
EntityId m_id;
};

#endif

</pre>
//// End Entity.h ////

//// Entity.cpp ////
<pre>
#include "Entity.h"

Entity::Entity(EntityId _id)
: m_id(_id)
{
}

EntityId Entity::getId()
{
return m_id;
}

void Entity::setId(EntityId _id)
{
m_id = _id;
}

</pre>
//// End Entity.cpp ////

=== The id type is defined as EntityId type, defined as a long to give a easy way to change all the id reference for another type: ===

//// EntityId.h ////
<pre>
#ifndef ENTITY_ID_H_
#define ENTITY_ID_H_

typedef long EntityId;

#endif

</pre>
//// End EntityId.h ////

=== The other class are free of logic, for now: ===

//// Product.h ////
<pre>
#ifndef PRODUCT_H_
#define PRODUCT_H_

#include "Entity.h"
#include "EntityId.h"

class Product : public Entity
{
public:
explicit Product(EntityId _id);
};

#endif

</pre>
//// End Product.h ////

//// Product.cpp ////
<pre>
#include "Product.h"

Product::Product(EntityId _id)
: Entity(_id)
{
}

</pre>
//// End Product.cpp ////

//// Customer.h ////
<pre>

#ifndef CUSTOMER_H_
#define CUSTOMER_H_

#include "Entity.h"
#include "EntityId.h"

class Customer: public Entity
{
public:
explicit Customer(EntityId _id);
};

#endif

</pre>
//// End Customer.h ////

//// Customer.cpp ////
<pre>
#include "Customer.h"

Customer::Customer(EntityId _id)
: Entity(_id)
{
}

</pre>
//// End Customer.cpp ////

//// PaymentMethod.h ////
<pre>
#ifndef PAYMENT_METHOD_H_
#define PAYMENT_METHOD_H_

#include "Entity.h"
#include "EntityId.h"

class PaymentMethod : public Entity
{
public:
explicit PaymentMethod(EntityId _id);
};

#endif

</pre>
//// End PaymentMethod.h ////

//// PaymentMethod.cpp ////

<pre>
#include "PaymentMethod.h"

PaymentMethod::PaymentMethod(EntityId _id)
: Entity(_id)
{
}

</pre>
//// End PaymentMethod.cpp ////

//// ShippingAddress.h ////
<pre>
#ifndef SHIPPING_ADDRESS_H_
#define SHIPPING_ADDRESS_H_

#include "Entity.h"
#include "EntityId.h"

class ShippingAddress : public Entity
{
public:
explicit ShippingAddress(EntityId _id);
};

#endif

</pre>
//// End ShippingAddress.h ////

//// ShippingAddress.cpp ////
<pre>
#include "ShippingAddress.h"

ShippingAddress::ShippingAddress(EntityId _id)
: Entity(_id)
{
}

</pre>
//// End ShippingAddress.cpp ////

Cppunit - Revision history

T1t0 at 00:42, 14 March 2021

T1t0 at 03:26, 14 February 2021

imported>T1t0 at 19:23, 6 October 2014

imported>T1t0: 1 revision