Improve Unit Testing with Visual C++ Programming

WEBINAR:
On-Demand

Application Security Testing: An Integral Part of DevOps


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
  • You must have javascript enabled in order to post comments.

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

Top White Papers and Webcasts

  • CEOs, CIOs, boards and shareholders are demanding digital transformation. They want their organizations to be more customer-focused, competitive and strategic to increase revenue. Data drives all of those aspects. A great first step in optimizing data use is moving data to the cloud. It can quickly show benefits. Here are six aspects of a cloud data management strategy that will help your organization more fully move, manage and use valuable data to successfully support digital transformation.

  • A leading provider of tools and services to the health care industry was looking to implement automated chargeback reports with aggregation of tiered storage usage across multiple business units and applications. When the company's storage administrators attempted to create this system in-house, their productivity took a huge hit and they discovered the task was too challenging, as well. Read this case study to learn how this company was able to increase storage utilization, reduce storage consumption, and …

Most Popular Programming Stories

More for Developers

RSS Feeds

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