Menu
▾
▴
[Scstudio-commits] SF.net SVN: scstudio:[699] trunk
|
From: <ma...@us...> - 2010-03-14 23:34:26
|
Revision: 699
http://scstudio.svn.sourceforge.net/scstudio/?rev=699&view=rev
Author: madzin
Date: 2010-03-14 23:34:18 +0000 (Sun, 14 Mar 2010)
Log Message:
-----------
Adds time to membership algorithm
Modified Paths:
--------------
trunk/src/membership/membership_alg.cpp
trunk/src/membership/membership_alg.h
trunk/tests/membership/CMakeLists.txt
Modified: trunk/src/membership/membership_alg.cpp
===================================================================
--- trunk/src/membership/membership_alg.cpp 2010-03-12 10:19:27 UTC (rev 698)
+++ trunk/src/membership/membership_alg.cpp 2010-03-14 23:34:18 UTC (rev 699)
@@ -21,8 +21,12 @@
// map of bmsc names and configurations which were checked
std::map<std::wstring, std::set<ConfigurationPtr> > checked;
+std::map<TimeRelationRefNodePtr, ConfigurationPtr> top_time_references;
+std::map<TimeRelationRefNodePtr, ConfigurationPtr> bottom_time_references;
+
//identification for receive events
int max_id;
+BMscPtr global_bmsc;
InstancePtr find_instance(InstancePtrList instances, std::wstring name);
@@ -65,6 +69,18 @@
bool is_strict_area_null(StrictOrderAreaPtr strict);
+bool check_node_time(ReferenceNodePtr node, ConfigurationPtr conf);
+
+int get_max_interval(ReferenceNodePtr node, ConfigurationPtr conf);
+
+int get_min_interval(ConfigurationPtr conf);
+
+Event* get_last_instance_event(Event* start, int id = INT_MAX);
+
+bool compare_events_time_relations(Event* a, Event* b);
+
+Event* find_event_on_instance_by_id(std::wstring label, int id);
+
/*
* Returns precondition list of the membership algorithm
*/
@@ -89,6 +105,8 @@
return NULL;
}
+ global_bmsc = bmsc_f;
+
if (hmsc != NULL)
return search_hmsc(hmsc, bmsc_f);
else
@@ -108,14 +126,33 @@
BMscGraphDuplicator duplicator;
HMscPtr dup_hmsc;
- dup_hmsc = duplicator.duplicate(hmsc);
+/*
+StartNodePtr start = hmsc->get_start();
+NodeRelationPtrVector succ = start->get_successors();
+SuccessorNode* hmsc_node = succ.front()->get_successor();
+ReferenceNode* node = dynamic_cast<ReferenceNode*> (hmsc_node);
+std::wcerr << L"node_time " << node->get_msc()->get_label() << std::endl;
+TimeRelationRefNodePtrSet top = node->get_time_relations_top();
+std::cout << "top size " << top.size() << std::endl;
+*/
+dup_hmsc = hmsc; // dup_hmsc = duplicator.duplicate(hmsc);
+
+/*
+start = dup_hmsc->get_start();
+succ = start->get_successors();
+hmsc_node = succ.front()->get_successor();
+node = dynamic_cast<ReferenceNode*> (hmsc_node);
+std::wcerr << L"node_time " << node->get_msc()->get_label() << std::endl;
+top = node->get_time_relations_top();
+std::cout << "top size " << top.size() << std::endl;
+*/
+
+
//creates configuration of defined bMSC
ConfigurationPtr searched_conf = new Configuration(bmsc_f->get_instances());
StartNodePtr start_node = dup_hmsc->get_start();
- NodeRelationPtrVector successors = start_node->get_successors();
- NodeRelationPtrVector::iterator it;
if (check_branch(start_node, searched_conf))
{
@@ -186,14 +223,20 @@
if (!look_at_checked_conf(node, b))
return false;
- ConfigurationPtr old_config = new Configuration(b);
+ ConfigurationPtr old_config_I, old_config_II;
+ old_config_I = new Configuration(b);
+ old_config_II = new Configuration(b);
+
if (!check_node(node, membership, b))
return false;
- if (!check_node(node, receive_ordering, old_config))
+ if(!check_node_time(node, old_config_II))
return false;
+ if (!check_node(node, receive_ordering, old_config_I))
+ return false;
+
NodeRelationPtrVector successors = node->get_successors();
NodeRelationPtrVector::iterator it;
SuccessorNode* succ;
@@ -551,6 +594,7 @@
return true;
}
+//parameters node_e, b_e
bool compare_events_attribute(Event* a, Event* b)
{
IncompleteMessagePtr incom_a = boost::dynamic_pointer_cast<IncompleteMessage > (a->get_message());
@@ -585,9 +629,159 @@
if (a_set || b_set || a_id != b_id)
return false;
- return true;
+ return compare_events_time_relations(a,b);
}
+//parameters node_e, b_e
+bool compare_events_time_relations(Event* a, Event* b)
+{
+ TimeRelationEventPtrList node_intervals = a->get_time_relations();
+ TimeRelationEventPtrList::iterator it;
+ int time_b_id;
+
+ for(it = node_intervals.begin(); it != node_intervals.end(); it++)
+ {
+ if((*it)->get_event_a() == a)
+ {
+ bool time_b_id_set = true;
+
+ time_b_id = (*it)->get_event_b()->get_attribute("identification", -1, time_b_id_set);
+
+ if(time_b_id_set)
+ {
+ std::cerr << "Error: Unexpected behaviour 3" << std::endl;
+ return false;
+ }
+
+ Event* bmsc_b_event = find_event_on_instance_by_id((*it)->get_event_b()->get_instance()->get_label(), time_b_id);
+
+ if(bmsc_b_event == NULL)
+ return false;
+
+ TimeRelationEventPtrList time_a_intervals = b->get_time_relations();
+ TimeRelationEventPtrList time_b_intervals = bmsc_b_event->get_time_relations();
+
+ if(time_a_intervals.size() == 0 || time_b_intervals.size() == 0)
+ {
+ std::cerr << "Error: Events in bmsc has to have time relation." << std::endl;
+ return false;
+ }
+
+ MscTimeIntervalSetD time_a_set = time_a_intervals.front()->get_interval_set();
+ MscTimeIntervalSetD time_b_set = time_b_intervals.front()->get_interval_set();
+
+ if(time_a_set.is_empty() || time_b_set.is_empty())
+ {
+ std::cerr << "Error: Time interval is corrupted" << std::endl;
+ return false;
+ }
+
+ MscTimeInterval<double> a_interval = time_a_set.get_set().front();
+ MscTimeInterval<double> b_interval = time_b_set.get_set().front();
+
+ double a_time = a_interval.get_begin_value();
+ double b_time = b_interval.get_begin_value();
+
+ if(time_a_intervals.size() > 1)
+ a_time = 0;
+
+ if(time_b_intervals.size() > 1)
+ b_time = 0;
+
+ double bmsc_inter = b_time - a_time;
+
+ MscTimeIntervalSetD hmsc_inter = (*it)->get_interval_set();
+ MscTimeIntervalSetD result, bmsc_inter_set;
+
+ bmsc_inter_set.insert(*(new MscTimeInterval<double>(bmsc_inter)));
+ result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
+
+ if(result.is_empty())
+ return false;
+ }
+ }
+
+ return true;
+}
+
+Event* find_event_on_instance_by_id(std::wstring label, int id)
+{
+ InstancePtrList instances = global_bmsc->get_instances();
+ InstancePtrList::iterator it;
+ InstancePtr instance;
+
+ for(it = instances.begin(); it != instances.end(); it++)
+ {
+ if((*it)->get_label() == label)
+ {
+ instance = *it;
+ break;
+ }
+ }
+
+ EventAreaPtr first = instance->get_first();
+ StrictOrderAreaPtr strict = boost::dynamic_pointer_cast<StrictOrderArea>(first);
+
+ StrictEventPtr str = strict->get_first();
+
+ if(str == NULL)
+ {
+ std::cerr << "Error: Unexpected behaviour 5" << std::endl;
+ return NULL;
+ }
+
+ int event_id;
+ bool event_set = true;
+
+ event_id = str->get_attribute("identification", -1, event_set);
+
+ if(event_set)
+ {
+ std::cerr << "Error: Unexpected behaviour 4" << std::endl;
+ return NULL;
+ }
+
+ StrictEventPtr old;
+
+ while(event_id != id)
+ {
+ old = str;
+ str = str->get_successor();
+
+ if(str == NULL)
+ {
+ EventAreaPtr area = old->get_general_area();
+ area = area->get_next();
+
+ strict = boost::dynamic_pointer_cast<StrictOrderArea>(area);
+
+ if(strict == NULL)
+ {
+ std::cerr << "Error: Node was not found" << std::endl;
+ return NULL;
+ }
+
+ str = strict->get_first();
+
+ if(str == NULL)
+ {
+ std::cerr << "Error: Node was not found" << std::endl;
+ return NULL;
+ }
+ }
+
+ event_id = str->get_attribute("identification", -1, event_set);
+
+ if(event_set)
+ {
+ std::cerr << "Error: Unexpected behaviour 4" << std::endl;
+ return NULL;
+ }
+ }
+
+ return str.get();
+}
+
/*
* Tries finding bMSC in bMSC
*
@@ -615,7 +809,7 @@
node->add_successor(succ);
else
{
- std::cout << "unexpected error" << std::endl;
+ std::cout << "Error: Unexpected behaviour" << std::endl;
return false;
}
@@ -630,7 +824,7 @@
node->add_successor(succ);
else
{
- std::cout << "unexpected error" << std::endl;
+ std::cout << "Error: Unexpected behaviour" << std::endl;
return false;
}
@@ -777,7 +971,7 @@
if (node_events.empty())
node_events.push_back(node_strict->get_first().get());
else
- std::cout << "node_events should be empty" << std::endl;
+ std::cout << "Error: Unexpected error" << std::endl;
}
bool result;
@@ -881,7 +1075,6 @@
bool check_node(ReferenceNodePtr node, enum check_type type, ConfigurationPtr conf)
{
//get msc from the node
-
ConfigurationPtr old_conf = new Configuration(conf);
MscPtr msc = node->get_msc();
@@ -1023,6 +1216,9 @@
bool is_cor_area_null(CoregionAreaPtr cor)
{
+ if(cor == NULL)
+ return true;
+
if(!cor->get_minimal_events().empty())
return false;
@@ -1031,8 +1227,442 @@
bool is_strict_area_null(StrictOrderAreaPtr strict)
{
+ if(strict == NULL)
+ return true;
+
if(strict->get_first() != NULL)
return false;
return true;
}
+
+bool check_node_time(ReferenceNodePtr node, ConfigurationPtr conf)
+{
+//std::wcerr << L"node_time " << node->get_msc()->get_label() << std::endl;
+
+ TimeRelationRefNodePtrSet top = node->get_time_relations_top();
+ TimeRelationRefNodePtrSet bottom = node->get_time_relations_bottom();
+ TimeRelationRefNodePtrSet::iterator it;
+
+ std::vector<TimeRelationRefNodePtr> top_vec, bottom_vec, themself_vec;
+
+//top_time_references, bottom_time_references su tam ulozene uzly kde sa zacina casovy interval, a su usporiadane podla top/bottom. To znamena casovy interval na node_a je pripojeny na top/bottom.
+
+//top_vec, bottom_vec su tam ulozene intervaly kde je aktualny node pripojeny ako koniec intervalu, su usporiadane podla top/bottom.
+
+ for(it = top.begin(); it!=top.end(); it++)
+ {
+ if((*it)->get_ref_node_b() == node.get())
+ {
+ if((*it)->get_ref_node_b() == (*it)->get_ref_node_a())
+ themself_vec.push_back(*it);
+ else
+ top_vec.push_back(*it);
+ }
+ else
+ top_time_references.insert(std::make_pair(*it, conf));
+ }
+
+ for(it = bottom.begin(); it!=bottom.end(); it++)
+ {
+ if((*it)->get_ref_node_b() == node.get())
+ {
+ if((*it)->get_ref_node_b() != (*it)->get_ref_node_a())
+ bottom_vec.push_back(*it);
+ }
+ else
+ bottom_time_references.insert(std::make_pair(*it, conf));
+ }
+
+ int max_a, max_b, min_a, min_b;
+
+ if(!themself_vec.empty())
+ {
+ if(themself_vec.size() > 1)
+ {
+ std::cerr << "Error: more time intervals between top and bottom of one reference node" << std::endl;
+ return false;
+ }
+
+ min_a = get_min_interval(conf);
+ max_b = get_max_interval(node, conf);
+
+ int bmsc_inter = max_b - min_a;
+
+ TimeRelationRefNodePtr relation = themself_vec.front();
+
+ if(relation == NULL)
+ {
+ std::cout<<"Error: Unexpected program's behaviour"<<std::endl;
+ return false;
+ }
+
+ MscTimeIntervalSetD hmsc_inter = relation->get_interval_set();
+ MscTimeIntervalSetD result, bmsc_inter_set;
+
+ bmsc_inter_set.insert(*(new MscTimeInterval<double>(bmsc_inter)));
+ result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
+
+ if(result.is_empty())
+ return false;
+ }
+
+ if(!top_vec.empty())
+ min_b = get_min_interval(conf);
+
+ if(!bottom_vec.empty())
+ max_b = get_max_interval(node, conf);
+
+ std::vector<TimeRelationRefNodePtr>::iterator it_vec;
+ std::map<TimeRelationRefNodePtr, ConfigurationPtr>::iterator it_map;
+
+ if(max_b != INT_MAX)
+ {
+ for(it_vec = bottom_vec.begin(); it_vec != bottom_vec.end(); it_vec++)
+ {
+ it_map = top_time_references.find(*it_vec);
+
+ if(it_map == top_time_references.end())
+ continue;
+
+ int bmsc_inter;
+
+ min_a = get_min_interval(it_map->second);
+ bmsc_inter = max_b - min_a;
+
+ MscTimeIntervalSetD hmsc_inter = (*it_vec)->get_interval_set();
+ MscTimeIntervalSetD result;
+ MscTimeIntervalSetD bmsc_inter_set;
+ bmsc_inter_set.insert(*(new MscTimeInterval<double>(bmsc_inter)));
+
+ result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
+
+ if(result.is_empty())
+ return false;
+ }
+
+ for(it_vec = bottom_vec.begin(); it_vec != bottom_vec.end(); it_vec++)
+ {
+ it_map = bottom_time_references.find(*it_vec);
+
+ if(it_map == bottom_time_references.end())
+ continue;
+
+ int bmsc_inter;
+
+ max_a = get_max_interval(it_map->first->get_ref_node_a(), it_map->second);
+ bmsc_inter = max_b - max_a;
+
+ MscTimeIntervalSetD hmsc_inter = (*it_vec)->get_interval_set();
+ MscTimeIntervalSetD result, bmsc_inter_set;
+
+ bmsc_inter_set.insert(*(new MscTimeInterval<double>(bmsc_inter)));
+
+ result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
+ if(result.is_empty())
+ return false;
+ }
+
+ }
+
+ if(min_b != INT_MAX)
+ {
+ for(it_vec = top_vec.begin(); it_vec != top_vec.end(); it_vec++)
+ {
+ it_map = bottom_time_references.find(*it_vec);
+
+ if(it_map == bottom_time_references.end())
+ continue;
+
+ int bmsc_inter;
+
+ max_a = get_max_interval(it_map->first->get_ref_node_a(), it_map->second);
+ bmsc_inter = min_b - max_a;
+
+ MscTimeIntervalSetD hmsc_inter = (*it_vec)->get_interval_set();
+ MscTimeIntervalSetD result, bmsc_inter_set;
+
+ bmsc_inter_set.insert(*(new MscTimeInterval<double>(bmsc_inter)));
+
+ result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
+ if(result.is_empty())
+ return false;
+ }
+
+ for(it_vec = top_vec.begin(); it_vec != top_vec.end(); it_vec++)
+ {
+ it_map = top_time_references.find(*it_vec);
+
+ if(it_map == top_time_references.end())
+ continue;
+
+ int bmsc_inter;
+
+ min_a = get_min_interval(it_map->second);
+ bmsc_inter = min_b - min_a;
+
+ MscTimeIntervalSetD hmsc_inter = (*it_vec)->get_interval_set();
+ MscTimeIntervalSetD result, bmsc_inter_set;
+
+ bmsc_inter_set.insert(*(new MscTimeInterval<double>(bmsc_inter)));
+
+ result = MscTimeIntervalSetD::set_intersection(hmsc_inter, bmsc_inter_set);
+
+ if(result.is_empty())
+ return false;
+ }
+ }
+
+ return true;
+
+}
+
+bool check_interval(TimeRelationRefNodePtr relation, TopBottom point)
+{
+ return false;
+}
+
+int get_min_interval(ConfigurationPtr conf)
+{
+ std::set<PositionPtr> positions = conf->get_positions();
+ std::set<PositionPtr>::iterator it;
+ TimeRelationEventPtrList time_intervals;
+ MscTimeIntervalSetD minimal;
+ int min = INT_MAX;
+
+ minimal.insert(*(new MscTimeInterval<double> ("(-inf,inf)")));
+
+ for(it = positions.begin(); it != positions.end(); it++)
+ {
+ std::vector<Event*> events = (*it)->get_events();
+
+ if(events.size() == 0)
+ continue;
+
+ time_intervals = events.front()->get_time_relations();
+
+ if(time_intervals.size() > 1)
+ min = 0;
+
+ MscTimeIntervalSetD time_set = time_intervals.front()->get_interval_set();
+
+ if(time_set.is_empty())
+ {
+ std::cerr << "Error: Unexpected behaviour " << std::endl;
+ }
+
+ MscTimeInterval<double> temp = time_set.get_set().front();
+
+ if(min > temp.get_begin_value())
+ min = temp.get_begin_value();
+ }
+
+ return min;
+}
+
+int get_max_interval(ReferenceNodePtr node, ConfigurationPtr conf)
+{
+ std::set<PositionPtr> positions = conf->get_positions();
+ std::set<PositionPtr>::iterator it;
+ TimeRelationEventPtrList time_intervals;
+ MscTimeIntervalSetD maximal;
+ int max = INT_MIN;
+
+ MscPtr msc = node->get_msc();
+
+ BMscPtr bmsc = boost::dynamic_pointer_cast<BMsc>(msc);
+
+ if(bmsc == NULL)
+ std::cerr << "Error: Unexpected behaviur" << std::endl;
+
+ InstancePtrList instances = bmsc->get_instances();
+ InstancePtrList::iterator inst_it;
+
+ //name of instance, event identification
+ std::map<std::wstring, std::vector<int> > node_last_events;
+ EventPtr start;
+ EventArea* area;
+ StrictOrderArea* strict;
+ CoregionArea* cor;
+
+ for(inst_it = instances.begin(); inst_it != instances.end(); inst_it++)
+ {
+ area = (*inst_it)->get_first().get();
+ strict = dynamic_cast<StrictOrderArea*>(area);
+
+ if(strict != NULL)
+ {
+ start = strict->get_first();
+ std::vector<int> identifications;
+ Event* e = get_last_instance_event(start.get());
+
+ if(e == NULL)
+ continue;
+
+ int it_id;
+ bool it_set = true;
+
+ it_id = e->get_attribute("identification", -1, it_set);
+
+ if(!it_set)
+ identifications.push_back(it_id);
+
+ node_last_events.insert(std::make_pair((*inst_it)->get_label(), identifications));
+ }
+
+ cor = dynamic_cast<CoregionArea*>(area);
+
+ if(cor != NULL)
+ {
+std::cout << "Coregion time intervals: This funcion is not currently supported." << std::endl;
+/*
+ vector<Event*> events = cor->get_minimal();
+ vector<Event*>::iterator event_it;
+ vector<int> identifications;
+
+ for(event_it = events.begin(); event_it != events.end(); event_it++)
+ {
+ Event* e = get_last_instance_event(start);
+
+ int it_id;
+ bool it_set = true;
+
+ it_id = e->get_attribute("identification", -1, it_set);
+
+ if(!it_set)
+ identifications.push_back(it_id);
+ }
+*/
+ }
+
+ }
+
+ maximal.insert(*(new MscTimeInterval<double> ("(-inf,inf)")));
+
+ for(it = positions.begin(); it != positions.end(); it++)
+ {
+ std::vector<Event*> events = (*it)->get_events();
+
+ if(events.empty())
+ {
+ continue;
+ }
+
+ Event* e = events.front();
+
+ std::map <std::wstring, std::vector<int> >::iterator node_last_it;
+ node_last_it = node_last_events.find(e->get_instance()->get_label());
+
+ if(node_last_it == node_last_events.end())
+ continue;
+
+ std::vector<int> node_events;
+ node_events = node_last_it->second;
+
+ for(unsigned int i = 0; i < node_events.size(); i++)
+ {
+
+ Event* last = get_last_instance_event(e, node_events[i]);
+
+ if(last == NULL)
+ continue;
+
+ time_intervals = last->get_time_relations();
+
+ MscTimeIntervalSetD time_set = time_intervals.front()->get_interval_set();
+
+ if(time_set.is_empty())
+ {
+ std::cerr << "Error: Unexpected behaviour" << std::endl;
+ }
+
+ MscTimeInterval<double> temp = time_set.get_set().front();
+
+ if(max < temp.get_begin_value())
+ max = temp.get_begin_value();
+ }
+ }
+
+ return max;
+}
+
+Event* get_last_instance_event(Event* start, int id)
+{
+ if(start == NULL)
+ return NULL;
+
+ EventArea* area = start->get_general_area();
+
+ if(area->get_next() == NULL)
+ {
+ StrictOrderArea* str = dynamic_cast<StrictOrderArea*>(area);
+
+ if(!is_strict_area_null(str))
+ {
+ if(id != INT_MAX)
+ {
+ StrictEventPtr e = str->get_first();
+
+ int it_id;
+ bool it_set = true;
+
+ it_id = e->get_attribute("identification", -1, it_set);
+
+ while(!it_set && it_id != id)
+ {
+ e = e->get_successor();
+ it_id = e->get_attribute("identification", -1, it_set);
+ }
+
+ if(it_set)
+ std::cerr << "Error: Unexpected behaviour" << std::endl;
+ else
+ return e.get();
+ }
+ }
+ }
+
+
+ while (area->get_next() != NULL)
+ {
+ StrictOrderArea* str = dynamic_cast<StrictOrderArea*>(area->get_next().get());
+
+ if(!is_strict_area_null(str))
+ {
+ if(id != INT_MAX)
+ {
+ StrictEventPtr e = str->get_first();
+
+ int it_id;
+ bool it_set = true;
+
+ it_id = e->get_attribute("identification", -1, it_set);
+
+ while(!it_set && it_id != id)
+ {
+ e = e->get_successor();
+
+ if(e == NULL)
+ break;
+
+ it_id = e->get_attribute("identification", -1, it_set);
+ }
+
+ if(it_set)
+ std::cerr << "Error: Unexpected behaviour" << std::endl;
+ else
+ return e.get();
+ }
+ else
+ area = area->get_next().get();
+ }
+
+ }
+
+ StrictOrderArea* strict = dynamic_cast<StrictOrderArea*>(area);
+
+ if(strict == NULL)
+ std::cerr << "Error: Pattern bMSC contains coretion" << std::endl;
+
+ return strict->get_last().get();
+}
Modified: trunk/src/membership/membership_alg.h
===================================================================
--- trunk/src/membership/membership_alg.h 2010-03-12 10:19:27 UTC (rev 698)
+++ trunk/src/membership/membership_alg.h 2010-03-14 23:34:18 UTC (rev 699)
@@ -27,6 +27,7 @@
class Configuration;
class Membership;
enum check_type {membership, receive_ordering};
+enum TopBottom {top, bottom};
typedef boost::intrusive_ptr<Position> PositionPtr;
typedef boost::intrusive_ptr<Configuration> ConfigurationPtr;
Modified: trunk/tests/membership/CMakeLists.txt
===================================================================
--- trunk/tests/membership/CMakeLists.txt 2010-03-12 10:19:27 UTC (rev 698)
+++ trunk/tests/membership/CMakeLists.txt 2010-03-14 23:34:18 UTC (rev 699)
@@ -166,3 +166,21 @@
ADD_TEST(membership_test-70 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/hard_pos_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/hard_pos_pat.mpr 1)
+#Lubos' time tests
+ADD_TEST(membership_test-71 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/time_simple1_pos_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/time_simple1_pos_pat.mpr 1)
+
+ADD_TEST(membership_test-72 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/time_simple1_neg_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/time_simple1_neg_pat.mpr 0)
+
+ADD_TEST(membership_test-73 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/time_simple2_pos_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/time_simple2_pos_pat.mpr 1)
+
+ADD_TEST(membership_test-74 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/time_simple2_neg_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/time_simple2_neg_pat.mpr 0)
+
+ADD_TEST(membership_test-75 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/time_cycle_neg_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/time_cycle_neg_pat.mpr 0)
+
+ADD_TEST(membership_test-76 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/time_cycle_pos_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/time_cycle_pos_pat.mpr 1)
+
+ADD_TEST(membership_test-77 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/time_cycleWithEmpty_pos_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/time_cycleWithEmpty_pos_pat.mpr 1)
+
+ADD_TEST(membership_test-78 ${MEMBERSHIP_TEST_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/time_cycleWithEmpty_neg_hmsc.mpr ${CMAKE_CURRENT_SOURCE_DIR}/time_cycleWithEmpty_neg_pat.mpr 0)
+
+
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
