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

  • Testing full recoveries of IT environments requires a proven methodology. Establishing and meeting recovery time objectives (RTOs), configuring a cloud recovery system, and tracking your changing environment are all critical components of a successful cloud recovery operation. It's also important to establish and follow a set of cloud disaster recovery (CDR) best practices. Read this technical guide to learn about these best practices, along with how disaster recovery as a service (DRaaS) can help you complete …

  • On-demand webcast Lately it seems that everywhere you turn, there's another cybersecurity breach — and hackers and thieves are never satisfied with the status quo, continuing to refine their tactics or create new methods of attack. So how do you protect your business now, but also plan for your future security needs? How can you guard against this ever-changing threat landscape? Watch Jeremy Smolik, Systems Engineer at Kaspersky Lab North America, in this on-demand webinar as we explore the biggest …

Most Popular Programming Stories

More for Developers

RSS Feeds

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