{"id":14955,"date":"2017-04-19T17:04:52","date_gmt":"2017-04-20T01:04:52","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vcblog\/?p=14955"},"modified":"2020-02-18T10:34:33","modified_gmt":"2020-02-18T10:34:33","slug":"cpp-testing-in-visual-studio","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/cpp-testing-in-visual-studio\/","title":{"rendered":"C++ Unit Testing in Visual Studio"},"content":{"rendered":"

Testing is an increasingly important part of a software development workflow. In many cases, it is insufficient to test a program simply by running it and trying it out \u2013 as the scope of the project gets more involved, it becomes increasingly necessary to be able to test individual components of the code on a structured basis. If you\u2019re a C++ developer and are interested in unit testing, you\u2019ll want to be aware of Visual Studio\u2019s unit testing tools. This post goes through just that, and is part of a series aimed at new users to Visual Studio. \nThis blog post goes over the following concepts: <\/p>\n

    \n
  1. Setting Up Unit Testing<\/a><\/li>\n
  2. The Microsoft Native C++ Unit Test Framework<\/a><\/li>\n
  3. Using the Test Explorer to Run Tests in the IDE<\/a><\/li>\n
  4. Determining Unit Test Code Coverage<\/a><\/li>\n<\/ol>\n

    <\/a><\/p>\n

    Setting Up Unit Testing<\/h4>\n

    The easiest and most organized way to set up unit tests is to create a separate project in Visual Studio for your tests. You can create as many test projects as you want in a solution and connect them to any number of other Visual Studio projects in that solution that contain the code you want to test. Assuming you already have some code that you want to test, simply follow these steps to get yourself set up: <\/p>\n

      \n
    1. Right-click your solution and choose Add > New > Project<\/em><\/strong>. Click the Visual C++ <\/em>category, and choose the Test <\/em>sub-category. Select Native Unit Test Project<\/em>, give the project a descriptive name, and then click OK<\/em>. \n\"Image<\/li>\n
    2. Visual Studio will create a new project containing unit tests, with all dependencies to the native test framework already set up. The next thing to do is to add references to any projects that will be tested. Right-click the unit test project and choose Add > Reference…<\/em><\/strong>\n\"Image<\/li>\n
    3. Check any projects that you want to unit test from your test project, and then press OK<\/em>.\n\"Add\nYour unit testing project can now access your project(s) under test. You can now start writing tests, as long as you add #include statements for the headers you want to access. <\/li>\n<\/ol>\n

      NOTE:<\/strong> You will only be able to unit test public functions this way. To unit test private functions, you must write your unit tests in the same class as the code that is being tested. \n<\/a><\/p>\n

      The Microsoft Native C++ Unit Test Framework<\/h4>\n

      Visual Studio ships with a native C++ test framework that you can use to write your unit tests. The framework defines a series of macros to provide simplified syntax. <\/p>\n

      If you followed the steps in the previous procedure, you should have a unit test project set up along with your main code. Open unittest1.cpp in your test project and look at the starting code provided: \n\"Image\nRight from the start, you\u2019ll notice that dependencies <\/a>have already been set up to the test framework, so you can get to work writing your tests. Assuming you connected your test project to your project(s) under test via Add > Reference <\/em>earlier, you can simply add the #include statements for the header files of the code you want to test. <\/p>\n

      Tests can be organized by using the TEST_CLASS <\/em>and TEST_METHOD <\/em>macros, which perform exactly the functions you\u2019d expect. A TEST_CLASS <\/em>is a collection of related TEST_METHODS<\/em>, and each TEST_METHOD <\/em>contains a test. You can name your TEST_CLASS <\/em>and TEST_METHOD <\/em>anything you want in the brackets. It\u2019s a good idea to use descriptive names that make it easy to identify each test\/test group individually later. <\/p>\n

      Let\u2019s try writing some basic asserts. At the TODO <\/em>comment, write: \nAssert::AreEqual(1, 1);<\/code><\/p>\n

      This is a basic equality assert which compares two expressions. The first expression holds the expected value, the second holds the item you are testing. For the Assert to pass, both sides must evaluate to the same result. In this trivial example, the test will always pass. You can also test for values you don\u2019t want your expression to evaluate to, like this: \nAssert::AreNotEqual(1, 2);<\/code><\/p>\n

      Here, for the test to pass, the two expressions must not evaluate to the same result. While this kind of assert is less common, you may find it useful for verifying edge cases where you want to avoid a specific behavior from occurring. <\/p>\n

      There are several other Assert functions that you can try. Simply type Assert::<\/em> and let IntelliSense provide the full list to take a look. Quick Info tooltips appear for each Assert as you make a selection in the list, providing more context on their format and function. You can find a full reference of features in the Microsoft C++ native framework <\/a>on MSDN. \n<\/a><\/p>\n

      Using the Test Explorer to Run Tests in the IDE<\/h4>\n

      With Visual Studio, you\u2019re not restricted to running unit tests in the command line. The Text Explorer window in Visual Studio provides a simple interface to run, debug, and parallelize<\/a> test execution. \n\"Image\nThis is a straightforward process. Once you connect your test project to your project(s) under test, add some #include directives in the file containing your unit tests to the code under test, and write some Asserts, you can simply run a full build. Test Explorer will then discover all your unit tests and populate itself with them. <\/p>\n

      NOTE:<\/strong> In .NET, a feature called Live Unit Testing <\/a>is available. This feature is not currently supported in C++, so unit tests are discovered and executed only after you run builds. <\/p>\n

      To run your unit tests, simply click the Run All <\/strong>link in the Test Explorer. This will build your project (though this process is skipped if the project is already up to date) then run all your tests. The Test Explorer indicates the passing tests with a checkmark and the failing tests with an X. A summary of execution results is provided at the bottom of the window. You can click on any failing unit test to see why it failed, including any exceptions that may have been thrown. Execution times for each unit test are also provided. For realistic test execution times, test in the Release solution configuration rather than Debug, which will provide faster runtimes which are more approximate to your shipped application. <\/p>\n

      To be able to debug your code as you run your unit tests (so you can stop at breakpoints and so forth), simply use the Test > Debug <\/em><\/strong>menu to run your tests.\n<\/a><\/p>\n

      Determining Unit Test Code Coverage<\/h4>\n

      If you are using Visual Studio Enterprise, you can run code coverage on your unit tests. Assuming you have unit tests already set up for your project, this is as simple as going to Test > Analyze Code Coverage <\/em><\/strong>in the main Visual Studio menu at the top of the IDE. This opens the Code Coverage Results window which summarizes code coverage data for your tests. \n\"Image\nNOTE:<\/strong> There is a known issue where Code Coverage will not work in C++ unless \/DEBUG:FULL<\/em> is selected as the debugging configuration. By default, the configuration is set to \/DEBUG:FASTLINK<\/em> instead. You can switch to \/DEBUG:FULL<\/em> by doing the following: <\/p>\n

        \n
      1. Right-click the test project and choose Properties<\/em>.<\/li>\n
      2. Go to Linker > Debugging > Generate Debug Info<\/em>.<\/li>\n
      3. Set the option to Generate Debug Information optimized for sharing and publishing (\/DEBUG:FULL)<\/em>. <\/li>\n<\/ol>\n

        The Code Coverage Results window provides an option called Show Code Coverage Coloring<\/em>, which colors the code based on whether it\u2019s covered or not. \n\"Image\nCode coverage is counted in blocks, with a block being a piece of code with exactly one entry and exit point. If a block is passed through at least once, it is considered covered. <\/p>\n

        For more information on C++ unit testing, including some more advanced topics, check out the following MSDN articles: <\/p>\n