improved tests to check unimplemented methods in device drivers

Author: randaz81

src/devices/fake/fakeDeviceUnwrapped/FakeDeviceUnwrapped.cpp

@@ -22,6 +22,12 @@ yarp::dev::ReturnValue FakeDeviceUnwrapped::doSomething()
     return ReturnValue_ok;
 }
 
+yarp::dev::ReturnValue FakeDeviceUnwrapped::doSomethingUnimplemented()
+{
+    yCInfo(FAKEDEVICEUNWRAPPED) << "doSomethingUnimplemented executed, returning unimplemented";
+    return yarp::dev::ReturnValue::return_code::return_value_error_not_implemented_by_device;
+}
+
 yarp::dev::ReturnValue FakeDeviceUnwrapped::testSetValue(int value)
 {
     yCInfo(FAKEDEVICEUNWRAPPED) << "testSetValue" << value;

src/devices/fake/fakeDeviceUnwrapped/FakeDeviceUnwrapped.h

@@ -39,6 +39,7 @@ class FakeDeviceUnwrapped :
 
     //IFakeDeviceInterfaceTest1
     yarp::dev::ReturnValue doSomething() override;
+    yarp::dev::ReturnValue doSomethingUnimplemented() override;
 
     //IFakeDeviceInterfaceTest2
     yarp::dev::ReturnValue testSetValue(int value) override;

src/devices/fake/fakeDeviceWrapper/FakeDeviceWrapper.cpp

@@ -8,6 +8,7 @@
 #include <yarp/os/Log.h>
 #include <yarp/os/LogComponent.h>
 #include <yarp/os/LogStream.h>
+#include <yarp/dev/ControlBoardInterfaces.h>
 
 using namespace yarp::os;
 using namespace yarp::dev;
@@ -34,6 +35,9 @@ yarp::dev::ReturnValue FakeDeviceWrapper::testGetValue(int& value)
 
 bool FakeDeviceWrapper::open(yarp::os::Searchable& config)
 {
+    this->m_RpcPort.open("/FakeDeviceWrapper/rpc");
+    m_RpcPort.setReader(*this);
+
     yCInfo(FAKEDEVICEWRAPPER) << "FakeDeviceWrapper opened";
     return true;
 }
@@ -59,3 +63,46 @@ bool FakeDeviceWrapper::attach(yarp::dev::PolyDriver* drv)
     }
     return false;
 }
+
+bool FakeDeviceWrapper::read(yarp::os::ConnectionReader& connection)
+{
+    yarp::os::Bottle command;
+    yarp::os::Bottle reply;
+    ReturnValue retval;
+
+    bool ok = command.read(connection);
+    if (!ok) {
+        return false;
+    }
+    reply.clear();
+
+    if (command.get(0).asString() == "testSetValue")
+    {
+        retval = testSetValue(1);
+        if (retval) {reply.addVocab32(VOCAB_OK);}
+        else  {reply.addVocab32(VOCAB_ERR);}
+    }
+    else
+    if (command.get(0).asString() == "testGetValue")
+    {
+        int val=0;
+        retval = testGetValue(val);
+        if (retval) {
+            reply.addVocab32(VOCAB_OK);
+        }
+        else {
+            reply.addVocab32(VOCAB_ERR);
+        }
+    }
+    else
+    {
+        reply.addVocab32(VOCAB_ERR);
+    }
+
+    yarp::os::ConnectionWriter *returnToSender = connection.getWriter();
+    if (returnToSender != nullptr)
+    {
+        reply.write(*returnToSender);
+    }
+    return true;
+}

src/devices/fake/fakeDeviceWrapper/FakeDeviceWrapper.h

@@ -10,6 +10,8 @@
 #include <yarp/dev/PolyDriver.h>
 #include <yarp/dev/WrapperSingle.h>
 
+#include <yarp/os/Port.h>
+
  /**
  * @ingroup dev_impl_fake
  *
@@ -19,10 +21,12 @@
 class FakeDeviceWrapper :
         public yarp::dev::DeviceDriver,
         public yarp::dev::WrapperSingle,
-        public yarp::dev::test::IFakeDeviceInterfaceTest2
+        public yarp::dev::test::IFakeDeviceInterfaceTest2,
+        public yarp::os::PortReader
 {
 private:
     yarp::dev::test::IFakeDeviceInterfaceTest2* iTest=nullptr;
+    yarp::os::Port m_RpcPort;
 
 public:
     FakeDeviceWrapper() = default;
@@ -44,6 +48,9 @@ class FakeDeviceWrapper :
     //interfaces
     yarp::dev::ReturnValue testSetValue(int value) override;
     yarp::dev::ReturnValue testGetValue(int& value) override;
+
+    // From PortReader
+    bool read(yarp::os::ConnectionReader& connection) override;
 };
 
 #endif

src/devices/fake/fakeDevice_nwc_yarp/FakeDevice_nwc_yarp.cpp

@@ -54,3 +54,9 @@ yarp::dev::ReturnValue FakeDevice_nwc_yarp::doSomething()
     yarp::dev::ReturnValue ret = m_thrift_RPC.doSomethingRPC();
     return ret;
 }
+
+yarp::dev::ReturnValue FakeDevice_nwc_yarp::doSomethingUnimplemented()
+{
+    yarp::dev::ReturnValue ret = m_thrift_RPC.doSomethingUnimplementedRPC();
+    return ret;
+}

src/devices/fake/fakeDevice_nwc_yarp/FakeDevice_nwc_yarp.h

@@ -34,5 +34,6 @@ class FakeDevice_nwc_yarp : public yarp::dev::DeviceDriver,
     bool close() override;
 
     //From IFakeInterface
-    yarp::dev::ReturnValue doSomething();
+    yarp::dev::ReturnValue doSomething() override;
+    yarp::dev::ReturnValue doSomethingUnimplemented() override;
 };

src/devices/fake/fakeDevice_nws_yarp/FakeDeviceServerImpl.cpp

@@ -30,6 +30,24 @@ yarp::dev::ReturnValue FakeServerRPCd::doSomethingRPC()
     return yarp::dev::ReturnValue_ok;
 }
 
+yarp::dev::ReturnValue FakeServerRPCd::doSomethingUnimplementedRPC()
+{
+    if (m_iFake == nullptr)
+    {
+        yCError(FAKEDEVICESERVER, "Invalid interface");
+        return yarp::dev::ReturnValue::return_code::return_value_error_not_ready;
+    }
+
+    yarp::dev::ReturnValue ret = m_iFake->doSomethingUnimplemented();
+    if (!ret)
+    {
+        yCError(FAKEDEVICESERVER, "doSomethingUnimplemented() failed");
+        return ret;
+    }
+
+    return yarp::dev::ReturnValue_ok;
+}
+
 void FakeServerRPCd::setInterface(yarp::dev::test::IFakeDeviceInterfaceTest1* _ifake)
 {
     m_iFake = _ifake;

src/devices/fake/fakeDevice_nws_yarp/FakeDeviceServerImpl.h

@@ -21,4 +21,5 @@ class FakeServerRPCd : public FakeTestMsgs
 
     // From FakeTestMsgs
     yarp::dev::ReturnValue doSomethingRPC() override;
+    yarp::dev::ReturnValue doSomethingUnimplementedRPC() override;
 };

src/libYARP_dev/src/yarp/dev/testInterfaces/IFakeDeviceInterfaceTest1.h

@@ -28,6 +28,11 @@ class YARP_dev_API IFakeDeviceInterfaceTest1
      * A method for testing purposes
      */
     virtual yarp::dev::ReturnValue doSomething() = 0;
+
+    /**
+     * A method for testing purposes, which implementation is not implemented
+     */
+    virtual yarp::dev::ReturnValue doSomethingUnimplemented() = 0;
 };
 
 } // namespace yarp::dev::test