[Scstudio-commits] SF.net SVN: scstudio:[990] trunk

[<ma...@us...>]

Revision: 990
          http://scstudio.svn.sourceforge.net/scstudio/?rev=990&view=rev
Author:   madzin
Date:     2010-10-10 22:38:19 +0000 (Sun, 10 Oct 2010)

Log Message:
-----------
add absolut time support for membership algorithm (not tested)

Modified Paths:
--------------
    trunk/src/membership/membership_additional.cpp
    trunk/src/membership/membership_additional.h
    trunk/src/membership/membership_alg.cpp
    trunk/src/membership/membership_base.h
    trunk/src/membership/membership_time.cpp
    trunk/src/membership/membership_time.h
    trunk/tests/membership/CMakeLists.txt

Added Paths:
-----------
    trunk/tests/membership/absolut_time_bmsc01.mpr
    trunk/tests/membership/absolut_time_bmsc02_1.mpr
    trunk/tests/membership/absolut_time_bmsc02_2.mpr
    trunk/tests/membership/absolut_time_hmsc01.mpr
    trunk/tests/membership/absolut_time_hmsc02.mpr

Modified: trunk/src/membership/membership_additional.cpp
===================================================================
--- trunk/src/membership/membership_additional.cpp	2010-10-05 12:29:14 UTC (rev 989)
+++ trunk/src/membership/membership_additional.cpp	2010-10-10 22:38:19 UTC (rev 990)
@@ -17,7 +17,9 @@
 
 #include "membership/membership_additional.h"
 
-bool compare_events(Event* a, Event* b)
+//parameters a - node event
+//           b - bmsc event
+bool compare_events(MembershipContext* c, Event* a, Event* b)
 {
   if (b == NULL || a == NULL)
     return false;
@@ -54,12 +56,14 @@
   return true;
 }
 
-bool compare_events_attribute(MembershipContext* c, Event* a, Event* b)
+//parameters node_e - node event
+//           b_e - bmsc event
+bool compare_events_attribute(MembershipContext* c, Event* node_e, Event* b_e)
 {
-  IncompleteMessagePtr incom_a = boost::dynamic_pointer_cast<IncompleteMessage > (a->get_message());
-  IncompleteMessagePtr incom_b = boost::dynamic_pointer_cast<IncompleteMessage > (b->get_message());
+  IncompleteMessagePtr incom_node = boost::dynamic_pointer_cast<IncompleteMessage > (node_e->get_message());
+  IncompleteMessagePtr incom_b = boost::dynamic_pointer_cast<IncompleteMessage > (b_e->get_message());
 
-  switch ((incom_a != NULL) + (incom_b != NULL))
+  switch ((incom_node != NULL) + (incom_b != NULL))
   {
   case 2:
     return true;
@@ -76,28 +80,41 @@
     return false;
   }
 
-  int a_id, b_id;
-  bool a_set = true;
+  int node_id, b_id;
+  bool node_set = true;
 
-  a_id = a->get_attribute("identification", -1, a_set);
+  node_id = node_e->get_attribute("identification", -1, node_set);
 
-  if(a_set)
-    c->add_attributed_event(a);
+  if(node_set)
+    c->add_attributed_event(node_e);
 
   bool b_set = true;
 
-  b_id = b->get_attribute("identification", -2, b_set);
+  b_id = b_e->get_attribute("identification", -2, b_set);
 
   if(b_set)
-    c->add_attributed_event(b);
+    c->add_attributed_event(b_e);
 
+  //check if the partial membership algorithm is not running or the instance is among the focused instances
   if(c->get_focused_instances().empty()
-     || c->contain_focused_instances(a->get_matching_event()->get_instance()->get_label()))
+     || c->contain_focused_instances(node_e->get_matching_event()->get_instance()->get_label()))
   {
-    if (a_set || b_set || a_id != b_id)
+    if (node_set || b_set || node_id != b_id)
       return false;
 
-    return compare_events_time_relations(c, a,b);
+    bool relative = false;
+    bool absolut = false;
+
+    relative = compare_relative_time_constraints(c, node_e, b_e);
+
+//TODO beginnig for absolut time support in BMSC parts of specification
+//    absolut = compare_absolut_time_constraints(c, node_e, b_e);
+    absolut = true;
+
+    if(relative && absolut)
+      return true;
+    else
+      return false;
   }
   else
     return true;

Modified: trunk/src/membership/membership_additional.h
===================================================================
--- trunk/src/membership/membership_additional.h	2010-10-05 12:29:14 UTC (rev 989)
+++ trunk/src/membership/membership_additional.h	2010-10-10 22:38:19 UTC (rev 990)
@@ -24,7 +24,7 @@
 #include "check/time/tightening.h"
 
 //! compares two events 
-bool compare_events(Event* a, Event* b);
+bool compare_events(MembershipContext* c, Event* a, Event* b);
 
 /**
  * \brief compares events attributes

Modified: trunk/src/membership/membership_alg.cpp
===================================================================
--- trunk/src/membership/membership_alg.cpp	2010-10-05 12:29:14 UTC (rev 989)
+++ trunk/src/membership/membership_alg.cpp	2010-10-10 22:38:19 UTC (rev 990)
@@ -173,17 +173,29 @@
       return false;
     }
 
-    //checks time constraints for this node
-    if(c->get_focused_instances().empty())
+    //if there are not time constraints or there are relative and absolut time constraints, skip the time checking
+    if(c->get_absolut_time() != c->get_relative_time())
     {
-      if(!check_node_time(c, node, old_config_II))
+      //checks time constraints for this node
+      //time constraints are not checked in partial mebership algorithm
+      if(c->get_focused_instances().empty())
       {
-        c->clear_attributed_events();
-        c->top_pop_path();
-        return false;
+        if(!check_node_time(c, node, old_config_II))
+        {
+          c->clear_attributed_events();
+          c->top_pop_path();
+          return false;
+        }
       }
     }
 
+    //if there are absolut and relative time constraints, print error and warning
+    if(c->get_absolut_time() && c->get_relative_time())
+    {
+      c->get_mem()->print_report(RS_ERROR, L"Error: both time constraints (relative, absolut) are not allowed in the same BMSC flow definition");
+      c->get_mem()->print_report(RS_WARNING, L"Warning: time checking was skipped");
+    }
+
     //checks the ordering of events (by attribute which was set at check_node(node, membership,b))
     if (!check_node(c, node, receive_ordering, old_config_I))
     {
@@ -246,10 +258,13 @@
   {
     if (type == membership)
     {
-      if (!compare_events(node_e, b_e))
+      if (!compare_events(c, node_e, b_e))
         return false;
 
+      //set identification to events
       set_identification(c, node_e, b_e);
+      //check relative and absolut time constraints
+      analyze_time_constraints(c, b_e);
     }
     else
     {
@@ -419,7 +434,7 @@
 
   for (node_it = node_events.begin(); node_it != node_events.end(); node_it++)
   {
-    if (compare_events(*node_it, b_e))
+    if (compare_events(c, *node_it, b_e))
     {
       node_e = dynamic_cast<CoregionEvent*> (*node_it);
 
@@ -446,12 +461,14 @@
 
     bool result = false;
 
-    result = compare_events(*accept_it, b_e);
+    result = compare_events(c, *accept_it, b_e);
 
     if(result)
     {
       //set identification to events
       set_identification(c, *accept_it, b_e);
+      //check relative and absolut time constraints
+      analyze_time_constraints(c, b_e);
 
       CoregionEvent* cor_e = dynamic_cast<CoregionEvent*> (*accept_it);
 

Modified: trunk/src/membership/membership_base.h
===================================================================
--- trunk/src/membership/membership_base.h	2010-10-05 12:29:14 UTC (rev 989)
+++ trunk/src/membership/membership_base.h	2010-10-10 22:38:19 UTC (rev 990)
@@ -61,12 +61,16 @@
   std::vector<TimeRelationPtr> not_full_covered_intervals; //! intervals in specification which are not full covered
   std::stack<HMscNodePtr> path; //! store information about the path if the flow meets the specification
   bool print_path; //! store whether the path will be printed
+  bool relative_time;
+  bool absolut_time; 
 
 public:
   MembershipContext() 
   {
     max_id = 0;
     print_path = true;
+    relative_time = false;
+    absolut_time = false;
   }
 
   void set_mem(MembershipAlg* m)
@@ -279,6 +283,26 @@
   {
     return print_path;
   }
+
+  void found_relative_time()
+  {
+    relative_time = true;
+  }
+
+  bool get_relative_time()
+  {
+    return relative_time;
+  }
+
+  void found_absolut_time()
+  {
+    absolut_time = true;
+  }
+
+  bool get_absolut_time()
+  {
+    return absolut_time;
+  }
 };
 
 //! store information about the position of checking algorithm on instance

Modified: trunk/src/membership/membership_time.cpp
===================================================================
--- trunk/src/membership/membership_time.cpp	2010-10-05 12:29:14 UTC (rev 989)
+++ trunk/src/membership/membership_time.cpp	2010-10-10 22:38:19 UTC (rev 990)
@@ -19,6 +19,12 @@
 
 bool check_node_time(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr conf)
 {
+  if(c->get_relative_time())
+    std::cout << "relative time" << std::endl;
+
+//  if(c->get_absolut_time())
+//      return check_absolut_time(c, node, conf);
+
   TimeRelationRefNodePtrSet top = node->get_time_relations_top();
   TimeRelationRefNodePtrSet bottom = node->get_time_relations_bottom();
   TimeRelationRefNodePtrSet::iterator it;
@@ -66,7 +72,7 @@
   if(!bottom_vec.empty())
     max_b = get_max_event(c, node, conf);
 
-  // found bottom time relation and decided the maximal event
+  //! found bottom time relation and decided the maximal event
   if(max_b != NULL)
   {
     if(!check_bottom_time_relations(c, bottom_vec, max_b))
@@ -118,8 +124,18 @@
   MscTimeIntervalSetD result, hmsc_inter, bmsc_inter;
 
   hmsc_inter = relation->get_interval_set();
-  bmsc_inter = c->get_time_matrix()->operator()(min_a, max_b);
 
+  if(c->get_absolut_time())
+  {
+//TODO to nemoze byt list intervalov v evente pri absolutnom case, to nedava zmysel 
+    MscTimeIntervalSetD a = *(min_a->get_absolut_times().begin());
+    MscTimeIntervalSetD b = *(max_b->get_absolut_times().begin());
+std::cout << "see 1    a " << a << " b " << b << std::endl;
+    bmsc_inter = get_continous_interval(c, a, b);
+  }
+  else
+    bmsc_inter = c->get_time_matrix()->operator()(min_a, max_b);
+
   result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter);
 
   if(result.is_empty())
@@ -162,25 +178,14 @@
   }
 
   //set of the minimal events (in case more events, the algorithm is not able to decide the minimum one)
-  std::set<Event*> min;
-  min.insert(pos_min[0]);
+  std::set<Event*> result;
 
-  //try to eliminate pos_min to one event
-  for(unsigned int i = 0; i < pos_min.size(); i++)
-  {
-    switch (compare_absolut_position(c, (*min.begin()), pos_min[i]))
-    {
-      case 0: min.insert(pos_min[i]); break;
-      case 1: break;
-      case 2: update_minimum_set(c, min, pos_min[i]); break;
-      default: throw std::runtime_error("Unexpected behaviour");
-    }
-  }
+  result = eliminate_posible_minimal(c, pos_min);
 
-  if(min.size() != 1)
+  if(result.size() != 1)
     return NULL;
   else
-    return *(min.begin());
+    return *(result.begin());
 }
 
 Event* get_max_event(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr conf)
@@ -227,29 +232,14 @@
   }
 
   //set of the maximal events (in case more events, the algorithm is not able to decide the maximum one)
-  std::set<Event*> max;
+  std::set<Event*> result;
 
-  if(pos_max.size() == 0)
-    return NULL;
+  result = eliminate_posible_maximal(c, pos_max);
 
-  max.insert(pos_max[0]);
-
-  //try to eliminate pos_min to one event
-  for(unsigned int i = 0; i < pos_max.size(); i++)
-  {
-    switch (compare_absolut_position(c, pos_max[i], (*max.begin())))
-    {
-      case 0: max.insert(pos_max[i]); break;
-      case 1: break;
-      case 2: update_maximum_set(c, max, pos_max[i]); break;
-      default: throw std::runtime_error("Unexpected behaviour");
-    }
-  }
-
-  if(max.size() != 1)
+  if(result.size() != 1)
     return NULL;
   else
-    return *(max.begin());
+    return *(result.begin());
 }
 
 void update_maximum_set(MembershipContext* c, std::set<Event*>& max, Event* new_element)
@@ -300,10 +290,75 @@
   min.insert(new_element);
 }
 
+std::set<Event*> eliminate_posible_minimal(MembershipContext* c, std::vector<Event*> pos_min)
+{
+  std::set<Event*> min;
+
+  if(pos_min.size() == 0)
+    return min;
+
+  min.insert(pos_min[0]);
+
+  //try to eliminate pos_min to one event
+  for(unsigned int i = 0; i < pos_min.size(); i++)
+  {
+    switch (compare_absolut_position(c, (*min.begin()), pos_min[i]))
+    {
+      case 0: min.insert(pos_min[i]); break;
+      case 1: break;
+      case 2: update_minimum_set(c, min, pos_min[i]); break;
+      default: throw std::runtime_error("Unexpected behaviour");
+    }
+  }
+
+  return min;
+}
+
+std::set<Event*> eliminate_posible_maximal(MembershipContext* c, std::vector<Event*> pos_max)
+{
+  std::set<Event*> max;
+
+  if(pos_max.size() == 0)
+    return max;
+
+  max.insert(pos_max[0]);
+
+  //try to eliminate pos_min to one event
+  for(unsigned int i = 0; i < pos_max.size(); i++)
+  {
+    switch (compare_absolut_position(c, pos_max[i], (*max.begin())))
+    {
+      case 0: max.insert(pos_max[i]); break;
+      case 1: break;
+      case 2: update_maximum_set(c, max, pos_max[i]); break;
+      default: throw std::runtime_error("Unexpected behaviour");
+    }
+  } 
+
+  return max;
+}
+
 int compare_absolut_position(MembershipContext* c, Event* first, Event* second)
 {
-  MscTimeIntervalSetD inter = c->get_time_matrix()->operator()(first, second);
+//TODO There can be checking for first == second 
 
+  MscTimeIntervalSetD inter;
+
+  //in case the absolut time constraints, it is necessary to compute interval
+//TODO event has not to have list of the absolut times just one time constraints
+  if(c->get_absolut_time())
+{
+    MscTimeIntervalSetD a = *(first->get_absolut_times().begin());
+    MscTimeIntervalSetD b = *(second->get_absolut_times().begin());
+
+    inter = get_continous_interval(c, a, b);    
+//    inter = get_continous_interval(c, *(first->get_absolut_times().begin()), *(second->get_absolut_times().begin()));
+std::cout << "time interval inter " << inter << std::endl;
+}
+  else 
+    inter = c->get_time_matrix()->operator()(first, second);
+
+  //compute which event is before
   const IntervalList intervals = inter.get_set();
   bool positive = false;
   bool negative = false;
@@ -345,7 +400,7 @@
   return 3;
 }
 
-bool compare_events_time_relations(MembershipContext* c, Event* node_a, Event* bmsc_a)
+bool compare_relative_time_constraints(MembershipContext* c, Event* node_a, Event* bmsc_a)
 {
   TimeRelationEventPtrList node_intervals = node_a->get_time_relations();
   TimeRelationEventPtrList::iterator it;
@@ -357,6 +412,7 @@
     {
       bool time_node_b_id_set = true;
 
+//TODO i don't like it, probably better would be is_attribute_set or something similar
       time_node_b_id = (*it)->get_event_b()->get_attribute("identification", -1, time_node_b_id_set);
 
       if(time_node_b_id_set)
@@ -370,7 +426,16 @@
       MscTimeIntervalSetD result, hmsc_inter, bmsc_inter;
 
       hmsc_inter = (*it)->get_interval_set();
-      bmsc_inter = c->get_time_matrix()->operator()(bmsc_a, bmsc_b);
+
+      if(c->get_absolut_time())
+      {
+        MscTimeIntervalSetD a = *(bmsc_a->get_absolut_times().begin());
+        MscTimeIntervalSetD b = *(bmsc_b->get_absolut_times().begin());
+        bmsc_inter = get_continous_interval(c, a, b);
+      }
+      else
+        bmsc_inter = c->get_time_matrix()->operator()(bmsc_a, bmsc_b);
+
       result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter);
 
       if(result.is_empty())
@@ -484,7 +549,18 @@
       MscTimeIntervalSetD bmsc_inter, result;
 
       min_a = get_min_event(c, map_top_conf);
-      bmsc_inter = c->get_time_matrix()->operator()(min_a, max_b);
+
+      if(c->get_absolut_time())
+      {
+        MscTimeIntervalSetD a = *(min_a->get_absolut_times().begin());
+        MscTimeIntervalSetD b = *(max_b->get_absolut_times().begin());
+//TODO to nemoze byt list intervalov v evente pri absolutnom case, to nedava zmysel 
+std::cout << "see 2" << std::endl;
+        bmsc_inter = get_continous_interval(c, a, b);
+      }
+      else
+        bmsc_inter = c->get_time_matrix()->operator()(min_a, max_b);
+  
       result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter);
 
       if(result.is_empty())
@@ -501,7 +577,18 @@
       MscTimeIntervalSetD bmsc_inter, result;
 
       max_a = get_max_event(c, (*it_vec)->get_ref_node_a(), map_bottom_conf);
-      bmsc_inter = c->get_time_matrix()->operator()(max_a, max_b);
+
+      if(c->get_absolut_time())
+      {
+        MscTimeIntervalSetD a = *(min_a->get_absolut_times().begin());
+        MscTimeIntervalSetD b = *(max_b->get_absolut_times().begin());
+//TODO to nemoze byt list intervalov v evente pri absolutnom case, to nedava zmysel 
+std::cout << "see 3" << std::endl;
+        bmsc_inter = get_continous_interval(c, a, b);
+      }
+      else
+        bmsc_inter = c->get_time_matrix()->operator()(max_a, max_b);
+
       result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter);
 
       if(result.is_empty())
@@ -535,7 +622,18 @@
       MscTimeIntervalSetD result, bmsc_inter;
 
       max_a = get_max_event(c, (*it_vec)->get_ref_node_a(), map_bottom_conf);
-      bmsc_inter = c->get_time_matrix()->operator()(max_a, min_b);
+
+      if(c->get_absolut_time())
+      {
+        MscTimeIntervalSetD a = *(min_a->get_absolut_times().begin());
+        MscTimeIntervalSetD b = *(min_b->get_absolut_times().begin());
+//TODO to nemoze byt list intervalov v evente pri absolutnom case, to nedava zmysel 
+std::cout << "see 4" << std::endl;
+        bmsc_inter = get_continous_interval(c, a, b);
+      }
+      else
+        bmsc_inter = c->get_time_matrix()->operator()(max_a, min_b);
+
       result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter);
 
       if(result.is_empty())
@@ -565,3 +663,44 @@
 
   return true;
 }
+
+void analyze_time_constraints(MembershipContext* c, Event* b_e)
+{
+  if(b_e->get_absolut_times().size() > 0)
+    c->found_absolut_time();
+
+  if(b_e->get_time_relations().size() > 0)
+    c->found_relative_time();
+}
+
+MscTimeIntervalSetD get_continous_interval(MembershipContext* c, MscTimeIntervalSetD& a, MscTimeIntervalSetD& b)
+{
+  std::list< MscTimeInterval<double> > a_set = a.get_set();
+  std::list< MscTimeInterval<double> > b_set = b.get_set();
+
+  std::list< MscTimeInterval<double> >::iterator a_it, b_it;
+
+  MscTimeIntervalSet<double> new_set;
+  MscTimeInterval<double> new_interval;
+  MscIntervalCouple<double> start;
+  MscIntervalCouple<double> end;
+
+  for(a_it = a_set.begin(); a_it != a_set.end(); a_it++)
+  {
+    for(b_it = b_set.begin(); b_it != b_set.end(); b_it++)
+    {
+      //compute beginning of the interval
+      start = MscIntervalCouple<double> (b_it->get_begin().get_closed() && a_it->get_end().get_closed(),
+                                         b_it->get_begin().get_value() - a_it->get_end().get_value());
+      
+      //compute ending of the interval 
+      end = MscIntervalCouple<double> (b_it->get_end().get_closed() && a_it->get_begin().get_closed(),
+                                       b_it->get_end().get_value() - a_it->get_begin().get_value());
+ 
+      new_interval = MscTimeInterval<double>(start, end);
+      new_set = MscTimeIntervalSetD::set_union(new_set, new_interval);
+    }
+  }
+  
+  return new_set;
+}

Modified: trunk/src/membership/membership_time.h
===================================================================
--- trunk/src/membership/membership_time.h	2010-10-05 12:29:14 UTC (rev 989)
+++ trunk/src/membership/membership_time.h	2010-10-10 22:38:19 UTC (rev 990)
@@ -30,7 +30,6 @@
 //! finds the minimum event of HMSC node and returns time interval value of matching event in bMSC
 Event* get_min_event(MembershipContext* c, ConfigurationPtr conf);
 
-
 //! finds the maximum event of HMSC node and returns time interval value of matching event in bMSC  
 Event* get_max_event(MembershipContext* c, ReferenceNodePtr node, ConfigurationPtr conf);
 
@@ -40,6 +39,12 @@
 //! compares each event from the set with new_elemetn and updates the set of minimal events (second parameter)
 void update_minimum_set(MembershipContext* c, std::set<Event*>& min, Event* new_element);
 
+//! eliminates set of possible minimal events
+std::set<Event*> eliminate_posible_minimal(MembershipContext* c, std::vector<Event*> pos_min);
+
+//! eliminates set of possible maximal events 
+std::set<Event*> eliminate_posible_maximal(MembershipContext* c, std::vector<Event*> pos_max);
+
 /**                                 
  *  \brief compares absolut position of two events
  *
@@ -61,7 +66,7 @@
  *               a - HMSC node
  *               b - bMSC node
  */
-bool compare_events_time_relations(MembershipContext* c, Event* a, Event* b);
+bool compare_relative_time_constraints(MembershipContext* c, Event* a, Event* b);
 
 //! returns matrix of time intervals among each nodes
 BMscIntervalSetMatrix get_bmsc_matrix(BMscPtr bmsc_f);
@@ -80,4 +85,8 @@
 //! checks top time relations
 bool check_top_time_relations(MembershipContext* c, std::vector<TimeRelationRefNodePtr> top_vec, Event* min_b);
 
+//! checks relative and absolut time constraints
+void analyze_time_constraints(MembershipContext* c, Event* b_e);
+
+MscTimeIntervalSetD get_continous_interval(MembershipContext* c, MscTimeIntervalSetD& a, MscTimeIntervalSetD& b);
 #endif

Modified: trunk/tests/membership/CMakeLists.txt
===================================================================
--- trunk/tests/membership/CMakeLists.txt	2010-10-05 12:29:14 UTC (rev 989)
+++ trunk/tests/membership/CMakeLists.txt	2010-10-10 22:38:19 UTC (rev 990)
@@ -267,5 +267,10 @@
 #ADD_TEST(membership_test-118 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_bmsc32.mpr ${CMAKE_CURRENT_SOURCE_DIR}/test_bmsc32_2.mpr 0)
 
 
-ADD_TEST(membership_test-118 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_hmsc35.mpr ${CMAKE_CURRENT_SOURCE_DIR}/test_bmsc35.mpr 1)
+ADD_TEST(membership_test-119 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test_hmsc35.mpr ${CMAKE_CURRENT_SOURCE_DIR}/test_bmsc35.mpr 1)
 
+ADD_TEST(membership_test-120 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/absolut_time_hmsc01.mpr ${CMAKE_CURRENT_SOURCE_DIR}/absolut_time_bmsc01.mpr 1)
+
+ADD_TEST(membership_test-121 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/absolut_time_hmsc02.mpr ${CMAKE_CURRENT_SOURCE_DIR}/absolut_time_bmsc02_1.mpr 1)
+
+ADD_TEST(membership_test-122 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/absolut_time_hmsc02.mpr ${CMAKE_CURRENT_SOURCE_DIR}/absolut_time_bmsc02_1.mpr 0)

Added: trunk/tests/membership/absolut_time_bmsc01.mpr
===================================================================
--- trunk/tests/membership/absolut_time_bmsc01.mpr	                        (rev 0)
+++ trunk/tests/membership/absolut_time_bmsc01.mpr	2010-10-10 22:38:19 UTC (rev 990)
@@ -0,0 +1,12 @@
+msc bbb;
+inst A;
+inst B;
+A: instance;
+in no,0 from B;
+time [@4, @5];
+endinstance;
+B: instance;
+out no,0 to A;
+time [@2, @3];
+endinstance;
+endmsc;

Added: trunk/tests/membership/absolut_time_bmsc02_1.mpr
===================================================================
--- trunk/tests/membership/absolut_time_bmsc02_1.mpr	                        (rev 0)
+++ trunk/tests/membership/absolut_time_bmsc02_1.mpr	2010-10-10 22:38:19 UTC (rev 990)
@@ -0,0 +1,12 @@
+msc bbb;
+inst A;
+inst B;
+A: instance;
+in no,0 from B;
+time [@4, @5];
+endinstance;
+B: instance;
+out no,0 to A;
+time @[3];
+endinstance;
+endmsc;

Added: trunk/tests/membership/absolut_time_bmsc02_2.mpr
===================================================================
--- trunk/tests/membership/absolut_time_bmsc02_2.mpr	                        (rev 0)
+++ trunk/tests/membership/absolut_time_bmsc02_2.mpr	2010-10-10 22:38:19 UTC (rev 990)
@@ -0,0 +1,12 @@
+msc bbb;
+inst A;
+inst B;
+A: instance;
+in no,0 from B;
+time [@4, @5];
+endinstance;
+B: instance;
+out no,0 to A;
+time [@2, @3];
+endinstance;
+endmsc;

Added: trunk/tests/membership/absolut_time_hmsc01.mpr
===================================================================
--- trunk/tests/membership/absolut_time_hmsc01.mpr	                        (rev 0)
+++ trunk/tests/membership/absolut_time_hmsc01.mpr	2010-10-10 22:38:19 UTC (rev 990)
@@ -0,0 +1,18 @@
+mscdocument Ola;
+msc iha;
+initial connect L1;
+L1: reference aaa time [1,4]; connect L2;
+L2: final;
+endmsc;
+
+msc aaa;
+inst A;
+inst B;
+A: instance;
+in no,0 from B;
+endinstance;
+B: instance;
+out no,0 to A;
+endinstance;
+endmsc;
+

Added: trunk/tests/membership/absolut_time_hmsc02.mpr
===================================================================
--- trunk/tests/membership/absolut_time_hmsc02.mpr	                        (rev 0)
+++ trunk/tests/membership/absolut_time_hmsc02.mpr	2010-10-10 22:38:19 UTC (rev 990)
@@ -0,0 +1,19 @@
+mscdocument Ola;
+msc iha;
+initial connect L1;
+L1: reference aaa time [1,4]; connect L2;
+L2: final;
+endmsc;
+
+msc aaa;
+inst A;
+inst B;
+A: instance;
+in no,0 from B;
+endinstance;
+B: instance;
+out no,0 to A;
+time e1 [1,2];
+endinstance;
+endmsc;
+


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.