Improve Unit Testing with Visual C++ Programming

Visual Studio comes with an interesting tool for unit testing as described in this blog about Writing Unit Tests in Visual Studio for Native C++, but this solution had the following disadvantages due to using C++\CLI:

  • Intellisense not supported for C++\CLI.
  • Assert is designed for .Net languages , and using it for native C++ induce using some workarounds like:Assert for string,Assert::IsNullPointer.
  • nullptr exist both in C++0x and CLI and concerning test for C++0x code we have to use __nullptr instead.
  • Many developers don't understand why they have to use C++\CLI to test native C++.

This testing tool is very elegant; it can easily be plugged into Team Foundation Server TFS), so don't be discouraged by the disadvantages described.

There's a simple solution to the disadvantages, with few changes, that resolve these issues. To explain this solution let's change the following test class.

using namespace System::Text;
using namespace System::Collections::Generic;
using namespace Microsoft::VisualStudio::TestTools::UnitTesting;
namespace TestProject1
{
   [TestClass]
    public ref class UnitTest1
    {
      public:
        [TestMethod]
        void TestMethod1()
        {
           //some test code
        }
    };
}

The most feedback about this code is the use of C++\CLI instead of native C++. The goal is to implement an alternative solution to the one proposed by Visual Studio. For that, let's do the following steps:

Step1: Create a Native Class for Test

The best aproach to test native code is to use a native test class like any other existing test unit framework (CppUnit,googleTest,...)

Let's create our native test class:

NativeTest.h

class NativeUnitTest1
{
   Public:
      void TestMethod1();
}

NativeTest.cpp

#include "nativetest.h"
void NativeUnitTest1::TestMethod1(){
//Native test code
}

We have to change the "Common Language Support" property to "No Common language rutime support." I n this case the intellisense works perfectly , and all test code is written with native C++.

Step2 : Create NativeAssert Class to Encapsulate Managed Assert Class

For test methods we need to use Assert methods. To avoid the drawbacks of using the managed Assert class, and facilitate using this class for native code, let's create a native class that encapsulates the managed one.

NativeAssert.h file:

class NativeAssert
{
   public:
      static void AreEqual(int a,int b);
      static void AreEqual(std::string a,std::string b);
};

NativeAssert.cpp file:

using namespace Microsoft::VisualStudio::TestTools::UnitTesting;
#include "NativeAssert.h"
void  NativeAssert::AreEqual(int a,int b)
{
    Assert::AreEqual(a,b);
}
void  NativeAssert::AreEqual(std::string a,std::string b)
{
    Assert::AreEqual<System::String^>(gcnew System::String(a.c_str()), gcnew System::String(b.c_str()));
}

Of course, all assert methods needed must be added to this class; this class will be developed one time and used by all test cases.

Step3 : Use NariveAssert in the Native Test Methods

void NativeUnitTest1::TestMethod1(){
    //some code
    NativeAssert("test",p->name());
}

To improve the syntax we can add this define:

#define NativeAssert Assert

So the code will be:

void NativeUnitTest1::TestMethod1(){
    //some code
    Assert("test",p->name());
}

Step4: Integrate the Native Test Class into C++\CLI

Until now the goal has been to develop native test classes to avoid all of the drawbacks described before. In this last step, we have to integrate it to C++\CLI, and finally this CLI class will be just a wrapper to adapt the test class to the existing testing engine.

#include "nativetest.h"
using namespace System;
using namespace System::Text;
using namespace System::Collections::Generic;
using namespace Microsoft::VisualStudio::TestTools::UnitTesting;
namespace TestProject1
{
[TestClass]
public ref class UnitTest1
{
     public:
     [TestInitialize]
     void Initialize()
     {
        m_pTest=new NativeUnitTest1 ();
     }
     [TestCleanup]
     void Cleanup()
     {
         delete m_pTest;
     }
     [TestMethod]
     void TestMethod1()
     {
        m_pTest->test1();
     }
     NativeUnitTest1* m_pTest;
    };
}

The advantage of using this technique is that it resolves all problems related to creating a unit test for native C++ classes with few changes.



About the Author

Issam Lahlali

Product Manager of CppDepend. MCSD and MCSD.net certified.

Related Articles

Comments

  • good

    Posted by ghazanfar381 on 07/25/2011 05:02pm

    good article. http://solutionsdealer.net

    Reply
Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • Enterprise cloud adoption has evolved rapidly from fringe curiosity to the mainstream. As enterprises increasingly move mission-critical workloads to the cloud, it's important to track best practices to ensure a seamless migration process. While CIOs are becoming increasingly mature and pragmatic in their approach to cloud, surprises and challenges still need to be addressed. Read this eBook to learn the key best practices for cloud deployment success, the importance of SLAs in choosing a cloud provider, and …

  • Download this IDC report to learn how your organization can benefit from new flash architecture built for the cloud era. The IDC report examines the evolving primary flash array market with a particular emphasis on how next generation flash–driven enterprise storage architectures will take performance, scalability and infrastructure density to the next level.

Most Popular Programming Stories

More for Developers

RSS Feeds

Thanks for your registration, follow us on our social networks to keep up-to-date