Driver: fix opening serial on Mac OS X

manifest.xml

@@ -14,5 +14,8 @@
     <tags>stable</tags>
 
     <depend package="base/types" />
+    <depend package="base/logging" />
     <depend package="boost" />
+    <test_depend package="libgtest-dev" /> 
+    <test_depend package="google-mock" />
 </package>

src/CMakeLists.txt

@@ -1,12 +1,15 @@
 find_package(Boost COMPONENTS thread system)
 include_directories(${Boost_INCLUDE_DIRS})
 
+find_package(Threads REQUIRED)
+
 rock_library(iodrivers_base
     SOURCES Driver.cpp Bus.cpp Timeout.cpp IOStream.cpp Exceptions.cpp TCPDriver.cpp
-    IOListener.cpp
+    IOListener.cpp TestStream.cpp
     HEADERS Driver.hpp Bus.hpp Timeout.hpp Status.hpp IOStream.hpp
-    Exceptions.hpp IOListener.hpp TCPDriver.hpp
-    LIBS ${Boost_THREAD_LIBRARY} ${Boost_SYSTEM_LIBRARY} pthread
+    Exceptions.hpp IOListener.hpp TCPDriver.hpp TestStream.hpp
+    Fixture.hpp FixtureBoostTest.hpp FixtureGTest.hpp
+    LIBS ${Boost_THREAD_LIBRARY} ${Boost_SYSTEM_LIBRARY} ${CMAKE_THREAD_LIBS_INIT}
     DEPS_PKGCONFIG base-types base-lib)
 
 # For backward compatibility only

src/Driver.cpp

@@ -25,6 +25,7 @@
 #include <boost/lexical_cast.hpp>
 #include <iodrivers_base/IOStream.hpp>
 #include <iodrivers_base/IOListener.hpp>
+#include <iodrivers_base/TestStream.hpp>
 
 #ifdef __gnu_linux__
 #include <linux/serial.h>
@@ -106,6 +107,11 @@ void Driver::setMainStream(IOStream* stream)
     m_stream = stream;
 }
 
+IOStream* Driver::getMainStream() const
+{
+    return m_stream;
+}
+
 void Driver::addListener(IOListener* listener)
 {
     m_listeners.insert(listener);
@@ -124,7 +130,10 @@ void Driver::clear()
 }
 
 Status Driver::getStatus() const
-{ return m_stats; }
+{
+    m_stats.queued_bytes = internal_buffer_size;
+    return m_stats;
+}
 void Driver::resetStatus()
 { m_stats = Status(); }
 
@@ -153,8 +162,8 @@ void Driver::openURI(std::string const& uri)
     //   3 for UDP server
     //   4 for file (either Unix sockets or named FIFOs)
     int mode_idx = -1;
-    char const* modes[5] = { "serial://", "tcp://", "udp://", "udpserver://", "file://" };
-    for (int i = 0; i < 5; ++i)
+    char const* modes[6] = { "serial://", "tcp://", "udp://", "udpserver://", "file://", "test://" };
+    for (int i = 0; i < 6; ++i)
     {
         if (uri.compare(0, strlen(modes[i]), modes[i]) == 0)
         {
@@ -214,6 +223,16 @@ void Driver::openURI(std::string const& uri)
     { // file file://path
         return openFile(device);
     }
+    else if (mode_idx == 5)
+    { // test://
+        if (!dynamic_cast<TestStream*>(getMainStream()))
+            openTestMode();
+    }
+}
+
+void Driver::openTestMode()
+{
+    setMainStream(new TestStream);
 }
 
 bool Driver::openSerial(std::string const& port, int baud_rate)
@@ -372,8 +391,12 @@ int Driver::openSerialIO(std::string const& port, int baud_rate)
 
     struct termios tio;
     memset(&tio, 0, sizeof(termios));
-    tio.c_cflag = CS8 | CREAD;    // data bits = 8bit and enable receiver
-    tio.c_iflag = IGNBRK; // don't use breaks by default
+
+    tio.c_cflag = (CS8 | CREAD | CLOCAL);    // data bits = 8bit, enable reading 
+					     // and ignore modem status line
+    tio.c_iflag = IGNBRK; 		     // don't use breaks by default
+    cfsetispeed(&tio, B9600);                // set baud rate to something
+    cfsetospeed(&tio, B9600); 		     // otherwise tcsetattr complains on Mac OS
 
     // Commit
     if (tcsetattr(fd, TCSANOW, &tio)!=0)

src/Driver.hpp

@@ -80,9 +80,10 @@ class Driver
     /** The current count of bytes left in \c internal_buffer */
     size_t internal_buffer_size;
 
-protected:
+public:
     int const MAX_PACKET_SIZE;
 
+protected:
     /** The underlying object that gives us access to the actual I/O stream
      */
     IOStream* m_stream;
@@ -434,6 +435,26 @@ class Driver
      */
     void setMainStream(IOStream* stream);
 
+    /** Gets the main IO stream
+     */
+    IOStream* getMainStream() const;
+
+    /** Open the IO in test mode
+     *
+     * It is mostly equivalent to openURI("test://"), but is not meant to be
+     * overloaded, allowing to test openURI:
+     *
+     * <code>
+     * openTestMode()
+     * // Feed data to the driver
+     * openURI();
+     *
+     * Moreover, it will always create
+     * a new test "channel", while openURI will create a new one only if the
+     * current main stream is not a test stream already.
+     */
+    void openTestMode();
+
     /** Add a listener stream. The object's ownership is taken by the Driver
      * object.
      */

src/Exceptions.hpp

@@ -3,6 +3,7 @@
 
 #include <string>
 #include <stdexcept>
+#include <exception>  
 
 namespace iodrivers_base
 {
@@ -31,6 +32,23 @@ struct TimeoutError : std::runtime_error
 };
 
 }
-
+class MockContextException : public std::exception
+{  
+    public:  
+        const char * what() const throw()  
+        {  
+            return "IODRIVERS_BASE_MOCK Error: Expectation set outside Mock Context! Please call IODRIVERS_BASE_MOCK() before setting expectations";
+        }  
+};  
+
+class TestEndsWithExpectationsLeftException : public std::exception
+{
+       public:  
+        const char * what() const throw()  
+        {  
+            return "IODRIVERS_BASE_MOCK Error: Test reached its end without satisfying all expecations";
+        }  
+};  
+
 #endif
 

src/Fixture.hpp

@@ -0,0 +1,197 @@
+#ifndef IODRIVERS_BASE_BOOST_FIXTURE_HPP
+#define IODRIVERS_BASE_BOOST_FIXTURE_HPP
+
+#include <iodrivers_base/TestStream.hpp>
+#include <vector>
+#include <iodrivers_base/Exceptions.hpp>
+
+namespace iodrivers_base
+{
+    /** A fixture class designed to ease testing of iodrivers_base drivers in
+     * boost and GTest
+     *
+     * It creates a given Driver class, which must be opened with the test://
+     * URI. It then provides helper methods to provide access to the underlying
+     * TestStream.
+     *
+     * readPacket/writePacket/pushDataToDevice/readDataFromDevice are then
+     * available within the test.
+     *
+     * In boost-test:
+     *
+     * <code>
+     * BOOST_FIXTURE_TEST(MyTest, Fixture<MyDriver>)
+     * {
+     *   MyDriver.openURI("test://");
+     *   uint8_t buffer[4] = { 0, 1, 2, 3 };
+     *   pushDataToDriver(buffer, buffer + 2);
+     *   auto packet = readPacket();
+     *   // Check that the packet matches the expected extraction
+     * }
+     * </code>
+     *
+     * In GTest:
+     *
+     * <code>
+     * struct DriverTest : ::testing::Test, iodrivers_base::Fixture<MyDriver>
+     * {
+     *    Fixture()
+     *    {
+     *       // Optional: open here
+     *       // driver.openURI("test://")
+     *    }
+     *    
+     * }
+     * 
+     * TEST_F(DriverTest, it_handles_an_invalid_packet)
+     * {
+     *   MyDriver.openURI("test://");
+     *   uint8_t buffer[4] = { 0, 1, 2, 3 };
+     *   pushDataToDriver(buffer, buffer + 2);
+     *   auto packet = readPacket();
+     *   // Check that the packet matches the expected extraction
+     * }
+     * </code>
+     * 
+     * Mock Mode:
+     * To mock the behavior of the device in situations which a reply
+     * is expected, the mock mode should be set, using IODRIVERS_BASE_MOCK().
+     * The expectations are set usint EXPECT_REPLY(expectation, reply) and
+     * multiple expecations can be set. The mock will check the expecations and
+     * reply in the order that they were defined and will raise an error if
+     * any of them is not met. Mock mode is available in both BOOST and GTest
+     * Frameworks.
+     * 
+     *<code>
+     *IODRIVER_BASE_MOCK()
+     *uint8_t exp[] = { 0, 1, 2, 3 };
+     *uint8_t rep[] = { 3, 2, 1, 0 };
+     *EXPECT_REPLY(vector<uint8_t>(exp, exp + 4), 
+     *                   vector<uint8_t>(rep, rep + 4));
+     *writePacket(exp,4);
+     *
+     *<code>
+     */
+    template<typename Driver>
+    struct Fixture
+    {
+        typedef Driver fixture_driver_t;
+
+        std::vector<uint8_t> packetBuffer;
+        Driver driver;
+
+        Fixture()
+        {
+            packetBuffer.resize(driver.MAX_PACKET_SIZE);
+        }
+
+        /** Get the underlying TestStream
+         */
+        TestStream* getStream()
+        {
+            if (!driver.getMainStream())
+                driver.openTestMode();
+            return dynamic_cast<TestStream*>(driver.getMainStream());
+        }
+
+        /** Read a packet from the driver and return it as an std::vector
+         */
+        std::vector<uint8_t> readPacket()
+        {
+            size_t size = driver.readPacket(packetBuffer.data(), packetBuffer.size());
+            std::vector<uint8_t> packet;
+            packet.insert(packet.end(), packetBuffer.begin(), packetBuffer.begin() + size);
+            return packet;
+        }
+
+        /** Write data to the driver */
+        void writePacket(std::vector<uint8_t> const& data)
+        {
+            writePacket(data.data(), data.size());
+        }
+
+        /** Write data to the driver */
+        void writePacket(uint8_t const* buffer, size_t size)
+        {
+            driver.writePacket(buffer, size);
+        }
+
+        /** Push data to the driver "as-if" it was coming from the device
+         */
+        void pushDataToDriver(std::vector<uint8_t> const& data)
+        {
+            return getStream()->pushDataToDriver(data);
+        }
+
+        /** Helper method to allow passing any kind of uint8_t range
+         *
+         * <code>
+         * uint8_t packet[] = { 0, 1, 2, 3 };
+         * pushDataToDriver(packet, packet + sizeof(packet));
+         * </code>
+         */
+        template<typename Iterator>
+        void pushDataToDriver(Iterator begin, Iterator end)
+        {
+            std::vector<uint8_t> buffer(begin, end);
+            pushDataToDriver(buffer);
+        }
+
+        /** Read data that the driver sent to the device
+         */
+        std::vector<uint8_t> readDataFromDriver()
+        {
+            return getStream()->readDataFromDriver();
+        }
+
+        /** Return the number of bytes currently queued in the driver's internal
+         * buffer
+         *
+         * This is useful mainly when testing extractPacket
+         *
+         * <code>
+         * TEST_F(DriverTest, KeepsSingleBytes)
+         * {
+         *   uint8_t data = 0x01;
+         *   pushDataToDriver(&data, &data + 1);
+         *   ASSERT_THROW(TimeoutError, readPacket());
+         *   ASSERT_EQUAL(1, getQueuedBytes());
+         * }
+         * </code>
+         */
+        unsigned int getQueuedBytes() const
+        {
+            return driver.getStatus().queued_bytes;
+        }
+        void EXPECT_REPLY(std::vector<uint8_t> const& expectation, std::vector<uint8_t> const& reply)
+        {
+            getStream()->EXPECT_REPLY(expectation,reply);
+        }
+
+        /**
+         * Check if the test has any expectation set and throw if positive.
+         * It should be used to check if the test reached its end without 
+         * any expecation left only
+         */
+        void validateExpectationsAreEmpty()
+        {
+            if(!getStream()->expectationsAreEmpty())
+                throw TestEndsWithExpectationsLeftException();
+        }
+
+        void setMockMode(bool mode)
+        {
+            getStream()->setMockMode(mode);
+        }
+
+        void clearExpectations()
+        {
+            getStream()->clearExpectations();
+        }
+
+        class GTestMockContext;
+        class BoostMockContext;
+    };
+}
+
+#endif