test: add sip and base64 tests

sip
* testMultipleOutgoingIpCall()
* testHoldIpCall()
* testSIPURI()
* testSimpleIncomingIpCall()
* testMultipleIncomingIpCall() wip

*base64
*test_video_input
tests done by Florian Wiesweg
https://gerrit-ring.savoirfairelinux.com/#/c/6652/

Change-Id: I748318cfade68ac1c42050f6a1d734a029b5128c
Reviewed-by: Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>

configure.ac

@@ -382,7 +382,7 @@ AS_IF([test "x$with_dbus" = "xyes"], [
        AS_IF([test "x$CLANG" = "xyes"], [
              AC_MSG_ERROR([dbus does not compile when clang is used, rerun with --without-dbus])
        ]);
-       AM_CONDITIONAL(RING_DBUS, true)],
+       AM_CONDITIONAL(RING_DBUS, true)],TESTS= $(check_PROGRAMS)
        AM_CONDITIONAL(RING_DBUS, false));
 
 dnl Ring name service is default-enabled
@@ -731,6 +731,9 @@ AC_CONFIG_FILES([Makefile \
                  ringtones/Makefile \
                  test/Makefile\
                  test/sip/Makefile \
+                 test/base64/Makefile \
+                 test/media/Makefile \
+                 test/media/video/Makefile \
                  man/Makefile \
                  doc/Makefile \
                  doc/doxygen/Makefile])

test/.gitignore

+*.o
+
+# test result files
 *.log
 *.trs
+
+.dirstamp

test/Makefile.am

 SUBDIRS=sip
+SUBDIRS+=base64
+SUBDIRS+=media

test/base64/.gitignore

+*.o
+
+# test result files
+*.log
+*.trs
+
+#test binaries
+sip
+
+base64

test/base64/Makefile.am

+include $(top_srcdir)/globals.mk
+
+AM_CXXFLAGS=-I$(top_srcdir)/src/media/video -I$(top_srcdir)/src
+check_PROGRAMS=
+
+#
+# base64 testsuite
+#
+check_PROGRAMS+= base64
+base64_SOURCES= base64.cpp
+base64_LDADD= $(CPPUNIT_LIBS) $(top_builddir)/src/libring.la
+
+#
+# video_input testsuite
+#
+#check_PROGRAMS+= test_video_input
+#test_video_input_SOURCES= media/video/test_video_input.cpp media/video/test_video_input.h
+#test_video_input_LDADD= $(top_builddir)/src/libring.la $(top_builddir)/src/media/video/libvideo.la $(YAML_LIBS)
+
+##################
+# EXCLUDED_TEST SUITES #
+##################
+# test_video_rtp
+#	reason: compilation fails
+#	test_video_rtp.cpp:38:19: error: no matching function for call to ‘ring::video::VideoRtpSession::start()’
+#
+#	test_video_rtp_SOURCES= media/video/test_video_rtp.cpp
+#	test_video_rtp_LDADD= $(top_builddir)/src/libring.la $(top_builddir)/src/media/video/libvideo.la $(YAML_LIBS)
+#
+#
+# test_shm (compilation fails, include file not in repository?)
+#	reason: compilation fails, include file not in repository:
+#	test_video_input.cpp.cpp:21:22: fatal error: shm_sink.h: No such file or directory
+#
+# 	if HAVE_LINUX
+# 	test_shm_SOURCES= media/video/test_shm.cpp media/video/shm_src.cpp media/video/shm_src.h
+# 	test_shm_LDADD= $(top_builddir)/src/libring.la $(top_builddir)/src/media/video/libvideo.la $(YAML_LIBS) -lrt
+# 	test_shm_CXXFLAGS=$(AM_CXXFLAGS)
+# 	endif
+
+TESTS= $(check_PROGRAMS)

test/base64/base64.cpp

+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+#include "test_runner.hpp"
+#include "base64.h"
+
+namespace ring_test {
+    class Base64Test : public CppUnit::TestFixture {
+    public:
+        static std::string name() { return "base64"; }
+
+    private:
+        void encodingTest();
+        void decodingTestSuccess();
+        void decodingTestFail();
+
+        CPPUNIT_TEST_SUITE(Base64Test);
+        CPPUNIT_TEST(encodingTest);
+        CPPUNIT_TEST(decodingTestSuccess);
+        CPPUNIT_TEST(decodingTestFail);
+        CPPUNIT_TEST_SUITE_END();
+
+        const std::vector<uint8_t> test_bytes = { 23, 45, 67, 87, 89, 34, 2, 45, 9, 10 };
+        const std::string test_base64 = "Fy1DV1kiAi0JCg==";
+        const std::string test_invalid_base64 = "ERSAÄÖöädt4-++asd==";
+    };
+
+    CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(Base64Test, Base64Test::name());
+
+    void Base64Test::encodingTest()
+    {
+        const std::string output = ring::base64::encode(test_bytes);
+        CPPUNIT_ASSERT(test_base64.compare(output) == 0);
+    }
+
+    void Base64Test::decodingTestSuccess()
+    {
+        const std::vector<uint8_t> output = ring::base64::decode(test_base64);
+        CPPUNIT_ASSERT(std::equal(test_bytes.begin(), test_bytes.end(), output.begin()));
+    }
+
+    void Base64Test::decodingTestFail()
+    {
+        // Currently, the input is not validated, i.e. the function most not throw an
+        // exception if decoding fails to make sure calling code not expecting any
+        // is no broken. (Some validation should be implemented sometimes later, though.
+        ring::base64::decode(test_invalid_base64);
+        CPPUNIT_ASSERT(true);
+    }
+} // namespace tests
+
+RING_TEST_RUNNER(ring_test::Base64Test::name())

test/base64/test_runner.hpp

+#include <iostream>
+
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/ui/text/TestRunner.h>
+#include <cppunit/CompilerOutputter.h>
+
+#define RING_TEST_RUNNER(suite_name) \
+int main() \
+{ \
+    CppUnit::TestFactoryRegistry &registry = CppUnit::TestFactoryRegistry::getRegistry(suite_name); \
+    CppUnit::Test *suite = registry.makeTest(); \
+    if(suite->countTestCases() == 0) { \
+        std::cout << "No test cases specified for suite \"" << suite_name << "\"\n"; \
+        return 1; \
+    } \
+    CppUnit::TextUi::TestRunner runner; \
+    runner.addTest(suite); \
+    return runner.run() ? 0 : 1; \
+}

test/media/Makefile.am

+include $(top_srcdir)/globals.mk
+
+SUBDIRS= video

test/media/video/.gitignore

+test_video_input

test/media/video/Makefile.am

+include $(top_srcdir)/globals.mk
+
+check_PROGRAMS=
+#
+# video_input testsuite
+#
+check_PROGRAMS+= test_video_input
+test_video_input_SOURCES= test_video_input.cpp test_video_input.h
+test_video_input_LDADD= $(top_builddir)/src/libring.la $(top_builddir)/src/media/video/libvideo.la $(YAML_LIBS)
+
+TESTS= $(check_PROGRAMS)

test/media/video/README

+c++ shm_src.cpp shmclient.cpp -o shmclient `pkg-config --cflags --libs clutter-1.0` -lrt -pthread -O2

test/media/video/test_video_input.cpp

+/*
+ *  Copyright (C) 2011-2017 Savoir-faire Linux Inc.
+ *
+ *  Author: Tristan Matthews <tristan.matthews@savoirfairelinux.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
+ */
+
+#include "test_video_input.h"
+#include "media/video/video_input.h"
+#include "media_const.h"
+#include <map>
+#include <string>
+
+namespace ring { namespace video { namespace test {
+
+void VideoInputTest::testInput()
+{
+    static const std::string sep = DRing::Media::VideoProtocolPrefix::SEPARATOR;
+    std::string resource = DRing::Media::VideoProtocolPrefix::DISPLAY + sep + std::string(getenv("DISPLAY") ? : ":0.0");
+    VideoInput video;
+    video.switchInput(resource);
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+}}} // namespace ring::video::test
+
+int main ()
+{
+    for (int i = 0; i < 20; ++i) {
+        ring::video::test::VideoInputTest test;
+        test.testInput();
+    }
+    return 0;
+}

test/media/video/test_video_input.h

+/*
+ *  Copyright (C) 2011-2017 Savoir-faire Linux Inc.
+ *
+ *  Author: Tristan Matthews <tristan.matthews@savoirfairelinux.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
+ */
+
+#ifndef _VIDEO_INPUT_TEST_
+#define _VIDEO_INPUT_TEST_
+
+namespace ring { namespace video { namespace test {
+
+class VideoInputTest {
+public:
+    void testInput();
+};
+
+}}} // namespace ring::video::test
+
+#endif // _VIDEO_INPUT_TEST_

test/sip/.gitignore

-*.o
-
-# test result files
-*.log
-*.trs
-
 #test binaries
 sip
+
+dring-sample.yml.bak

test/sip/Makefile.am

 # Rules for the test code (use `make check` to execute)
-include ../../globals.mk
+include $(top_srcdir)/globals.mk
 TESTS = sip
 check_PROGRAMS = $(TESTS)
-sip_LDADD = ./../../src/libring.la
+sip_LDADD = $(top_builddir)/src/libring.la
 sip_SOURCES = sip.cpp test_SIP.h test_SIP.cpp ../../manager.h
 sip_CXXFLAGS = $(CPPUNIT_CFLAGS)
 sip_LDFLAGS = $(CPPUNIT_LIBS) -ldl

test/sip/test_SIP.cpp

@@ -2,6 +2,7 @@
  *  Copyright (C) 2004-2017 Savoir-Faire Linux Inc.
  *  Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
  *  Author: Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
+ *  Author: Olivier Gregoire <olivier.gregoire@savoirfairelinux.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -124,283 +125,212 @@ test_SIP::tearDown()
         std::cout << "test_SIP: Error from system call, killall sipp"
                   << ", ret=" << ret
                   << '\n';
+    Manager::instance().callFactory.clear();
 }
 
 void
 test_SIP::testSimpleOutgoingIpCall()
 {
-   // start a user agent server waiting for a call
-   auto t = sippThread("sipp -sn uas -i 127.0.0.1 -p 5068 -m 1 -bg");
+    std::cout << ">>>> test simple outgoing IP call <<<< " << '\n';
 
-   std::string testaccount("IP2IP");
-   std::string testcallnumber("sip:test@127.0.0.1:5068");
-   std::string testcallid; // returned by outgoingCall()
+    CPPUNIT_ASSERT(Manager::instance().callFactory.empty());
 
-   CPPUNIT_ASSERT(!Manager::instance().hasCurrentCall());
+    // start a user agent server waiting for a call
+    auto t = sippThread("sipp -sn uas -i 127.0.0.1 -p 5068 -m 1 -bg");
 
-   // start a new call sending INVITE message to sipp instance
-   testcallid = Manager::instance().outgoingCall(testaccount, testcallnumber);
-
-   // wait for receiving 180 and 200 message from peer
-   std::this_thread::sleep_for(std::chrono::seconds(2)); // should be enough
-
-   auto call = Manager::instance().getCallFromCallID(testcallid);
-   CPPUNIT_ASSERT(call);
-
-   // check call state
-   auto state = call->getStateStr();
-   std::cout << ">>>> call state is now " << state << '\n';
-   CPPUNIT_ASSERT(state == DRing::Call::StateEvent::CURRENT);
-
-   Manager::instance().hangupCall(testcallid);
-
-   // check call state
-   state = call->getStateStr();
-   std::cout << ">>>> call state is now " << state << '\n';
-   CPPUNIT_ASSERT(state == DRing::Call::StateEvent::OVER);
-
-   // Call must not not be available (except for thus how already own a pointer like us)
-   CPPUNIT_ASSERT(not Manager::instance().getCallFromCallID(testcallid));
-}
-
-#if 0
-void test_SIP::testSimpleIncomingIpCall()
-{
-    pthread_t thethread;
-
-    // command to be executed by the thread, user agent client which initiate a call and hangup
-    std::string command("sipp -sn uac 127.0.0.1 -i 127.0.0.1 -p 5062 -m 1i -bg");
-
-    int rc = pthread_create(&thethread, NULL, sippThread, &command);
-
-    if (rc)
-        std::cout << "test_SIP: ERROR; return code from pthread_create()" << std::endl;
-
-    // sleep a while to make sure that sipp insdtance is initialized and sflphoned received
-    // the incoming invite.
-    sleep(2);
-
-    // gtrab call id from sipvoiplink
-    SIPVoIPLink& siplink = SIPVoIPLink::instance();
-
-    CPPUNIT_ASSERT(siplink.sipCallMap_.size() == 1);
-    SipCallMap::iterator iterCallId = siplink.sipCallMap_.begin();
-    std::string testcallid = iterCallId->first;
-
-    // Answer this call
-    CPPUNIT_ASSERT(Manager::instance().answerCall(testcallid));
-
-    sleep(1);
-
-    rc = pthread_join(thethread, NULL);
-
-    if (rc)
-        std::cout << "test_SIP: ERROR; return code from pthread_join(): " << rc << std::endl;
-    else
-        std::cout << "test_SIP: completed join with thread" << std::endl;
-}
-#endif
-
-void
-test_SIP::testTwoOutgoingIpCall()
-{
-    // This scenario expect to be put on hold before hangup
-    auto firstCallThread = sippThread("sipp -sf tools/sippxml/test_1.xml -i 127.0.0.1 -p 5062 -m 1");
-    // The second call uses the default user agent scenario
-    auto secondCallThread = sippThread("sipp -sn uas -i 127.0.0.1 -p 5064 -m 1");
-
-    sleep(1);
-
-    auto testAccount = "IP2IP";
-    auto firstCallNumber = "sip:test@127.0.0.1:5062";
-    auto secondCallNumber = "sip:test@127.0.0.1:5064";
+    std::string testaccount("IP2IP");
+    std::string testcallnumber("sip:test@127.0.0.1:5068");
+    std::string testcallid; // returned by outgoingCall()
 
     CPPUNIT_ASSERT(!Manager::instance().hasCurrentCall());
 
     // start a new call sending INVITE message to sipp instance
-    // this call should be put on hold when making the second call
-    auto firstCallId = Manager::instance().outgoingCall(testAccount, firstCallNumber);
+    testcallid = Manager::instance().outgoingCall(testaccount, testcallnumber);
+
+    // wait for receiving 180 and 200 message from peer
+    std::this_thread::sleep_for(std::chrono::seconds(1)); // should be enough
 
-    // must sleep here until receiving 180 and 200 message from peer
-    sleep(1);
+    auto call = Manager::instance().getCallFromCallID(testcallid);
+    CPPUNIT_ASSERT(call);
 
-    auto secondCallId = Manager::instance().outgoingCall(testAccount, secondCallNumber);
+    // check call state
+    auto state = call->getStateStr();
+    std::cout << ">>>> call state is now " << state << '\n';
+    CPPUNIT_ASSERT(state == DRing::Call::StateEvent::CURRENT);
 
-    sleep(1);
+    // hangup call
+    std::cout << ">>>> hangup the call " << '\n';
+    Manager::instance().hangupCall(testcallid);
+    state = call->getStateStr();
+    std::cout << ">>>> call state is now " << state << '\n';
+    CPPUNIT_ASSERT(state == DRing::Call::StateEvent::OVER);
 
-    Manager::instance().hangupCall(firstCallId);
-    Manager::instance().hangupCall(secondCallId);
+    // Call must not not be available (except for thus how already own a pointer like us)
+    CPPUNIT_ASSERT(not Manager::instance().getCallFromCallID(testcallid));
 }
 
-#if 0
-void test_SIP::testTwoIncomingIpCall()
-{
-    pthread_mutex_init(&count_mutex, NULL);
-    pthread_cond_init(&count_nb_thread, NULL);
 
-    pthread_attr_t attr;
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+void
+test_SIP::testSimpleIncomingIpCall()
+{
+    std::cout << ">>>> test simple incomming IP call <<<< " << '\n';
 
-    // the first call is supposed to be put on hold when answering teh second incoming call
-    std::string firstCallCommand("sipp -sf tools/sippxml/test_2.xml 127.0.0.1 -i 127.0.0.1 -p 5064 -m 1 > testfile1.txt -bg");
+    CPPUNIT_ASSERT(Manager::instance().callFactory.empty());
 
     // command to be executed by the thread, user agent client which initiate a call and hangup
-    std::string secondCallCommand("sipp -sn uac 127.0.0.1 -i 127.0.0.1 -p 5062 -m 1 -d 250 > testfile2.txt -bg");
+    sippThread("sipp -sn uac 127.0.0.1 -i 127.0.0.1 -p 5062 -m 1 -bg");
 
-    pthread_t firstCallThread;
-    int rc = pthread_create(&firstCallThread, &attr, sippThreadWithCount, &firstCallCommand);
-
-    if (rc)
-        std::cout << "test_SIP: ERROR; return code from pthread_create()" << std::endl;
-
-    // sleep a while to make sure that sipp insdtance is initialized and sflphoned received
+    // sleep a while to make sure that sipp insdtance is initialized and dring received
     // the incoming invite.
-    sleep(1);
-
-    // gtrab call id from sipvoiplink
-    SIPVoIPLink& sipLink = SIPVoIPLink::instance();
-
-    CPPUNIT_ASSERT(sipLink.sipCallMap_.size() == 1);
-    SipCallMap::iterator iterCallId = sipLink.sipCallMap_.begin();
-    std::string firstCallID = iterCallId->first;
+    std::this_thread::sleep_for(std::chrono::seconds(1));
 
     // Answer this call
-    CPPUNIT_ASSERT(Manager::instance().answerCall(firstCallID));
+    const auto& calls = Manager::instance().callFactory.getAllCalls();
+    const auto call = *calls.cbegin();
+    CPPUNIT_ASSERT(Manager::instance().answerCall(call->getCallId()));
+
+    // hangup this call
+    Manager::instance().hangupCall(call->getCallId());
+    auto state = call->getStateStr();
+    std::cout << ">>>> call state is now " << state << '\n';
+    CPPUNIT_ASSERT(state == DRing::Call::StateEvent::OVER);
+}
 
-    sleep(1);
-    pthread_t secondCallThread;
-    rc = pthread_create(&secondCallThread, &attr, sippThread, &secondCallCommand);
+void
+test_SIP::testMultipleIncomingIpCall(){
+    std::cout << ">>>> test multiple incoming IP call <<<< " << '\n';
 
-    if (rc)
-        std::cout << "test_SIP: Error; return  code from pthread_create()" << std::endl;
+    CPPUNIT_ASSERT(Manager::instance().callFactory.empty());
 
-    sleep(1);
+    // this value change the number of outgoing call we do
+    int numberOfCall =5;
 
-    CPPUNIT_ASSERT(sipLink.sipCallMap_.size() == 2);
-    iterCallId = sipLink.sipCallMap_.begin();
+    for(int i = 0; i < numberOfCall; i++){
+        // start a user agent server waiting for a call
+        sippThread("sipp -sf sippxml/test_2.xml 127.0.0.1 -i 127.0.0.1 -p 506"+std::to_string(i+1)+" -m 1 -bg");
 
-    if (iterCallId->first == firstCallID)
-        ++iterCallId;
+        // sleep a while to make sure that sipp insdtance is initialized and dring received
+        // the incoming invite.
+        std::this_thread::sleep_for(std::chrono::seconds(3));
 
-    std::string secondCallID(iterCallId->first);
+        const auto& calls = Manager::instance().callFactory.getAllCalls();
+        const auto call = *calls.cbegin();
+        auto state = call->getStateStr();
+        std::cout << ">>>> current call (call number: "+std::to_string(i)+") state:" << state << '\n';
+        CPPUNIT_ASSERT(state == DRing::Call::StateEvent::INCOMING); //TODO this state is sometime HOLD
 
-    CPPUNIT_ASSERT(Manager::instance().answerCall(secondCallID));
+        // Answer this call
+        CPPUNIT_ASSERT(Manager::instance().answerCall(call->getCallId()));
 
-    sleep(2);
+        state = call->getStateStr();
+        std::cout << ">>>> current call (call number: "+std::to_string(i)+") state:" << state << '\n';
+        CPPUNIT_ASSERT(state == DRing::Call::StateEvent::CURRENT);
 
-    pthread_mutex_lock(&count_mutex);
+        Manager::instance().onHoldCall(call->getCallId());
+        state = call->getStateStr();
+        std::cout << ">>>> current call (call number: "+std::to_string(i)+") state:" << state << '\n';
+        CPPUNIT_ASSERT(state == DRing::Call::StateEvent::HOLD);
+    }
+
+}
 
-    while (counter > 0)
-        pthread_cond_wait(&count_nb_thread, &count_mutex);
 
-    pthread_mutex_unlock(&count_mutex);
+void
+test_SIP::testMultipleOutgoingIpCall()
+{
+    std::cout << ">>>> test multiple outgoing IP call <<<< " << '\n';
+
+    CPPUNIT_ASSERT(Manager::instance().callFactory.empty());
+
+    // this value change the number of outgoing call we do
+    int numberOfCall =5;
+
+    //setup of the calls
+    std::string callNumber("sip:test@127.0.0.1:5061");
+    std::string testaccount("IP2IP");
+    std::string callID[numberOfCall];
+
+    for(int i = 0; i < numberOfCall; i++){
+        // start a user agent server waiting for a call
+        sippThread("sipp -sn uas -i 127.0.0.1 -p 5061 -m "+std::to_string(numberOfCall)+" -bg");
+
+        callID[i] = Manager::instance().outgoingCall(testaccount, callNumber);
+        auto newCall = Manager::instance().getCallFromCallID(callID[i]);
+        CPPUNIT_ASSERT(newCall);
+
+        // wait for receiving 180 and 200 message from peer
+        std::this_thread::sleep_for(std::chrono::seconds(1)); // should be enough
+
+        auto state = newCall->getStateStr();
+        std::cout << ">>>> current call (call number: "+std::to_string(i)+") state:" << state << '\n';
+        CPPUNIT_ASSERT(state == DRing::Call::StateEvent::CURRENT);
+
+        // test the changement of calls states after doing a new call
+        if(i){
+            for(int j = 0; j<i; j++){
+                auto oldCall = Manager::instance().getCallFromCallID(callID[j]);
+                CPPUNIT_ASSERT(oldCall);
+                auto oldState = oldCall->getStateStr();
+                std::cout << ">>>> old call (call number: "+std::to_string(j)+") state:" << oldState << '\n';
+                CPPUNIT_ASSERT(oldState == DRing::Call::StateEvent::HOLD);
+                }
+            }
+        }
 
-    pthread_mutex_destroy(&count_mutex);
-    pthread_cond_destroy(&count_nb_thread);
+    //hangup  all calls
+    for(int i = 0; i < numberOfCall; i++){
+        auto call = Manager::instance().getCallFromCallID(callID[i]);
+        Manager::instance().hangupCall(callID[i]);
+        auto state = call->getStateStr();
+        CPPUNIT_ASSERT(state == DRing::Call::StateEvent::OVER);
+    }
 }
-#endif
 
 void
 test_SIP::testHoldIpCall()
 {
+    std::cout << ">>>> test hold IP call <<<< " << '\n';
+
+    CPPUNIT_ASSERT(Manager::instance().callFactory.empty());
+
     auto testAccount = "IP2IP";
     auto testCallNumber = "sip:test@127.0.0.1:5062";
 
-    auto callThread = sippThread("sipp -sf tools/sippxml/test_3.xml -i 127.0.0.1 -p 5062 -m 1 -bg");
+    auto callThread = sippThread("sipp -sf sippxml/test_3.xml -i 127.0.0.1 -p 5062 -m 1 -bg");
 
     auto testCallId = Manager::instance().outgoingCall(testAccount, testCallNumber);
+    auto call = Manager::instance().getCallFromCallID(testCallId);
 
-    sleep(1);
+    std::this_thread::sleep_for(std::chrono::seconds(2));
+
+    auto state = call->getStateStr();
+    std::cout << ">>>> call state is now " << state << '\n';
+    CPPUNIT_ASSERT(state == DRing::Call::StateEvent::CURRENT);
 
     Manager::instance().onHoldCall(testCallId);
 
-    sleep(1);
+    state = call->getStateStr();
+    std::cout << ">>>> call state is now " << state << '\n';
+    CPPUNIT_ASSERT(state == DRing::Call::StateEvent::HOLD);
 
     Manager::instance().offHoldCall(testCallId);
 
-    sleep(1);
+    state = call->getStateStr();
+    std::cout << ">>>> call state is now " << state << '\n';
+    CPPUNIT_ASSERT(state == DRing::Call::StateEvent::CURRENT);
 
     Manager::instance().hangupCall(testCallId);
+    state = call->getStateStr();
+    std::cout << ">>>> call state is now " << state << '\n';
+    CPPUNIT_ASSERT(state == DRing::Call::StateEvent::OVER);
 }