6 files changed, 240 insertions, 0 deletions
diff --git a/source/serial/tests/CMakeLists.txt b/source/serial/tests/CMakeLists.txt
new file mode 100644
index 0000000..e52a4d3
--- /dev/null
+++ b/source/serial/tests/CMakeLists.txt
@@ -0,0 +1,12 @@
+if(UNIX)
+    catkin_add_gtest(${PROJECT_NAME}-test unix_serial_tests.cc)
+    target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME} ${Boost_LIBRARIES})
+    if(NOT APPLE)
+        target_link_libraries(${PROJECT_NAME}-test util)
+    endif()
+
+    if(NOT APPLE)  # these tests are unreliable on macOS
+      catkin_add_gtest(${PROJECT_NAME}-test-timer unit/unix_timer_tests.cc)
+      target_link_libraries(${PROJECT_NAME}-test-timer ${PROJECT_NAME})
+    endif()
+endif()
diff --git a/source/serial/tests/proof_of_concepts/mdc2250.cc b/source/serial/tests/proof_of_concepts/mdc2250.cc
new file mode 100644
index 0000000..ff7ec1b
--- /dev/null
+++ b/source/serial/tests/proof_of_concepts/mdc2250.cc
@@ -0,0 +1 @@
+#include ""
+\ No newline at end of file
diff --git a/source/serial/tests/proof_of_concepts/python_serial_test.py b/source/serial/tests/proof_of_concepts/python_serial_test.py
new file mode 100644
index 0000000..6f92b84
--- /dev/null
+++ b/source/serial/tests/proof_of_concepts/python_serial_test.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+
+import serial, sys
+
+if len(sys.argv) != 2:
+    print "python: Usage_serial_test <port name like: /dev/ttyUSB0>"
+    sys.exit(1)
+
+sio = serial.Serial(sys.argv[1], 115200)
+sio.timeout = 250
+
+while True:
+    sio.write("Testing.")
+    print sio.read(8)
+
diff --git a/source/serial/tests/proof_of_concepts/tokenizer.cc b/source/serial/tests/proof_of_concepts/tokenizer.cc
new file mode 100644
index 0000000..da15a09
--- /dev/null
+++ b/source/serial/tests/proof_of_concepts/tokenizer.cc
@@ -0,0 +1,31 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/foreach.hpp>
+
+void
+_delimeter_tokenizer (std::string &data, std::vector<std::string> &tokens,
+                      std::string delimeter)
+{
+  boost::split(tokens, data, boost::is_any_of(delimeter));
+}
+
+typedef boost::function<void(std::string&,std::vector<std::string>&)> TokenizerType;
+
+int main(void) {
+  std::string data = "a\rb\rc\r";
+  std::vector<std::string> tokens;
+  std::string delimeter = "\r";
+  
+  TokenizerType f = boost::bind(_delimeter_tokenizer, _1, _2, delimeter);
+  f(data, tokens);
+  
+  BOOST_FOREACH(std::string token, tokens)
+    std::cout << token << std::endl;
+  
+  return 0;
+}
+\ No newline at end of file
diff --git a/source/serial/tests/unit/unix_timer_tests.cc b/source/serial/tests/unit/unix_timer_tests.cc
new file mode 100644
index 0000000..5bbd1ed
--- /dev/null
+++ b/source/serial/tests/unit/unix_timer_tests.cc
@@ -0,0 +1,63 @@
+#include "gtest/gtest.h"
+#include "serial/impl/unix.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+
+using serial::MillisecondTimer;
+
+namespace {
+
+/**
+ * Do 100 trials of timing gaps between 0 and 19 milliseconds.
+ * Expect accuracy within one millisecond.
+ */
+TEST(timer_tests, short_intervals) {
+  for (int trial = 0; trial < 100; trial++)
+  {
+    uint32_t ms = rand() % 20;
+    MillisecondTimer mt(ms);
+    usleep(1000 * ms);
+    int32_t r = mt.remaining(); 
+
+    // 1ms slush, for the cost of calling usleep.
+    EXPECT_NEAR(r+1, 0, 1);
+  }
+}
+
+TEST(timer_tests, overlapping_long_intervals) {
+  MillisecondTimer* timers[10];
+
+  // Experimentally determined. Corresponds to the extra time taken by the loops,
+  // the big usleep, and the test infrastructure itself.
+  const int slush_factor = 14;
+
+  // Set up the timers to each time one second, 1ms apart.
+  for (int t = 0; t < 10; t++)
+  {
+    timers[t] = new MillisecondTimer(1000);
+    usleep(1000);
+  }
+
+  // Check in on them after 500ms.
+  usleep(500000);
+  for (int t = 0; t < 10; t++)
+  {
+    EXPECT_NEAR(timers[t]->remaining(), 500 - slush_factor + t, 5);
+  }
+
+  // Check in on them again after another 500ms and free them.
+  usleep(500000);
+  for (int t = 0; t < 10; t++)
+  {
+    EXPECT_NEAR(timers[t]->remaining(), -slush_factor + t, 5);
+    delete timers[t];
+  }
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/source/serial/tests/unix_serial_tests.cc b/source/serial/tests/unix_serial_tests.cc
new file mode 100644
index 0000000..26ffde2
--- /dev/null
+++ b/source/serial/tests/unix_serial_tests.cc
@@ -0,0 +1,118 @@
+/* To run these tests you need to change the define below to the serial port 
+ * with a loop back device attached.
+ * 
+ * Alternatively you could use an Arduino:
+ 
+void setup()
+{
+ Serial.begin(115200);
+}
+
+void loop()
+{
+ while (Serial.available() > 0) {
+   Serial.write(Serial.read());
+ }
+}
+ 
+*/
+
+#include <string>
+#include "gtest/gtest.h"
+
+#include <boost/bind.hpp>
+
+// Use FRIEND_TEST... its not as nasty, thats what friends are for
+// // OMG this is so nasty...
+// #define private public
+// #define protected public
+
+#include "serial/serial.h"
+
+#if defined(__linux__)
+#include <pty.h>
+#else
+#include <util.h>
+#endif
+
+using namespace serial;
+
+using std::string;
+
+namespace {
+
+class SerialTests : public ::testing::Test {
+protected:
+  virtual void SetUp() {
+    if (openpty(&master_fd, &slave_fd, name, NULL, NULL) == -1) {
+      perror("openpty");
+      exit(127);
+    }
+
+    ASSERT_TRUE(master_fd > 0);
+    ASSERT_TRUE(slave_fd > 0);
+    ASSERT_TRUE(string(name).length() > 0);
+
+    port1 = new Serial(string(name), 115200, Timeout::simpleTimeout(250));
+  }
+
+  virtual void TearDown() {
+    port1->close();
+    delete port1;
+  }
+
+  Serial * port1;
+  int master_fd;
+  int slave_fd;
+  char name[100];
+};
+
+TEST_F(SerialTests, readWorks) {
+  write(master_fd, "abc\n", 4);
+  string r = port1->read(4);
+  EXPECT_EQ(r, string("abc\n"));
+}
+
+TEST_F(SerialTests, writeWorks) {
+  char buf[5] = "";
+  port1->write("abc\n");
+  read(master_fd, buf, 4);
+  EXPECT_EQ(string(buf, 4), string("abc\n"));
+}
+
+TEST_F(SerialTests, timeoutWorks) {
+  // Timeout a read, returns an empty string
+  string empty = port1->read();
+  EXPECT_EQ(empty, string(""));
+  
+  // Ensure that writing/reading still works after a timeout.
+  write(master_fd, "abc\n", 4);
+  string r = port1->read(4);
+  EXPECT_EQ(r, string("abc\n"));
+}
+
+TEST_F(SerialTests, partialRead) {
+  // Write some data, but request more than was written.
+  write(master_fd, "abc\n", 4);
+
+  // Should timeout, but return what was in the buffer.
+  string empty = port1->read(10);
+  EXPECT_EQ(empty, string("abc\n"));
+  
+  // Ensure that writing/reading still works after a timeout.
+  write(master_fd, "abc\n", 4);
+  string r = port1->read(4);
+  EXPECT_EQ(r, string("abc\n"));
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  try {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+  } catch (std::exception &e) {
+    std::cerr << "Unhandled Exception: " << e.what() << std::endl;
+  }
+  return 1;
+}