Part III:  Developing and Testing the Domain Layer

[Author's note, July 28, 2010: Fixed minor bug in LaserScanReader.cpp wherein it couldn't be restarted after being stopped; had to reset _stopRequested to false.]

In Part II of this series, we created the humble beginnings of the package and added folders to accommodate all of the layers of our end product, a well-designed ROS package that reports (fake) laser scan reports.  In this post, the domain layer of the package will be fleshed out along with unit tests to verify the model and functionality, accordingly.  The entire focus will be on implementing just one of the requirements initially described in Part I:  The package will read laser reports coming from a laser range-finder. If you’d like to download the resulting source for this article, click here.

That certainly sounds easy enough.  Disregarding the previous discussions concerning architecture, the gut reaction might be to start adding code to main(), simply taking the results from the range-finder, turning them directly into a ROS message, and publishing the messages to the appropriate ROS topic.  This myopic “get ‘er done” approach quickly gets out of hand as main() turns into a tangled mess of code managing a variety of responsibilities.  Object oriented principles aside, having all of these separate concerns mashed into main turns the little package into a maintenance nightmare with little ability to reuse code.  As mentioned, the first concern that we’ll want to tackle is the ability to read laser range-finder reports.  We’ll tackle this requirement by encapsulating the range-finder integration code within a class called LaserScanReader.cpp.  By doing so, all of the communications to the range-finder are properly encapsulated within one or more classes, making the integration code easier to reuse and maintain.  To keep our focus on the overall architecture, and to avoid the need to have a physical range-finder handy, we’ll simulate range-finder communications within LaserScanReader.cpp.  Certainly an added benefit of this approach, if we were doing this for a real-world package, is that one group could work on the “rest” of the package while another group works on the actually range-finder communications; so when ready, LaserScanReader.cpp could be switched out with the “real” range-finder integration code.

Prerequisites:

• ROS Box Turtle or later
• Familiarity with C++

Before proceeding, recall that, as described in Part I, the domain layer of the package should not have knowledge concerning how to communicate with the messaging middleware directly (e.g., ROS).  This implies that the domain layer should have no direct dependencies on the messaging middleware.  This allows the domain layer to be more easily reused with another messaging middleware solution.  Additionally, keeping this clean separation of concerns facilitates the testing of the domain layer independently from its interactions with the messaging middleware.  Accordingly, the simple domain layer developed in this post will adhere to this guidance along with full testing for verification of capabilities as well.

Our LaserScanReader class will expose two methods, beginReading() and stopReading(), along with an observer hook to provide a call-back to be invoked whenever a new reading is available.  For now, we won’t worry about what exactly will be called back in the completed package, as that’ll be a concern of the application services layer; but we’ll need to prepare for it by including an interface for the laser scan observer.

Target Class Diagram

The following diagram shows what the package will look like after completing the steps in this post. While the individual elements will be discussed in more detail; the class diagram should serve as a good bird’s eye view of the current objectives.

1. Setup the Package Skeleton

If not done already, follow the steps in Part II to create the beginnings of the package.

2. Create the ILaserScanListener Observer Header

Whenever a laser scan is read, it’ll need to be given to whomever is interested in it. It should not be the responsibility of the laser scan reader to predict who will want the laser scans. Accordingly, an observer interface should be introduced which the laser scan reader will communicate through to raise laser scan events to an arbitrary number of listeners.

Add a new interface header file to /ladar_reporter/src/core called ILaserScanListener.hpp containing the following code:

// ILaserScanListener.hpp
 
#ifndef GUARD_ILaserScanListener
#define GUARD_ILaserScanListener
 
#include "sensor_msgs/LaserScan.h"
 
namespace ladar_reporter_core
{
  class ILaserScanListener
  {
    public:
      // Virtual destructor to pass pointer ownership without exposing base class [Meyers, 2005, Item 7]
      virtual ~ILaserScanListener() {}
      virtual void onLaserScanAvailableEvent(const sensor_msgs::LaserScan& laserScan) const = 0;
  };
}
 
#endif /* GUARD_ILaserScanListener */

As you can see, this C++ interface (or as close as you can get to an interface in C++) simply exposes a single function to handle laser scan events.

3.  Create the LaserScanReader Header

Add a new class header file to /ladar_reporter/src/core called LaserScanReader.hpp containing the following code, which we’ll discuss in detail below.

// LaserScanReader.hpp
 
#ifndef GUARD_LaserScanReader
#define GUARD_LaserScanReader
 
#include <pthread.h>
#include <vector>
#include "sensor_msgs/LaserScan.h"
#include "ILaserScanListener.hpp"
 
namespace ladar_reporter_core
{
  class LaserScanReader
  {
    public:
      LaserScanReader();
 
      void beginReading();
      void stopReading();
 
      // Provides a call-back mechanism for objects interested in receiving scans
      void attach(ILaserScanListener& laserScanListener);
 
    private:
      void readLaserScans();
      void notifyLaserScanListeners(const sensor_msgs::LaserScan& laserScan);
 
      std::vector<ILaserScanListener*> _laserScanListeners;
 
      // Basic threading support as suggested by Jeremy Friesner at
      // http://stackoverflow.com/questions/1151582/pthread-function-from-a-class
      volatile bool _stopRequested;
      volatile bool _running;
      pthread_t _thread;
      static void * readLaserScansFunction(void * This) {
        ((LaserScanReader *)This)->readLaserScans();
        return 0;
      }
  };
}
 
#endif /* GUARD_LaserScanReader */

Let’s now review the more interesting parts of the header class:

• Lines 3-4:  Standard header guard so that the class is not declared multiple times.
• Line 8:  Include the laser scan message from ROS.  As discussed previously, the domain layer should not have any direct dependencies on the messaging infrastructure.  The question here is whether or not the domain layer’s knowledge of the laser scan message class violates this principle.  When I initially developed this example code, I wrote a domain-specific equivalent of the laser scan message, placed within /core, so as to avoid any direct dependencies on anything ROS related.  Continuing in this vein, it would then be required that the message endpoint contain a message translator to  convert the domain-specific laser scan class into the corresponding ROS laser scan message, for subsequent publication to ROS.  The motivation for taking this “theoretically pure” approach was to reduce coupling between the domain layer and the messaging infrastructure; one of the advantages being to enable the ability to swap out the messaging infrastructure with another messaging option while having no impact on the domain layer of the package.
  With that said, ROS makes available a very well organized model which is useful to the domain beyond the concerns of messaging itself.  For example, our laser scan reader class is only concerned with  reading information from the laser scanning device (e.g., Sick LMS111 or Hokuyo URG-04LX-UG01) and raising the laser scan event data.  Accordingly, regardless of the chosen messaging infrasturcture, the laser reader ultimately needs to encapsulate the laser scan information within a class for intra-package data passing.  The reader could use a custom (domain-specific) class to encapsulate this information, but we’d end up replicating many of the ROS message classes along with an equivalent number of message translators, without much decoupling benefit.  To illustrate, in the unlikely event that the ROS messaging infrastructure needed to be swapped out with another messaging solution, the domain layer could continue using the strongly typed ROS message classes in the domain, using message translator within the message endpoints, to translate between the ROS message classes (and other domain-specific classes we may be using) with the messages required by the messaging infrastructure.  If ROS messages were not strongly typed, being a collection of name/value pairs instead, for example, then I would avoid referencing ROS message classes from within the domain layer.
  So in our example package here, we will slightly ease the rule of strict domain-layer/ROS decoupling and allow the use of ROS message classes from within the domain layer while still avoiding the introduction of any ROS communication details to the domain, such as how to publish to a topic.  This theoretical vs. practical compromise is a discussion that should be had with any project team to carefully decide how strictly decoupling should be enforced on a given package and specifically where the rule may be eased, if and when appropriate.  In this case, the benefits of using the strongly typed ROS message classes were weighed against the introduction of domain-layer coupling to those classes, accordingly.  Keep in mind that any introduction of coupling with the messaging infrastructure should be carefully reviewed, and well justified, before doing so.
• Lines 18-19:  Declare the methods beginReading() and stopReading() which will provide the ability to start and stop the reader, respectively.
• Line 22:  Provide a means for laser scan listeners (observers) to register to receive laser scan reports when available.
• Line 25:  The readLaserScans() function actually does the work of reading laser reports from the laser scanner and raising the laser data events.  We’ll see in the implementation that it’ll be invoked within the beginReading() function.
• Line 26: notifyLaserScanListeners() has the responsibility of informing all laser scan listeners that a new laser scan is available.
• Line 28: _laserScanListeners will hold a reference to every laser scan listerner.
• Lines 32-38:  These members will facilitate the ability to read and raise laser scan events asynchronously. (As a side note, I spent an abhorrent amount of time trying to get Boost::Thread and Boost::signals2 in place for the threading and callback mechanisms within the ROS context. While I got it working most of the time, the intermittent segfault finally made me throw in the towel in favor of pthreads and observer pattern; more on this below.)

4.  Create the LaserScanReader Class Implementation

Add a new class file to /ladar_reporter/src/core called LaserScanReader.cpp containing the following code, which we’ll discuss in detail below.

// LaserScanReader.cpp
 
#include "LaserScanReader.hpp"
 
namespace ladar_reporter_core
{
  LaserScanReader::LaserScanReader()
    : _stopRequested(false), _running(false) {
    _laserScanListeners.reserve(1);
  }
 
  void LaserScanReader::attach(ILaserScanListener& laserScanListener) {
    _laserScanListeners.push_back(&laserScanListener);
  }
 
  void LaserScanReader::beginReading() {
    if (! _running) {
      _running = true;
      _stopRequested = false;
      // Spawn async thread for reading laser scans
      pthread_create(&_thread, 0, readLaserScansFunction, this);
    }
  }
 
  void LaserScanReader::stopReading() {
    if (_running) {
      _running = false;
      _stopRequested = true;
      // Wait to return until _thread has completed
      pthread_join(_thread, 0);
    }
  }
 
  void LaserScanReader::readLaserScans() {
    int i = 0;
 
    while (! _stopRequested) {
      sensor_msgs::LaserScan laserScan;
      // Just set the angle_min to include some data
      laserScan.angle_min = ++i;
      notifyLaserScanListeners(laserScan);
      sleep(1);
    }
  }
 
  void LaserScanReader::notifyLaserScanListeners(const sensor_msgs::LaserScan& laserScan) {
    for (int i= 0; i < _laserScanListeners.size(); i++) {
        _laserScanListeners[i]->onLaserScanAvailableEvent(laserScan);
    }
  }
}

Let’s now review the more interesting parts of the class implementation:

• LaserScanReader constructor:  The constructor for the LaserScanReader class initializes the _stopRequested member to false.  Since the reading of laser scans will be performed asynchronously, this private member acts as a poor man’s state machine, facilitating a means to stop the reading of laser scans if set to true. In addition to this, the constructor reserves a wee bit of expected space to avoid too much space being allocated upon the first add to the vector.
• beginReading():  This function will be called to begin the process of reading laser scans from the laser range finder.  The first step of this process sets the _stopRequested member to ensure that the readings won’t stop until requested to do so.  Next, a new thread is begun to execute the readLaserScans() function asynchronously.  I spent a very long amount of time researching different approaches for the simple thread management needed in this class; the most simple and stable solution I found was on stackoverflow.com. (Please let me know if you have a simpler, cleaner – and still stable – solution.)
• stopReading():  This function does not explicitly stop the laser scan reading process.  Instead, it simply sets the _stopRequested member to false to inform the asynchronous reading process to terminate. The pthread_join() function is called to wait until the thread represented by the thread object has completed.
• readLaserScans():  In a real package, this function would communicate with the physical range finding device, collect data, and raise laser scan information via the onLaserScanAvailableEvent.  In our example code here, we’ll simply create a number of fake laser scan reports as long as the _stopRequested member does not equal true.

  Note again that by using the observer pattern to raise laser scan events to listeners, the implementation code need not be aware of who a priori is listening for laser scans, only that a means exists to raise laser scan events, accordingly.  Arguably, readLaserScans() could publish laser scans directly to ROS topics. But this approach comes with the drawback of tightly coupling the laser scan reading functionality to the ROS messaging system, it violates the Single Responsibility Principle, and it makes it more difficult to do “any other stuff” (whatever that may be) with the laser scans before they’re handed off to ROS for publishing without further cluttering readLaserScans().  As the package evolves, we’ll see that an application services layer will be put in place to coordinate the task of handling the laser scan events and passing the information onto a message endpoint for publication to ROS.

• notifyLaserScanListeners(): Raises the laser scan to any observers. Be sure to note that this does not publish laser scans to ROS, but only raises them to registered observers within the package.

5.  Add a ROS sensor_msgs Dependency to manifest.xml

Since the code above refers to sensor_msgs::LaserScan, a dependency needs to be added for the package to use this class, accordingly:

• Under /ladar_reporter, open manifest.xml and add the following line just before the closing </package> tag:

  <depend package="sensor_msgs" />

6.  Configure CMake to Include both the Header and Implementation

With the header and implementation classes completed, we need to make a couple of minor modifications to CMake for their inclusion in the build.

First, open /ladar_reporter/CMakeLists.txt and make the following modifications:

1. Under the first line, which sets the cmake_minimum_required, add a new line to set the project name:

   project(ladar_reporter)

2. At the end of the CMake file:

   # Include subdirectories for headers
   include_directories(
     "src/core"
   )
   
   add_subdirectory(src)

In doing so, the LaserScanReader header has been included for consumption by other classes and application layers.  This inclusion has been done in the root CMakeLists.txt as this will make the headers available to the unit tests as well.  For more complex packages, this approach of including the headers in the root CMakeLists.txt, to make them globally accessible, may become a bit messy; it may be more appropriate to put the header inclusions in only the CMakeLists.txt which actually require the respective headers if the package is larger.

At this point, a new CMake file is needed under /ladar_report/src:

• Create a new CMakeLists.txt under /ladar_reporter/src, containing the following:

  # Include subdirectories with their own CMakeLists.txt
  add_subdirectory(core)

You’ll quickly notice that this CMake file has merely passed the buck of defining class libraries further down the chain.  Accordingly, a CMakeLists.txt will be setup for each of the package layers including application_services, core, message_endpoints, and ui.  All of these layers will be compiled into separate class libraries and, finally, an executable.  Arguably, all of these layers could be combined into a single executable with a single CMakeLists.txt file.  But keeping them in separate class libraries keeps a clean separation of concerns in their respective responsibilities and makes each aspect of our package more easily testable in isolation from the other layers.

Next, in order to create the core class library, a new CMake file is needed under /ladar_reporter/src/core:

• Create a new CMakeLists.txt under /ladar_reporter/src/core, containing the following:

  # Create the core library
  add_library(
    ladar_reporter_core
    LaserScanReader.cpp
  )

We’re now ready to compile the class library for the “core” layer of the package…

7.  Build the core Class Library

In a terminal window, cd to /ladar_reporter and run make.  The class library should build and link successfully.

Woohoo!  Done, right?  Well, not yet…time to test our new functionality.

8.  Unit Test the LadarScanReader Functionality

So far, you’ve had to simply assume that a successful build means everything is working as expected.  Obviously, when developing a ROS package, we’ll want a bit more reassurance than a successful build to be confident that the developed capabilities are working as expected.  Accordingly, unit tests should be developed to test the functionality; in the case at hand, a unit test will be developed to initialize, begin and stop the laser reading cycle to ensure that it is raising laser scan events as designed.

The standard ROS testing tool is gtest; this is a great choice as gtest is very easy to setup and provides informative output during unit test execution.  To setup and run unit tests for the package, only two elements are needed:  a “test runner” to act as the unit tests’ main and to execute all of the package unit tests, and the unit tests themselves which may be spread out among a variety of folders and classes.  When unit testing, I typically write one unit testing class (a test fixture) per class being tested.  Furthermore, I include one unit test for each public function or behavior of the class being tested.  As for a couple of other unit testing best practices, be sure to keep the unit tests independent from each other – they should be able to be run in isolation without being dependent on the running of other unit tests.  Additionally, each unit test is organized as three stages of the test:  “establish context” wherein the testing context is setup, “act” wherein the desired behavior is invoked, and “assert” wherein the results of the behavior are verified. Finally, no testing code should be added to the “production” source code itself; all tests should be maintained in a separate executable to keep a clean separation of concerns between application code and tests.  We’ll see an example of this as we proceed.

1. To begin testing the laser scan reader, first define the test runner by creating /ladar_reporter/test/TestRunner.cpp containing the following:

   #include <gtest/gtest.h>
    
   // Run all the tests that were declared with TEST()
   int main(int argc, char **argv){
     testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
   }

2. Now that the unit tests’ main is in place, create /ladar_reporter/test/core/LaserScanReaderTests.cpp containing the following testing code:

   #include <gtest/gtest.h>
   #include "LaserScanReader.hpp"
   #include "ILaserScanListener.hpp"
   #include "sensor_msgs/LaserScan.h"
    
   using namespace ladar_reporter_core;
    
   namespace ladar_reporter_test_core
   {
     // Will be used by unit test to handle laser scans
     struct LaserScanReceiver : public ladar_reporter_core::ILaserScanListener
     {
       LaserScanReceiver()
         : countOfLaserScansReceived(0) { }
    
       mutable int countOfLaserScansReceived;
    
       void onLaserScanAvailableEvent(const sensor_msgs::LaserScan& laserScan) const {
         countOfLaserScansReceived++;
    
         // Output the laser scan seq number to the terminal; this isn't the
         // unit test, but merely a helpful means to show what's going on.
         std::cout << "Laser scan sent to LaserScanReceiver with angle_min of: " << laserScan.angle_min << std::endl;
       }
     };
    
     // Define the unit test to verify ability to start and stop the reader
     TEST(LaserScanReaderTests, canStartAndStopLaserScanReader) {
       // Establish Context
       LaserScanReader laserScanReader;
       LaserScanReceiver laserScanReceiver;
    
       // Wire up the reader to the handler of laser scan reports
       laserScanReader.attach(laserScanReceiver);
    
       // Act
       laserScanReader.beginReading();
       // Let it perform readings for a couple of seconds
       sleep(2);
       laserScanReader.stopReading();
    
       // Assert
    
       // Since we just ran the reader for 2 seconds, we should expect a few readings.
       // Arguably, this test is a bit light but makes sure laser scans are being reported.
       EXPECT_TRUE(laserScanReceiver.countOfLaserScansReceived > 0 &&
         laserScanReceiver.countOfLaserScansReceived <= 10);
     }
   }

3. Then to include the new test in the build, open /ladar_reporter/CMakeLists.txt and add the following to the end of the file:

   add_subdirectory(test)

   As seen before, this has just passed the buck onto subsequent CMake file(s) to include the appropriate files in the build – which is preferred. Ideally, each CMakeLists.txt should only know about its immediate “surroundings” and not have the concerns of subfolders added to it.

4. Next, create a new CMakeLists.txt file under /ladar_reporter/test containing the following:

   rosbuild_add_executable(
     ladar_reporter_tests
     TestRunner.cpp
     ./core/LaserScanReaderTests.cpp
   )
   
   rosbuild_add_gtest_build_flags(ladar_reporter_tests)
   
   # Link the libraries
   target_link_libraries(
     ladar_reporter_tests
     ladar_reporter_core
   )

   This CMake file instructs the make process to create a stand-alone gtest executable called ladar_reporter_tests, made up of the two files indicated. (As a side note, ROS has a macro called rosbuild_add_gtest which will include and run the tests automatically when compiled with the command make test. I have reliably encountered segfaults when using Boost asynchronous threading and building with rosbuild_add_gtest. Interestingly, I do not run into such problems if I build and run the testing executable separately from the make process. I have thoroughly researched this topic (i.e., thrown laptops through windows), and have found no solution. Moral of the story: use rosbuild_add_executable to create your test executable.)

5. With everything in place, head back to the terminal and run:

   make
   cd bin
   ./ladar_reporter_tests

When the test runs, you should see a few laser scan angle_min values get printed to the terminal along with the final report that the test successfully passed.

Now that we’ve done all of the above to complete the core domain layer of the package, let’s review what have was accomplished:

• Header and implementation classes were developed for communicating with the (fake) laser scan range finder;
• An observer interface was established to allow (yet unseen) observers listen for new laser scans;
• A unit test was developed, outside of the package source, to test the reader functionality;
• CMake was configured to compile the artifacts and to run tests with gtest; and
• Most importantly, we’ve been able to develop and test our core functionality without needing to involve the ROS messaging system (outside of the use of its LaserScan message class) and without having to prematurely develop any UI layers to test the completed code.

In Part IV, we’ll be setting our sights on developing and testing the application services layer of the application with a test double standing in for the ROS messaging system.

Enjoy!
Billy McCafferty

Download the source for this article.