Sunday, 11 September 2011

In the spirit of the agile "just enough, just in time" principle, I had originally created the OSLC code sample in a minimalistic way to demonstrate what I was explaining in the posting. As I mentioned in my original post, I did not use method parameters and variables were stuck in to the global variable context. As it turns out, this is not very unit testable code.

This is one of the good things about unit testing; it forces one to make the code testable, and by consequence, better structured. Hence, I have refactored my code to add function parameters and have taken some variables out of the global context. I also fixed up a few other things.

In addition to this I have also broken the code base into three projects (or targets), one of which is the unit test executable. This is necessary as native executables typically only have one entry point, the main (WinMain, _main, etc.) function and I need two (one for the program itself and one for executing the unit tests only). I could of used command line arguments but this is not a good way of doing it. It is better practice to not mix unit test code with production code so I basically created projects that produce two executables: one with the unit tests, the other with the production executable (the "main" main function). The common code used by both I have but in a static library.

In continuation of my previous articles related to C/C++ development on Rational Team concert, i will continue here by adding cppunit unit tests. To start we need to add some things to the MinGW sys environment that I explained in the first posting. So, if you have not set up MinGW and Rational Team Concert to at least that point, you should do so before continuing.

There is no better way to understand the code then to show it so lets do some set up and get the code loaded. So lets start being installing MSYS into MinGW.

You will need to do the following:

1. From within a command prompt type and answer the questions appropriately.

mingw-get intall msys

2. You now need to run a post install script to set up MSYS to work with MinGW. You now need to launch the MSYS shell and run a post install script. You will need to know where your MinGW installation is (typically C:\MinGW). First launch MSYS and then run the script from the MSYS shell.

C:\MinGW\msys\1.0\msys.bat

/postinstall/pi.sh

3. We also need the MinGW developer toolkit. You can install it by running the following command from the command prompt.

mingw-get install mingw-developer-toolkit

4. Last thing is to add MSYS to you system path. Do so by adding C:\MinGW\msys\1.0\bin to you system path after the C:|MinGW\bin path entry.

Next step is to install cppunit. We will need to build it as well so we will download the distribution, build it using the MinGW build toolchain. We could also build it using Rational Team Concert but there is really no point to it as we are not developing or contributing to cppunit but rather just using it. The best thing is to install it into the MinGW directories so that we don't need to add extra include and library paths to our C/C++ projects, we can just keep the default MinGW ones.

2. Extract the tar ball into a memorable place. In my case it was C: (C:\cppunit-1.12.1)

3. Open a MSYS shell (C:\MinGW\msys\1.0\msys.bat) and change the directory to the cppunit directory and run the following commands:

cd C:/cppunit-1.12.1

./configure --prefix=/mingwmake make install

Thats it! You should now have cppunit installed into your MinGW compiler toolchain environment. Next step is to actually get the code.

1. Download the Rational Team Concert 3.0.1 OLSC sample projectsfrom here. As i mentioned in the opening, I have split the code base into three projects. A common library, the production executable and the unit test executable.

2. Extract the zip file into your Rational Team Concert workspace. (Delete the old ones if necessary)

3. Import the projects into Rational Team Concert by running "File->Import->General->Import Existing Projects" into Workspace

4. Do a search and replace ("Search->File") in the workspace for: servername, 9443, username, password and replace them with your corresponding rational team concert host name, port, username and password (for an JazzAdmins user preferably).

5. You will also need to adjust some paths in the build.xml files and make files in all the projects. If you do not remember which ones please look at the blog posting about setting up static analysis (the CLASSPATH and JAVA variables in the Makefiles and the path to RSAR in build.xml). If you do not want static analysis as part of the build you can comment the corresponding lines out.

You should be able to build after doing the proper adjustments. You will notice that the builds are using the MinGW make tool and generating make files. This seems to work the best with Rational Team Concert and CDT. It also provides the added benefit of easily testing Makefiles by simply switching the "Generate Makefiles Automatically" option in the "Project Properties->C/C++ Build" section.

Keys things to note here is the refactoring that has been doing to the project and build environments:

Three Projects:

OSLC Consumer: The Production executable

OSLC Consumer Common: A static library used by the executables

Test OSLS Consumer: The unit test executable that runs the unit tests

Three makefiles and build.xml files:

OSLC Consumer

JBEMakefile builds the production exe and runs static analysis on OSLC Consumer (OSLCConsumer.exe) and also kicks off the other project makefiles as a precondition. It is used directly by the JBE (Jazz Build Engine).

build.xml provides updates to JBE about the build and published static analysis links an artifacts.

build.xml provides updates to JBE about the build and published static analysis links an artifacts. It also publishes the xml unit test results to JBE using the cppunitLogPublisher tag.

The build engine definition remains unchanged from previous blogs. The only thing to do is to deliver the code into the RTC SCM, accept it into the Build Stream and request a build as described in previous blogs.

The end result you should see a build result like this:

You can see that 2 unit test were run ant they both succeeded. You can try to make the unit test fail on purpose by modifying the code to see what happens. You can also see the static analysis artifacts and links.

I you actually take a look at the test you can see that the results have been published:

So, we have no build a complete template C/C++ software development environment in Rational Team Concert 3.0.1.

I am not sure what I should cover in subsequent blogs regarding this topic but I am open to suggestions!

Disclaimers

The postings on this site are my own and don't necessarily represent IBM's position, strategies or opinions.

Anyone is free to use, copy, distribute, modify or sell the source code and other materials directly linked from boriskuschel.com and isprovided "as is" without warranties.I am not responsible for any harm or damage caused to your computer, software or anything else caused by the material.