Changeset 113:938e71ac0af4 in finroc_plugins_data_ports

Timestamp:

17.05.2017 20:29:14 (7 years ago)

Author:

Tobias Föhst <foehst@…>

Branch:

default

Parents:

111:9fa05a16eed9 (diff), 112:4756cdcbb205 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Phase:

public

Message:

Merge with 14.08

Files:

• tests/test_collection.cpp (modified) (3 diffs)
• tests/test_collection.cpp (modified) (3 diffs)

tests/test_collection.cpp

@@ -44 +44 @@
 #include "plugins/data_ports/tProxyPort.h"
 #include "plugins/data_ports/tThreadLocalBufferManagement.h"
+#include "plugins/data_ports/tPortPack.h"
 
 //----------------------------------------------------------------------
@@ -368 +369 @@
   RRLIB_UNIT_TESTS_BEGIN_SUITE(DataPortsTestCollection);
   RRLIB_UNIT_TESTS_ADD_TEST(Test);
+  RRLIB_UNIT_TESTS_ADD_TEST(PortPack);
   RRLIB_UNIT_TESTS_END_SUITE;
 
@@ -394 +396 @@
     TestGenericPorts<bool>(true, false);
   }
+
+  void PortPack()
+  {
+    auto parent = new core::tFrameworkElement(&core::tRuntimeEnvironment::GetInstance(), "TestPortPack");
+
+    using tTypeList = rrlib::util::tTypeList<int, double, std::string, bool>;
+    data_ports::tPortPack<tInputPort, tTypeList> ports(parent, "X");
+
+    RRLIB_UNIT_TESTS_EQUALITY(tTypeList::cSIZE, ports.NumberOfPorts());
+
+    for (size_t i = 0; i < tTypeList::cSIZE; ++i)
+    {
+      RRLIB_UNIT_TESTS_EQUALITY("X" + std::to_string(i + 1), ports.GetPort(i).GetName());
+    }
+
+    std::array<std::string, tTypeList::cSIZE> names {"foo", "bar", "baz", "fnord"};
+    data_ports::tPortPack<tInputPort, tTypeList> named_ports(parent, names.begin(), names.end());
+
+    for (size_t i = 0; i < tTypeList::cSIZE; ++i)
+    {
+      RRLIB_UNIT_TESTS_EQUALITY(names[i], named_ports.GetPort(i).GetName());
+    }
+  }
 };
 

tests/test_collection.cpp

@@ -239 +239 @@
 }
 
+template <typename T>
+void TestNetworkConnectionLoss(const T& default_value, const T& publish_value)
+{
+  core::tFrameworkElement* parent = new core::tFrameworkElement(&core::tRuntimeEnvironment::GetInstance(), "TestNetworkConnectionLoss");
+
+  tOutputPort<T> output_port("Output Port", parent);
+  tInputPort<T> input_port_no_explicit_default("Input Port No Explicit Default", parent, core::tFrameworkElement::tFlag::DEFAULT_ON_DISCONNECT);
+  tInputPort<T> input_port_explicit_default("Input Port Explicit Default", parent, core::tFrameworkElement::tFlag::DEFAULT_ON_DISCONNECT, default_value);
+  tInputPort<T> input_port_deferred_default("Input Port Deferred Default", parent, core::tFrameworkElement::tFlag::DEFAULT_ON_DISCONNECT);
+  input_port_deferred_default.SetDefault(default_value);
+  output_port.ConnectTo(input_port_no_explicit_default);
+  output_port.ConnectTo(input_port_explicit_default);
+  output_port.ConnectTo(input_port_deferred_default);
+  parent->Init();
+
+  output_port.Publish(publish_value);
+  RRLIB_UNIT_TESTS_EQUALITY(publish_value, *input_port_no_explicit_default.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(publish_value, *input_port_explicit_default.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(publish_value, *input_port_deferred_default.GetPointer());
+  input_port_no_explicit_default.GetWrapped()->NotifyOfNetworkConnectionLoss();
+  input_port_explicit_default.GetWrapped()->NotifyOfNetworkConnectionLoss();
+  input_port_deferred_default.GetWrapped()->NotifyOfNetworkConnectionLoss();
+  RRLIB_UNIT_TESTS_EQUALITY(T(), *input_port_no_explicit_default.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(default_value, *input_port_explicit_default.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(default_value, *input_port_deferred_default.GetPointer());
+  output_port.Publish(publish_value);
+  RRLIB_UNIT_TESTS_EQUALITY(publish_value, *input_port_no_explicit_default.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(publish_value, *input_port_explicit_default.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(publish_value, *input_port_deferred_default.GetPointer());
+  output_port.DisconnectAll();
+  RRLIB_UNIT_TESTS_EQUALITY(T(), *input_port_no_explicit_default.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(default_value, *input_port_explicit_default.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(default_value, *input_port_deferred_default.GetPointer());
+
+  parent->ManagedDelete();
+}
+
+void TestOutOfBoundsPublish()
+{
+  core::tFrameworkElement* parent = new core::tFrameworkElement(&core::tRuntimeEnvironment::GetInstance(), "TestOutOfBoundsPublish");
+
+  tOutputPort<int> output_port("Output Port", parent, tBounds<int>(0, 2, tOutOfBoundsAction::DISCARD));
+  tInputPort<int> input_port("Input Port", parent, tBounds<int>(0, 1));
+  output_port.ConnectTo(input_port);
+  parent->Init();
+
+  output_port.Publish(3);
+  RRLIB_UNIT_TESTS_EQUALITY(0, input_port.Get());
+  output_port.Publish(2);
+  RRLIB_UNIT_TESTS_EQUALITY(1, input_port.Get());
+
+  parent->ManagedDelete();
+}
+
+template <typename T>
+void TestHijackedPublishing(const T& value_to_publish)
+{
+  core::tFrameworkElement* parent = new core::tFrameworkElement(&core::tRuntimeEnvironment::GetInstance(), "TestHijackedPublishing");
+  T default_value = T();
+
+  tOutputPort<T> output_port("Output Port", parent);
+  tProxyPort<T, true> proxy_port("Proxy Port", parent, core::tFrameworkElementFlag::PUSH_STRATEGY);
+  tInputPort<T> input_port("Input Port", parent);
+  output_port.ConnectTo(proxy_port);
+  proxy_port.ConnectTo(input_port);
+  parent->Init();
+
+  output_port.Publish(value_to_publish);
+  RRLIB_UNIT_TESTS_EQUALITY(value_to_publish, *proxy_port.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(value_to_publish, *input_port.GetPointer());
+  input_port.GetWrapped()->SetHijacked(true);
+  RRLIB_UNIT_TESTS_EQUALITY(value_to_publish, *proxy_port.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(value_to_publish, *input_port.GetPointer());
+  output_port.Publish(default_value);
+  RRLIB_UNIT_TESTS_EQUALITY(default_value, *proxy_port.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(value_to_publish, *input_port.GetPointer());
+  proxy_port.GetWrapped()->SetHijacked(true);
+  input_port.GetWrapped()->SetHijacked(false);
+  output_port.Publish(value_to_publish);
+  RRLIB_UNIT_TESTS_EQUALITY(default_value, *proxy_port.GetPointer());
+  RRLIB_UNIT_TESTS_EQUALITY(value_to_publish, *input_port.GetPointer());
+  output_port.GetWrapped()->SetHijacked(true);
+  output_port.Publish(value_to_publish);
+
+  parent->ManagedDelete();
+}
+
+template <typename T>
+void TestGenericPorts(T value_to_publish, T another_value)
+{
+  core::tFrameworkElement* parent = new core::tFrameworkElement(&core::tRuntimeEnvironment::GetInstance(), "TestGenericPorts");
+  T default_value = T();
+  rrlib::rtti::tGenericObjectWrapper<T> default_buffer(default_value);
+  rrlib::rtti::tGenericObjectWrapper<T> value_buffer(value_to_publish);
+  rrlib::rtti::tGenericObjectWrapper<T> another_value_buffer(another_value);
+
+  tGenericPort output_port("Output Port", rrlib::rtti::tDataType<T>(), parent, core::tFrameworkElement::tFlag::EMITS_DATA | core::tFrameworkElement::tFlag::OUTPUT_PORT);
+  tGenericPort proxy_port("Proxy Port", rrlib::rtti::tDataType<T>(), parent, core::tFrameworkElement::tFlag::ACCEPTS_DATA | core::tFrameworkElement::tFlag::PUSH_STRATEGY | core::tFrameworkElement::tFlag::EMITS_DATA);
+  tGenericPort input_port("Input Port", rrlib::rtti::tDataType<T>(), parent, core::tFrameworkElement::tFlag::ACCEPTS_DATA | core::tFrameworkElement::tFlag::PUSH_STRATEGY);
+  output_port.ConnectTo(proxy_port);
+  proxy_port.ConnectTo(input_port);
+  parent->Init();
+
+  // Publish by value
+  T get_value = T();
+  rrlib::rtti::tGenericObjectWrapper<T> get_buffer(get_value);
+  input_port.Get(get_buffer);
+  RRLIB_UNIT_TESTS_EQUALITY(default_value, get_value);
+  output_port.Publish(value_buffer);
+  proxy_port.Get(get_buffer);
+  RRLIB_UNIT_TESTS_EQUALITY(value_to_publish, get_value);
+  input_port.Get(get_buffer);
+  RRLIB_UNIT_TESTS_EQUALITY(value_to_publish, get_value);
+
+  // Publish via buffer
+  auto unused_buffer = output_port.GetUnusedBuffer();
+  unused_buffer->GetData<T>() = another_value;
+  output_port.Publish(unused_buffer);
+  proxy_port.Get(get_buffer);
+  RRLIB_UNIT_TESTS_EQUALITY(another_value, get_value);
+  input_port.Get(get_buffer);
+  RRLIB_UNIT_TESTS_EQUALITY(another_value, get_value);
+
+  parent->ManagedDelete();
+}
+
 class DataPortsTestCollection : public rrlib::util::tUnitTestSuite
 {
@@ -253 +379 @@
     TestPortListeners<int>(1);
     TestPortListeners<std::string>("test");
+    TestNetworkConnectionLoss<int>(4, 7);
+    TestNetworkConnectionLoss<std::string>("default_value", "published_value");
+    TestOutOfBoundsPublish();
+    TestHijackedPublishing<int>(42);
+    TestHijackedPublishing<std::string>("test");
+    TestGenericPorts<bool>(true, false);
+    TestGenericPorts<std::string>("123", "45");
 
     tThreadLocalBufferManagement local_buffers;
@@ -258 +391 @@
     TestPortQueues<int>(1, 2, 3);
     TestPortListeners<int>(1);
+    TestNetworkConnectionLoss<int>(4, 7);
+    TestOutOfBoundsPublish();
+    TestHijackedPublishing<int>(42);
+    TestGenericPorts<bool>(true, false);
   }