View source for Cppunit

= 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 ////



= 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/cpp]]
[[Category:test]]