/ - Diff - humotion - Research for Cognitive Interaction

         if(TARGET ${PROJECT_NAME}-test-client)
         target_link_libraries(${PROJECT_NAME}-test-client ${PROJECT_NAME})
         endif()
         catkin_add_gtest(${PROJECT_NAME}-test-timestamp test/timestamp.cpp)
         if(TARGET ${PROJECT_NAME}-test-timestamp)
         target_link_libraries(${PROJECT_NAME}-test-timestamp ${PROJECT_NAME})
         endif()
     ENDIF (catkin_FOUND)

+    }
     Timestamp Timestamp::now(void){
         Timestamp res;
         struct timespec tp;
         clock_gettime(CLOCK_REALTIME, &tp);
         res.set(tp.tv_sec, tp.tv_nsec);
         return res;
         return Timestamp(tp.tv_sec, tp.tv_nsec);
+    }
     void Timestamp::set(int32_t _sec, int32_t _nsec){

     // Bring in my package's API, which is what I'm testing
     #include "client.h"
     #include "humotion/client/client.h"
     #include <gtest/gtest.h>
     #include <string>
     #include <cstdio>
     using namespace std;
     using namespace humotion;
     using namespace humotion::client;
     namespace {
-...
     class client_Test : public ::testing::Test {
     protected:
         client_Test() {
     		//set-up work for EACH test here
             s = new client();
             //set-up work for EACH test here
             s = new Client("test", "ROS");
+        }
+    	}
         virtual ~client_Test() {
     		//clean-up work that doesn't throw exceptions here
     		delete(s);
     		s = NULL;
+    	}
     	//if the constructor and destructor are not enough for setting up
     	//and cleaning up each test, you can define the following methods:
     	virtual void SetUp() {
     		//code here will be called immediately after the constructor (right before each test).
+    	}
             //clean-up work that doesn't throw exceptions here
             delete(s);
             s = NULL;
+        }
     	virtual void TearDown() {
     		//code here will be called immediately after each test (right
     		//before the destructor).
+    	}
         //if the constructor and destructor are not enough for setting up
         //and cleaning up each test, you can define the following methods:
         virtual void SetUp() {
             //code here will be called immediately after the constructor (right before each test).
+        }
         virtual void TearDown() {
             //code here will be called immediately after each test (right
             //before the destructor).
+        }
     	//ojects declared here can be used by all tests in the test case for Foo
         client *s;
         //ojects declared here can be used by all tests in the test case for Foo
         Client *s;
     };
     // Tests that the Foo::Bar() method does Abc.
-...
     // Run all the tests that were declared with TEST()
     int main(int argc, char **argv){
     	testing::InitGoogleTest(&argc, argv);
     	return RUN_ALL_TESTS();
         testing::InitGoogleTest(&argc, argv);
         return RUN_ALL_TESTS();
+    }

     // Bring in my package's API, which is what I'm testing
     #include "server.h"
     #include "humotion/server/server.h"
     #include <gtest/gtest.h>
     #include <string>
     #include <cstdio>
     using namespace std;
     using namespace humotion;
     using namespace humotion::server;
     namespace {
-...
     protected:
     	server_Test() {
     		//set-up work for EACH test here
     		s = new Server();
             s = new Server("test", "ROS", NULL);
+    	}
-...
     	EXPECT_EQ(s->ok(), true);
     	for(int i=0; i<100000; i++){
     		s->tick();
             //s->tick();
+    	}
+    }

     // Bring in my package's API, which is what I'm testing
     #include "timestamp.h"
     #include <gtest/gtest.h>
     #include <string>
     #include <cstdio>
     #include <stdio.h>
     #include <unistd.h>
     using namespace std;
     using namespace humotion;
     namespace {
     //the fixture for testing class Foo.
     class timestamp_Test : public ::testing::Test {
     protected:
         timestamp_Test() {
             //set-up work for EACH test here
+        }
         virtual ~timestamp_Test() {
             //clean-up work that doesn't throw exceptions here
+        }
         //if the constructor and destructor are not enough for setting up
         //and cleaning up each test, you can define the following methods:
         virtual void SetUp() {
             //code here will be called immediately after the constructor (right before each test).
+        }
         virtual void TearDown() {
             //code here will be called immediately after each test (right
             //before the destructor).
+        }
         //ojects declared here can be used by all tests in the test case for Foo
     };
     // Tests that the Foo::Bar() method does Abc.
     TEST_F(timestamp_Test, init_from_values) {
         //check sec/nsec initialiser
         Timestamp a(1.0, 0.0);
         ASSERT_EQ(a.to_seconds(), 1.0);
         Timestamp b(999, 123);
         ASSERT_EQ(b.to_seconds(), 999.0 + 123 / 1000000000.0);
         Timestamp c(666.777);
         ASSERT_EQ(c.to_seconds(), 666.777);
         ASSERT_EQ(c.sec, 666);
         ASSERT_EQ(c.nsec, 0.777 / 1E-9);;
         //test initializer with now()
         struct timespec tp;
         clock_gettime(CLOCK_REALTIME, &tp);
         Timestamp ts_d;
         sleep(1);
         Timestamp ts_e;
         //they should be at least 1 second apart:
         double diff = ts_e.to_seconds() - ts_d.to_seconds();
         ASSERT_GE(diff, 1.0);
         ASSERT_LE(diff, 2.0);
         //d should also be greater equal that timespec values:
         ASSERT_GE(ts_d.sec, tp.tv_sec);
         SUCCEED();
+    }
     TEST_F(timestamp_Test, comparison) {
         //check sec/nsec initialiser
         Timestamp a(1234567, 89101213);
         Timestamp b(1234567, 89101213);
         ASSERT_TRUE(a == b);
         ASSERT_TRUE(a >= b);
         ASSERT_TRUE(a <= b);
         ASSERT_FALSE(a != b);
         ASSERT_FALSE(a < b);
         ASSERT_FALSE(a > b);
         //check double initializer
         Timestamp e(1.234567);
         Timestamp f(1.234568);
         ASSERT_FALSE(e == f);
         ASSERT_FALSE(e >= f);
         ASSERT_TRUE(e <= f);
         ASSERT_TRUE(e != f);
         ASSERT_TRUE(e < f);
         ASSERT_FALSE(e > f);
         //check now() initializer
         Timestamp c;
         sleep(1);
         Timestamp d;
         ASSERT_FALSE(c == d);
         ASSERT_FALSE(c >= d);
         ASSERT_TRUE(c <= d);
         ASSERT_TRUE(c != d);
         ASSERT_TRUE(c < d);
         ASSERT_FALSE(c > d);
         //ok now test comparisons based on sec:
         Timestamp g(100, 1234567);
         Timestamp h(101, 1234567);
         ASSERT_FALSE(g == h);
         ASSERT_FALSE(g >= h);
         ASSERT_TRUE(g <= h);
         ASSERT_TRUE(g != h);
         ASSERT_TRUE(g < h);
         ASSERT_FALSE(g > h);
         //ok now test comparisons based on nsec:
+        {
             Timestamp i(100, 1234567);
             Timestamp j(100, 1234568);
             ASSERT_FALSE(i == j);
             ASSERT_FALSE(i >= j);
             ASSERT_TRUE(i <= j);
             ASSERT_TRUE(i != j);
             ASSERT_TRUE(i < j);
             ASSERT_FALSE(i > j);
+        }
         //ok now test comparisons based on sec + nsec:
+        {
             Timestamp i(100, 1234568);
             Timestamp j(101, 1234567);
             ASSERT_FALSE(i == j);
             ASSERT_FALSE(i >= j);
             ASSERT_TRUE(i <= j);
             ASSERT_TRUE(i != j);
             ASSERT_TRUE(i < j);
             ASSERT_FALSE(i > j);
+        }
         SUCCEED();
+    }
     // Tests that Foo does Xyz.
     // TEST_F(xsc3_client_cpp_Test, DoesXyz) {
     // 	CheckConnection(xsc3_client);
     // }
     }  // namespace
     // Run all the tests that were declared with TEST()
     int main(int argc, char **argv){
         testing::InitGoogleTest(&argc, argv);
         return RUN_ALL_TESTS();
+    }

humotion

Revision e19ad051