ExternalVendorCode/trick
1
0
Fork 0
mirror of https://github.com/nasa/trick.git synced 2024-12-24 23:36:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
7bc6ab74a8
trick/test/SIM_stls/models/STLCheckpoint.cpp
Jacqueline Deans 2519c914a5
Pair checkpointing fix (#1356) 
* Fix pair checkpointing bug, add tests
* Documentation update
2022-10-07 17:00:09 -05:00

764 lines
30 KiB
C++
Raw Blame History

#include "sim_services/Message/include/message_proto.h"
#include "STLCheckpoint.hh"
#include "trick/memorymanager_c_intf.h"
#include <iostream>
#include <vector>
#include "sim_services/UnitTest/include/trick_tests.h"
/* These 2 constructors add different data to an STLCheckpoint. */
STLCheckpoint::STLCheckpoint() {
return ;
}
template <typename T>
void compare_data_structures_with_top(T a, T b, std::string test_name) {
const char *test_suite = "STLCheckpoint";
TRICK_EXPECT_EQ(a.size(), b.size(), test_suite, test_name.c_str());
while (!a.empty()) {
TRICK_EXPECT_EQ(a.top(), b.top(), test_suite, test_name.c_str());
a.pop();
b.pop();
}
}
int STLCheckpoint::addData() {
dataJobRun = true;
vector_vector_double = std::vector< std::vector< double > >(4, std::vector<double>(3));
vector_vector_vector_double = std::vector< std::vector< std::vector< double > > >(5, std::vector<std::vector<double> >(4, std::vector<double>(3)));
std::cout << "Adding hardcoded data to sim" << std::endl;
double_map[44.4] = 444.4 ;
double_map[55.5] = 555.5 ;
double_map[66.6] = 666.6 ;
string_key_map[std::string("four")] = 4 ;
string_key_map[std::string("five")] = 5 ;
string_key_map[std::string("six")] = 6 ;
string_data_map[7] = std::string("seiben") ;
string_data_map[8] = std::string("acht") ;
string_data_map[9] = std::string("neun") ;
std::vector< int > v ;
v.push_back(2) ;
v.push_back(4) ;
v.push_back(6) ;
v.push_back(8) ;
map_int_vector_int[1] = v ;
std::pair< int , int > p ;
p.first = 24 ;
p.second = 30 ;
gcd[p] = 6 ;
p.first = 50 ;
p.second = 60 ;
std::pair< int , int > q ;
q.first = 70 ;
q.second = 80 ;
map_pair_pair[p] = q ;
p.first = 3 ;
p.second = 5 ;
v.clear() ;
v.push_back(15) ;
v.push_back(30) ;
v.push_back(45) ;
v.push_back(60) ;
common_multiples.insert(std::pair< std::pair< int, int >, std::vector< int > >(p,v)) ;
p.first = 3 ;
p.second = 7 ;
v.clear() ;
v.push_back(21) ;
v.push_back(42) ;
v.push_back(84) ;
v.push_back(168) ;
common_multiples.insert(std::pair< std::pair< int, int >, std::vector< int > >(p,v)) ;
string_map[std::string("sister")] = std::string("Lisa") ;
string_map[std::string("dog")] = std::string("Santa's Little Helper") ;
int_multimap.insert(std::pair<int, int>(44,444)) ;
int_multimap.insert(std::pair<int, int>(55,555)) ;
int_multimap.insert(std::pair<int, int>(66,666)) ;
int_multimap.insert(std::pair<int, int>(44,4444)) ;
int_multimap.insert(std::pair<int, int>(55,5555)) ;
int_multimap.insert(std::pair<int, int>(66,6666)) ;
string_key_multimap.insert(std::pair<std::string, int>("four", 4)) ;
string_key_multimap.insert(std::pair<std::string, int>("five", 5)) ;
string_key_multimap.insert(std::pair<std::string, int>("six", 6)) ;
string_key_multimap.insert(std::pair<std::string, int>("four", 44)) ;
string_key_multimap.insert(std::pair<std::string, int>("five", 55)) ;
string_key_multimap.insert(std::pair<std::string, int>("six", 66)) ;
string_data_multimap.insert(std::pair<int, std::string>(7, "seiben")) ;
string_data_multimap.insert(std::pair<int, std::string>(8, "acht")) ;
string_data_multimap.insert(std::pair<int, std::string>(9, "neun")) ;
string_data_multimap.insert(std::pair<int, std::string>(7, "seven")) ;
string_data_multimap.insert(std::pair<int, std::string>(8, "eight")) ;
string_data_multimap.insert(std::pair<int, std::string>(9, "nine")) ;
string_multimap.insert(std::pair<std::string, std::string>("sister","Lisa")) ;
string_multimap.insert(std::pair<std::string, std::string>("dog","Santa's Little Helper")) ;
string_multimap.insert(std::pair<std::string, std::string>("sister","Meg")) ;
string_multimap.insert(std::pair<std::string, std::string>("dog","Brian")) ;
double_vector.push_back(4.0) ;
double_vector.push_back(5.0) ;
double_vector.push_back(6.0) ;
string_vector.push_back("It") ;
string_vector.push_back("has") ;
string_vector.push_back("the") ;
string_vector.push_back("Wi-Fies") ;
short_list.push_back(400) ;
short_list.push_back(401) ;
short_list.push_back(402) ;
string_list.push_back("I") ;
string_list.push_back("don't") ;
string_list.push_back("care") ;
float_deque.push_back(98.7) ;
float_deque.push_back(65.4) ;
float_deque.push_back(32.1) ;
string_deque.push_back("Welcome") ;
string_deque.push_back("to") ;
string_deque.push_back("PhoneMart") ;
int_set.insert(8000) ;
int_set.insert(4000) ;
int_set.insert(2000) ;
int_set.insert(1000) ;
string_set.insert("efg") ;
string_set.insert("abc") ;
string_set.insert("def") ;
for (int j = 0; j < 5; j++) {
std::vector<int> temp;
for (int i = j; i < 10; i++) {
temp.push_back(i);
}
vector_set.insert(temp);
}
pair_set.emplace("One", 1);
pair_set.emplace("Two", 2);
pair_set.emplace("Three", 3);
std::map<short,double> m;
m[5] = 500.5;
m[1] = 100.1;
std::map<short,double> m2;
m2[5] = 5000.5;
m2[1] = 1000.1;
nested_map_set.insert(m);
nested_map_set.insert(m2);
for (int j = 0; j < 5; j++) {
std::vector<int> temp;
for (int i = j; i < 10; i++) {
temp.push_back(i);
}
vector_queue.push(temp);
}
long_multiset.insert(8000) ;
long_multiset.insert(4000) ;
long_multiset.insert(4000) ;
long_multiset.insert(2000) ;
long_multiset.insert(1000) ;
string_multiset.insert("efg") ;
string_multiset.insert("abc") ;
string_multiset.insert("def") ;
string_multiset.insert("efg") ;
string_multiset.insert("abc") ;
string_multiset.insert("def") ;
pair_multiset.emplace(5, 5);
pair_multiset.emplace(5, 5);
pair_multiset.emplace(5, 4);
pair_multiset.emplace(4, 4);
vec_multiset.emplace(std::vector<int>({1,2,3,4}));
vec_multiset.emplace(std::vector<int>({1,2,3,4}));
vec_multiset.emplace(std::vector<int>({1,2,3,4,5}));
uint_stack.push(1) ;
uint_stack.push(2) ;
uint_stack.push(3) ;
uint_stack.push(4) ;
string_stack.push("I") ;
string_stack.push("want the one") ;
string_stack.push("with the bigger") ;
string_stack.push("Gee Bees") ;
std::vector<int> temp_v1 = {1, 2, 3, 4};
std::vector<int> temp_v2 = {5, 6, 7, 8};
stack_vector_int.push(temp_v1) ;
stack_vector_int.push(temp_v2) ;
int_queue.push(1) ;
int_queue.push(2) ;
int_queue.push(3) ;
int_queue.push(4) ;
string_queue.push("I") ;
string_queue.push("want") ;
string_queue.push("an") ;
string_queue.push("iPhone 4") ;
int_priority_queue.push(3) ;
int_priority_queue.push(2) ;
int_priority_queue.push(4) ;
int_priority_queue.push(1) ;
string_priority_queue.push("I") ;
string_priority_queue.push("want") ;
string_priority_queue.push("an") ;
string_priority_queue.push("iPhone 4") ;
queue_vector_int.push(temp_v1) ;
queue_vector_int.push(temp_v2) ;
priority_queue_vector_int.push(temp_v1) ;
priority_queue_vector_int.push(temp_v2) ;
int_pair.first = 10 ;
int_pair.second = 20 ;
string_first_pair.first = "string first" ;
string_first_pair.second = 25 ;
string_second_pair.first = 25 ;
string_second_pair.second = "string second" ;
string_pair.first = "pair first string" ;
string_pair.second = "pair second string" ;
int_pair_int_int.first = 200 ;
p.first = 10 ;
p.second = 20 ;
int_pair_int_int.second = p ;
p.first = 15 ;
p.second = 12 ;
pair_int_int_int.first = p ;
pair_int_int_int.second = 180 ;
pair_pair_pair.first.first = 51 ;
pair_pair_pair.first.second = 52 ;
pair_pair_pair.second.first = 53 ;
pair_pair_pair.second.second = 54 ;
int_vec_pair.first = 5;
int_vec_pair.second.push_back(5);
int_vec_pair.second.push_back(10);
int_vec_pair.second.push_back(15);
int_vec_pair.second.push_back(20);
vec_int_pair.second = 5;
vec_int_pair.first.push_back(5);
vec_int_pair.first.push_back(10);
vec_int_pair.first.push_back(15);
vec_int_pair.first.push_back(20);
vec_vec_pair.first.push_back(5);
vec_vec_pair.first.push_back(10);
vec_vec_pair.first.push_back(15);
vec_vec_pair.first.push_back(20);
vec_vec_pair.second.push_back(5);
vec_vec_pair.second.push_back(10);
vec_vec_pair.second.push_back(15);
vec_vec_pair.second.push_back(20);
vector_vector_double[0][0] = 100 ;
vector_vector_double[0][1] = 101 ;
vector_vector_double[0][2] = 102 ;
vector_vector_double[1][0] = 103 ;
vector_vector_double[1][1] = 104 ;
vector_vector_double[1][2] = 105 ;
vector_vector_double[2][0] = 106 ;
vector_vector_double[2][1] = 107 ;
vector_vector_double[2][2] = 108 ;
vector_vector_double[3][0] = 109 ;
vector_vector_double[3][1] = 110 ;
vector_vector_double[3][2] = 111 ;
vector_vector_vector_double[0][0][0] = 0 ;
vector_vector_vector_double[0][0][1] = 1 ;
vector_vector_vector_double[0][0][2] = 2 ;
vector_vector_vector_double[0][1][0] = 3 ;
vector_vector_vector_double[0][1][1] = 4 ;
vector_vector_vector_double[0][1][2] = 5 ;
vector_vector_vector_double[0][2][0] = 6 ;
vector_vector_vector_double[0][2][1] = 7 ;
vector_vector_vector_double[0][2][2] = 8 ;
vector_vector_vector_double[0][3][0] = 9 ;
vector_vector_vector_double[0][3][1] = 10 ;
vector_vector_vector_double[0][3][2] = 11 ;
vector_vector_vector_double[1][0][0] = 1000 ;
vector_vector_vector_double[1][0][1] = 1001 ;
vector_vector_vector_double[1][0][2] = 1002 ;
vector_vector_vector_double[1][1][0] = 1003 ;
vector_vector_vector_double[1][1][1] = 1004 ;
vector_vector_vector_double[1][1][2] = 1005 ;
vector_vector_vector_double[1][2][0] = 1006 ;
vector_vector_vector_double[1][2][1] = 1007 ;
vector_vector_vector_double[1][2][2] = 1008 ;
vector_vector_vector_double[1][3][0] = 1009 ;
vector_vector_vector_double[1][3][1] = 1010 ;
vector_vector_vector_double[1][3][2] = 1011 ;
vector_vector_vector_double[2][0][0] = 2000 ;
vector_vector_vector_double[2][0][1] = 2001 ;
vector_vector_vector_double[2][0][2] = 2002 ;
vector_vector_vector_double[2][1][0] = 2003 ;
vector_vector_vector_double[2][1][1] = 2004 ;
vector_vector_vector_double[2][1][2] = 2005 ;
vector_vector_vector_double[2][2][0] = 2006 ;
vector_vector_vector_double[2][2][1] = 2007 ;
vector_vector_vector_double[2][2][2] = 2008 ;
vector_vector_vector_double[2][3][0] = 2009 ;
vector_vector_vector_double[2][3][1] = 2010 ;
vector_vector_vector_double[2][3][2] = 2011 ;
vector_vector_vector_double[3][0][0] = 3000 ;
vector_vector_vector_double[3][0][1] = 3001 ;
vector_vector_vector_double[3][0][2] = 3002 ;
vector_vector_vector_double[3][1][0] = 3003 ;
vector_vector_vector_double[3][1][1] = 3004 ;
vector_vector_vector_double[3][1][2] = 3005 ;
vector_vector_vector_double[3][2][0] = 3006 ;
vector_vector_vector_double[3][2][1] = 3007 ;
vector_vector_vector_double[3][2][2] = 3008 ;
vector_vector_vector_double[3][3][0] = 3009 ;
vector_vector_vector_double[3][3][1] = 3010 ;
vector_vector_vector_double[3][3][2] = 3011 ;
vector_vector_vector_double[4][0][0] = 4000 ;
vector_vector_vector_double[4][0][1] = 4001 ;
vector_vector_vector_double[4][0][2] = 4002 ;
vector_vector_vector_double[4][1][0] = 4003 ;
vector_vector_vector_double[4][1][1] = 4004 ;
vector_vector_vector_double[4][1][2] = 4005 ;
vector_vector_vector_double[4][2][0] = 4006 ;
vector_vector_vector_double[4][2][1] = 4007 ;
vector_vector_vector_double[4][2][2] = 4008 ;
vector_vector_vector_double[4][3][0] = 4009 ;
vector_vector_vector_double[4][3][1] = 4010 ;
vector_vector_vector_double[4][3][2] = 4011 ;
for (int i = 0; i < 10; i++) {
UserClass temp;
for (int j = 0; j < 5; j++) {
temp.a[j] = i+j;
}
temp.b = 8888888888;
temp.c = "Here is a test string";
// We'll just make a pointer to the same stuff
UserClass * user_class_ptr = (UserClass *) TMM_declare_var_s("UserClass");
for (int j = 0; j < 5; j++) {
user_class_ptr->a[j] = i+j;
}
user_class_ptr->b = 8888888888;
user_class_ptr->c = "Here is a test string";
temp.d = user_class_ptr;
vec_user_simple.emplace_back(temp);
}
for (int i = 0; i < 10; i++) {
SimpleWrapper temp_wrapper;
temp_wrapper.a = 888;
for (int j = i; j < i+10; j++) {
temp_wrapper.vec.push_back(j);
}
vec_user_defined.emplace_back(temp_wrapper);
}
for (int i = 0; i < 10; i++) {
SimpleWrapper * temp_wrapper = (SimpleWrapper *) TMM_declare_var_s("SimpleWrapper");
temp_wrapper->a = 888;
for (int j = i; j < i+10; j++) {
temp_wrapper->vec.push_back(j);
}
vec_user_defined_ptr.push_back(temp_wrapper);
}
return 0;
}
int STLCheckpoint::print() {
message_publish(1,"Quack!\n") ;
message_publish(1, "Double vector size: %d", double_vector.size() );
message_publish(1,"double_vector: %f %f %f\n", double_vector[0], double_vector[1], double_vector[2]) ;
message_publish(1,"vector_vector_double[1]: %f %f %f\n",
vector_vector_double[1][0], vector_vector_double[1][1], vector_vector_double[1][2]) ;
message_publish(1,"vector_vector_vector_double[4][2]: %f %f %f\n",
vector_vector_vector_double[4][2][0], vector_vector_vector_double[4][2][1], vector_vector_vector_double[4][2][2]) ;
message_publish(1,"string_vector[0]: %s\n", string_vector[0].c_str()) ;
message_publish(1,"map_int_vector_int[1][1] = %d\n", map_int_vector_int[1][1]) ;
message_publish(1,"gcd = %d\n", gcd[std::pair<int, int >(24,30)]) ;
message_publish(1,"common_multiples = %d\n", common_multiples[std::pair<int, int >(3,5)][1]) ;
message_publish(1,"common_multiples = %d\n", common_multiples[std::pair<int, int >(3,5)][1]) ;
message_publish(1,"int_pair_int_int.second.second = %d\n", int_pair_int_int.second.second) ;
message_publish(1,"pair_int_int_int.first.second = %d\n", pair_int_int_int.first.second) ;
message_publish(1,"pair_pair_pair.second.first = %d\n", pair_pair_pair.second.first) ;
message_publish(1,"int_queue.front = %d\n", int_queue.front()) ;
message_publish(1,"int_priority_queue.top = %d\n", int_priority_queue.top()) ;
message_publish(1,"uint_stack.top = %d\n", uint_stack.top()) ;
message_publish(1,"queue_vector_int.front()[3] = %d\n", queue_vector_int.front()[3]) ;
message_publish(1,"priority_queue_vector_int.top()[2] = %d\n", priority_queue_vector_int.top()[2]) ;
message_publish(1,"stack_vector_int.top()[1] = %d\n", stack_vector_int.top()[1]) ;
return 0 ;
}
int STLCheckpoint::test() {
std::cout << "Running test jobs" << std::endl;
const char *test_suite = "STLCheckpoint";
TRICK_EXPECT_EQ( double_vector.size(), 3, test_suite, "double_vector size");
TRICK_EXPECT_EQ( double_vector[0], 4, test_suite, "double_vector[0]");
TRICK_EXPECT_EQ( double_vector[1], 5, test_suite, "double_vector[1]");
TRICK_EXPECT_EQ( double_vector[2], 6, test_suite, "double_vector[2]");
TRICK_EXPECT_EQ( vector_vector_double[1][0], 103, test_suite, "vector_vector_double[1][0]");
TRICK_EXPECT_EQ( vector_vector_double[1][1], 104, test_suite, "vector_vector_double[1][1]");
TRICK_EXPECT_EQ( vector_vector_double[1][2], 105, test_suite, "vector_vector_double[1][2]");
TRICK_EXPECT_EQ( vector_vector_vector_double[4][2][0], 4006, test_suite, "vector_vector_vector_double[4][2][0]");
TRICK_EXPECT_EQ( vector_vector_vector_double[4][2][1], 4007, test_suite, "vector_vector_vector_double[4][2][1]");
TRICK_EXPECT_EQ( vector_vector_vector_double[4][2][2], 4008, test_suite, "vector_vector_vector_double[4][2][2]");
TRICK_EXPECT_EQ( string_vector[0], std::string("It"), test_suite, "string_vector");
TRICK_EXPECT_EQ( double_map[44.4], 444.4, test_suite, "double_map[44.4]" );
TRICK_EXPECT_EQ( string_data_map[7], std::string("seiben"), test_suite, "string_data_map[7]" );
TRICK_EXPECT_EQ( string_data_map[9], std::string("neun") , test_suite, "string_data_map[9]");
std::vector< int > v ;
v.push_back(2) ;
v.push_back(4) ;
v.push_back(6) ;
v.push_back(8) ;
TRICK_EXPECT_EQ( map_int_vector_int[1], v, test_suite, "map_int_vector_int[1]");
std::pair< int , int > p ;
p.first = 24 ;
p.second = 30 ;
TRICK_EXPECT_EQ(gcd[p], 6, test_suite, "gcd[p]" );
p.first = 50 ;
p.second = 60 ;
std::pair< int , int > q ;
q.first = 70 ;
q.second = 80 ;
TRICK_EXPECT_EQ( map_pair_pair[p], q, test_suite, "map_pair_pair[p]" );
p.first = 3 ;
p.second = 5 ;
v.clear() ;
v.push_back(15) ;
v.push_back(30) ;
v.push_back(45) ;
v.push_back(60) ;
TRICK_EXPECT_EQ( common_multiples[p], v, test_suite, "common_multiples" );
p.first = 3 ;
p.second = 7 ;
v.clear() ;
v.push_back(21) ;
v.push_back(42) ;
v.push_back(84) ;
v.push_back(168) ;
TRICK_EXPECT_EQ( common_multiples[p], v, test_suite, "common_multiples" );
TRICK_EXPECT_EQ( string_map["sister"], "Lisa", test_suite, "string_map[sister]" );
TRICK_EXPECT_EQ( string_map["dog"], "Santa's Little Helper", test_suite, "string_map[dog]" );
// The easiest way to test the multimaps is to just rebuild copies and compare
std::multimap<int, int> int_multimap_copy;
int_multimap_copy.insert(std::pair<int, int>(44,444)) ;
int_multimap_copy.insert(std::pair<int, int>(55,555)) ;
int_multimap_copy.insert(std::pair<int, int>(66,666)) ;
int_multimap_copy.insert(std::pair<int, int>(44,4444)) ;
int_multimap_copy.insert(std::pair<int, int>(55,5555)) ;
int_multimap_copy.insert(std::pair<int, int>(66,6666)) ;
TRICK_EXPECT_EQ(int_multimap, int_multimap_copy , test_suite, "int_multimap");
int_multimap_copy.insert(std::pair<int, int>(66,66666)) ;
TRICK_EXPECT_NE(int_multimap, int_multimap_copy , test_suite, "int_multimap_fail");
std::multimap<std::string, int> string_key_multimap_copy;
string_key_multimap_copy.insert(std::pair<std::string, int>("four", 4)) ;
string_key_multimap_copy.insert(std::pair<std::string, int>("five", 5)) ;
string_key_multimap_copy.insert(std::pair<std::string, int>("six", 6)) ;
string_key_multimap_copy.insert(std::pair<std::string, int>("four", 44)) ;
string_key_multimap_copy.insert(std::pair<std::string, int>("five", 55)) ;
string_key_multimap_copy.insert(std::pair<std::string, int>("six", 66)) ;
TRICK_EXPECT_EQ(string_key_multimap, string_key_multimap_copy , test_suite, "string_key_multimap");
std::multimap<int, std::string> string_data_multimap_copy;
string_data_multimap_copy.insert(std::pair<int, std::string>(7, "seiben")) ;
string_data_multimap_copy.insert(std::pair<int, std::string>(8, "acht")) ;
string_data_multimap_copy.insert(std::pair<int, std::string>(9, "neun")) ;
string_data_multimap_copy.insert(std::pair<int, std::string>(7, "seven")) ;
string_data_multimap_copy.insert(std::pair<int, std::string>(8, "eight")) ;
string_data_multimap_copy.insert(std::pair<int, std::string>(9, "nine")) ;
TRICK_EXPECT_EQ(string_data_multimap, string_data_multimap_copy , test_suite, "string_data_multimap");
std::multimap<std::string, std::string> string_multimap_copy;
string_multimap_copy.insert(std::pair<std::string, std::string>("sister","Lisa")) ;
string_multimap_copy.insert(std::pair<std::string, std::string>("dog","Santa's Little Helper")) ;
string_multimap_copy.insert(std::pair<std::string, std::string>("sister","Meg")) ;
string_multimap_copy.insert(std::pair<std::string, std::string>("dog","Brian")) ;
TRICK_EXPECT_EQ(string_multimap, string_multimap_copy , test_suite, "string_multimap");
// TODO: fix this case
// TRICK_EXPECT_EQ(vec_user_defined.size(), 10, test_suite, "vec_user_defined");
// for (int i = 0; i < vec_user_defined.size(); i++) {
// TRICK_EXPECT_EQ(vec_user_defined[i].vec.size(), 10, test_suite, "vec_user_defined");
// TRICK_EXPECT_EQ(vec_user_defined[i].a, 888, test_suite, "vec_user_defined");
// for (int j = i; j < i+vec_user_defined[i].vec.size(); j++) {
// TRICK_EXPECT_EQ(vec_user_defined[i].vec[j-i], j, test_suite, "vec_user_defined");
// }
// }
TRICK_EXPECT_EQ(vec_user_defined_ptr.size(), 10, test_suite, "vec_user_defined_ptr");
for (int i = 0; i < vec_user_defined_ptr.size(); i++) {
TRICK_EXPECT_EQ(vec_user_defined_ptr[i]->vec.size(), 10, test_suite, "vec_user_defined_ptr");
TRICK_EXPECT_EQ(vec_user_defined_ptr[i]->a, 888, test_suite, "vec_user_defined_ptr");
std::vector<int> test_vec;
for (int j = i; j < i+vec_user_defined_ptr[i]->vec.size(); j++) {
test_vec.push_back(j);
}
TRICK_EXPECT_EQ(vec_user_defined_ptr[i]->vec, test_vec, test_suite, "vec_user_defined_ptr");
}
std::vector<std::string> string_vector_copy = {"It", "has", "the", "Wi-Fies"};
TRICK_EXPECT_EQ(string_vector, string_vector_copy, test_suite, "string_vector");
std::list<short> short_list_copy = {400, 401, 402};
int list_index = 0;
TRICK_EXPECT_EQ(short_list, short_list_copy, test_suite, "short_list");
std::list<std::string> string_list_copy = {"I", "don't", "care"};
TRICK_EXPECT_EQ(string_list, string_list_copy, test_suite, "string_list");
std::deque<float> float_deque_copy = {98.7, 65.4, 32.1};
TRICK_EXPECT_EQ(float_deque, float_deque_copy, test_suite, "float_deque");
std::deque<std::string> string_deque_copy = {"Welcome", "to", "PhoneMart"};
TRICK_EXPECT_EQ(string_deque, string_deque_copy, test_suite, "string_deque");
std::set<int> int_set_copy = {8000, 4000, 2000, 1000};
TRICK_EXPECT_EQ(int_set, int_set_copy, test_suite, "int_set");
std::set<std::string> string_set_copy = {"efg", "abc", "def"};
TRICK_EXPECT_EQ(string_set, string_set_copy, test_suite, "string_set");
std::set<std::vector<int>> vector_set_copy;
for (int j = 0; j < 5; j++) {
std::vector<int> temp;
for (int i = j; i < 10; i++) {
temp.push_back(i);
}
vector_set_copy.insert(temp);
}
TRICK_EXPECT_EQ(vector_set, vector_set_copy, test_suite, "vector_set");
std::set<std::pair<std::string, int>> pair_set_copy;
pair_set_copy.emplace("One", 1);
pair_set_copy.emplace("Two", 2);
pair_set_copy.emplace("Three", 3);
TRICK_EXPECT_EQ(pair_set, pair_set_copy, test_suite, "pair_set");
std::set<std::map<short,double>> nested_map_set_copy;
std::map<short,double> m;
m[5] = 500.5;
m[1] = 100.1;
std::map<short,double> m2;
m2[5] = 5000.5;
m2[1] = 1000.1;
nested_map_set_copy.insert(m);
nested_map_set_copy.insert(m2);
TRICK_EXPECT_EQ(nested_map_set, nested_map_set_copy, test_suite, "nested_map_set");
std::queue<std::vector<int>> vector_queue_copy;
for (int j = 0; j < 5; j++) {
std::vector<int> temp;
for (int i = j; i < 10; i++) {
temp.push_back(i);
}
vector_queue_copy.push(temp);
}
TRICK_EXPECT_EQ(vector_queue, vector_queue_copy, test_suite, "vector_queue");
std::multiset<long> long_multiset_copy = {8000, 4000, 4000, 2000, 1000};
TRICK_EXPECT_EQ(long_multiset, long_multiset_copy, test_suite, "long_multiset");
std::multiset<std::string> string_multiset_copy = {"efg", "abc", "def", "efg", "abc", "def"};
TRICK_EXPECT_EQ(string_multiset, string_multiset_copy, test_suite, "string_multiset");
std::multiset<std::pair<int,int>> pair_multiset_copy;
pair_multiset_copy.emplace(5, 5);
pair_multiset_copy.emplace(5, 5);
pair_multiset_copy.emplace(5, 4);
pair_multiset_copy.emplace(4, 4);
TRICK_EXPECT_EQ(pair_multiset, pair_multiset_copy, test_suite, "pair_multiset");
std::multiset<std::vector<int>> vec_multiset_copy;
vec_multiset_copy.emplace(std::vector<int>({1,2,3,4}));
vec_multiset_copy.emplace(std::vector<int>({1,2,3,4}));
vec_multiset_copy.emplace(std::vector<int>({1,2,3,4,5}));
TRICK_EXPECT_EQ(vec_multiset, vec_multiset_copy, test_suite, "vec_multiset");
std::stack<unsigned int> uint_stack_copy;
uint_stack_copy.push(1) ;
uint_stack_copy.push(2) ;
uint_stack_copy.push(3) ;
uint_stack_copy.push(4) ;
TRICK_EXPECT_EQ(uint_stack, uint_stack_copy, test_suite, "uint_stack");
std::stack<std::string> string_stack_copy;
string_stack_copy.push("I") ;
string_stack_copy.push("want the one") ;
string_stack_copy.push("with the bigger") ;
string_stack_copy.push("Gee Bees") ;
TRICK_EXPECT_EQ(string_stack, string_stack_copy, test_suite, "string_stack");
std::stack<std::vector<int>> stack_vector_int_copy;
std::vector<int> temp_v1 = {1, 2, 3, 4};
std::vector<int> temp_v2 = {5, 6, 7, 8};
stack_vector_int_copy.emplace(temp_v1) ;
stack_vector_int_copy.emplace(temp_v2) ;
TRICK_EXPECT_EQ(stack_vector_int, stack_vector_int_copy, test_suite, "stack_vector_int");
std::queue<int> int_queue_copy;
int_queue_copy.push(1) ;
int_queue_copy.push(2) ;
int_queue_copy.push(3) ;
int_queue_copy.push(4) ;
TRICK_EXPECT_EQ(int_queue, int_queue_copy, test_suite, "int_queue");
std::queue<std::string> string_queue_copy;
string_queue_copy.push("I") ;
string_queue_copy.push("want") ;
string_queue_copy.push("an") ;
string_queue_copy.push("iPhone 4") ;
TRICK_EXPECT_EQ(string_queue, string_queue_copy, test_suite, "string_queue");
// Why doesn't priority_queue have the == operator but literally everything else does >:(
std::priority_queue<int> int_priority_queue_copy;
int_priority_queue_copy.push(3) ;
int_priority_queue_copy.push(2) ;
int_priority_queue_copy.push(4) ;
int_priority_queue_copy.push(1) ;
compare_data_structures_with_top(int_priority_queue_copy, int_priority_queue, "int_priority_queue");
std::priority_queue<std::string> string_priority_queue_copy;
string_priority_queue_copy.push("I") ;
string_priority_queue_copy.push("want") ;
string_priority_queue_copy.push("an") ;
string_priority_queue_copy.push("iPhone 4") ;
compare_data_structures_with_top(string_priority_queue_copy, string_priority_queue, "string_priority_queue");
std::queue<std::vector<int>> queue_vector_int_copy;
queue_vector_int_copy.emplace(temp_v1) ;
queue_vector_int_copy.emplace(temp_v2) ;
TRICK_EXPECT_EQ(queue_vector_int, queue_vector_int_copy, test_suite, "queue_vector_int");
std::priority_queue<std::vector<int>> priority_queue_vector_int_copy;
priority_queue_vector_int_copy.emplace(temp_v1) ;
priority_queue_vector_int_copy.emplace(temp_v2) ;
compare_data_structures_with_top(priority_queue_vector_int_copy, priority_queue_vector_int, "priority_queue_vector_int");
std::pair<int,int> int_pair_copy(10,20);
TRICK_EXPECT_EQ(int_pair, int_pair_copy, test_suite, "int_pair");
std::pair< std::string , int > string_first_pair_copy ("string first", 25);
TRICK_EXPECT_EQ(string_first_pair, string_first_pair_copy, test_suite, "string_first_pair");
std::pair< int , std::string > string_second_pair_copy (25, "string second");
TRICK_EXPECT_EQ(string_second_pair_copy, string_second_pair, test_suite, "string_second_pair");
std::pair< std::string , std::string > string_pair_copy ("pair first string", "pair second string");
TRICK_EXPECT_EQ(string_pair_copy, string_pair, test_suite, "string_pair");
std::pair< int , std::pair< int, int > > int_pair_int_int_copy;
int_pair_int_int_copy.first = 200 ;
p.first = 10 ;
p.second = 20 ;
int_pair_int_int_copy.second = p ;
TRICK_EXPECT_EQ(int_pair_int_int_copy, int_pair_int_int, test_suite, "int_pair_int_int");
std::pair< std::pair< int, int > , int > pair_int_int_int_copy;
p.first = 15 ;
p.second = 12 ;
pair_int_int_int_copy.first = p ;
pair_int_int_int_copy.second = 180 ;
TRICK_EXPECT_EQ(pair_int_int_int_copy, pair_int_int_int, test_suite, "pair_int_int_int");
std::pair< std::pair< int, int > , std::pair< int, int > > pair_pair_pair_copy ;
pair_pair_pair_copy.first.first = 51 ;
pair_pair_pair_copy.first.second = 52 ;
pair_pair_pair_copy.second.first = 53 ;
pair_pair_pair_copy.second.second = 54 ;
TRICK_EXPECT_EQ(pair_pair_pair_copy, pair_pair_pair, test_suite, "pair_pair_pair");
// Check all the int/vec combo pairs together, for laziness
TRICK_EXPECT_EQ(int_vec_pair.first, 5, test_suite, "int_vec_pair.first");
TRICK_EXPECT_EQ(vec_int_pair.second, 5, test_suite, "vec_int_pair.second");
TRICK_EXPECT_EQ(int_vec_pair.second.size(), 4, test_suite, "int_vec_pair.second.size");
TRICK_EXPECT_EQ(vec_int_pair.first.size(), 4, test_suite, "vec_int_pair.first.size");
TRICK_EXPECT_EQ(vec_vec_pair.first.size(), 4, test_suite, "vec_vec_pair.first.size");
TRICK_EXPECT_EQ(vec_vec_pair.second.size(), 4, test_suite, "vec_vec_pair.second.size");
for (int i = 0; i < int_vec_pair.second.size(); i++) {
TRICK_EXPECT_EQ(int_vec_pair.second[i], (i+1)*5, test_suite, "int_vec_pair.second elems");
TRICK_EXPECT_EQ(vec_int_pair.first[i], (i+1)*5, test_suite, "vec_int_pair.first elems");
TRICK_EXPECT_EQ(vec_vec_pair.first[i], (i+1)*5, test_suite, "vec_vec_pair.first elems");
TRICK_EXPECT_EQ(vec_vec_pair.second[i], (i+1)*5, test_suite, "vec_vec_pair.second elems");
}
TRICK_EXPECT_EQ(vec_user_simple.size(), 10, test_suite, "vec_user_simple")
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 5; j++) {
TRICK_EXPECT_EQ(vec_user_simple[i].a[j], i+j, test_suite, "vec_user_simple");
TRICK_EXPECT_EQ(vec_user_simple[i].d->a[j], i+j, test_suite, "vec_user_simple");
}
TRICK_EXPECT_EQ(vec_user_simple[i].b, 8888888888, test_suite, "vec_user_simple");
TRICK_EXPECT_EQ(vec_user_simple[i].d->b, 8888888888, test_suite, "vec_user_simple");
TRICK_EXPECT_EQ(vec_user_simple[i].c, "Here is a test string", test_suite, "vec_user_simple");
TRICK_EXPECT_EQ(vec_user_simple[i].d->c, "Here is a test string", test_suite, "vec_user_simple");
}
}
Reference in New Issue View Git Blame Copy Permalink