BOOST_FIXTURE_TEST_CASE(compact_elias_fano_singleton,
sequence_initialization)
{
// test singleton sequences
std::vector<uint64_t> short_seq;
short_seq.push_back(0);
test_sequence(ds2i::compact_elias_fano(), params, 1, short_seq);
short_seq[0] = 1;
test_sequence(ds2i::compact_elias_fano(), params, 2, short_seq);
}
void test_sequence1 () {
std::vector<int> v;
for ( int i = 5; i < 15; ++i )
v.push_back ( i );
test_sequence ( v );
std::list<int> l;
for ( int i = 25; i > 15; --i )
l.push_back ( i );
test_sequence ( l );
}
void test_sequence1 () {
std::vector<int> v;
for ( int i = 5; i < 15; ++i )
v.push_back ( i );
test_sequence ( v );
BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr();
BOOST_CHECK(constexpr_res);
std::list<int> l;
for ( int i = 25; i > 15; --i )
l.push_back ( i );
test_sequence ( l );
}
void test_sequence_collection()
{
ds2i::global_parameters params;
uint64_t universe = 10000;
typedef ds2i::sequence_collection<BaseSequence>
collection_type;
typename collection_type::builder b(params);
std::vector<std::vector<uint64_t>> sequences(30);
for (auto& seq: sequences) {
double avg_gap = 1.1 + double(rand()) / RAND_MAX * 10;
uint64_t n = uint64_t(universe / avg_gap);
seq = random_sequence(universe, n, true);
b.add_sequence(seq.begin(), seq.back() + 1, n);
}
{
collection_type coll;
b.build(coll);
succinct::mapper::freeze(coll, "temp.bin");
}
{
collection_type coll;
boost::iostreams::mapped_file_source m("temp.bin");
succinct::mapper::map(coll, m);
for (size_t i = 0; i < sequences.size(); ++i) {
test_sequence(coll[i], sequences[i]);
}
}
}
static size_t random_tests(size_t seed, size_t number, size_t maxsize)
{
size_t fail = 0;
srand(seed);
printf("Seed: %zu\n", seed);
for (size_t i = 0; i < number; i++)
{
Test t;
t.size = rand() % maxsize;
t.data = (Colour *)malloc(t.size * sizeof(*t.data)); /*=C++=*/
if (t.data == 0)
{
fprintf(stderr, "Out of memory\n");
exit(1);
}
if (verbose)
printf("Test: %zu (%zu)\n", i, t.size);
for (size_t j = 0; j < t.size; j++)
t.data[j] = (Colour)(rand() % 3);
if (test_sequence(t) == false)
{
fail++;
break;
}
}
return fail;
}
void test_partitioned_sequence(uint64_t universe,
std::vector<uint64_t> const& seq)
{
ds2i::global_parameters params;
typedef ds2i::partitioned_sequence<BaseSequence> sequence_type;
succinct::bit_vector_builder bvb;
sequence_type::write(bvb, seq.begin(), universe, seq.size(), params);
succinct::bit_vector bv(&bvb);
typename sequence_type::enumerator r(bv, 0, universe, seq.size(), params);
ds2i::partitioned_sequence_test::test_construction(r, seq);
test_sequence(r, seq);
}
int main()
{
typedef fusion::vector<> vector0;
typedef fusion::vector<element1_type &> vector1;
typedef fusion::vector<element1_type &, element2_type> vector2;
typedef fusion::vector<element1_type &, element2_type, element3_type> vector3;
vector0 v0;
vector1 v1(element1);
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
// Note: C++11 will pickup the rvalue overload for the d argument
// since we do not have all permutations (expensive!) for all const&
// and && arguments. We either have all && or all const& arguments only.
// For that matter, use std::ref to disambiguate the call.
vector2 v2(std::ref(element1), element2);
vector3 v3(std::ref(element1), element2, std::ref(element3));
#else
vector2 v2(element1, element2);
vector3 v3(element1, element2, element3);
#endif
test_sequence(v0);
test_sequence(v1);
test_sequence(v2);
test_sequence(v3);
typedef fusion::list<> list0;
typedef fusion::list<element1_type &> list1;
typedef fusion::list<element1_type &, element2_type> list2;
typedef fusion::list<element1_type &, element2_type, element3_type> list3;
list0 l0;
list1 l1(element1);
list2 l2(element1, element2);
list3 l3(element1, element2, element3);
test_sequence(l0);
test_sequence(l1);
test_sequence(l2);
test_sequence(l3);
return boost::report_errors();
}
int main(int argc, char *argv[])
{
if (argc <= 1)
fixed_sequences();
else {
float arr[argc-1]; // convert string arguments to float vaules
for (int i = 1; i < argc; i++) {
char *end;
arr[i-1] = strtof(argv[i], &end);
if (*end != '\0' || errno)
error(1, errno, "invalid number '%s'", argv[i]);
}
test_sequence(0, arr, argc-1);
}
return 0;
}
void test_sequence1 () {
std::vector<int> v;
v.clear ();
for ( int i = 5; i < 15; ++i )
v.push_back ( i );
test_sequence ( v, less_than<int>(3)); // no elements
test_sequence ( v, less_than<int>(6)); // only the first element
test_sequence ( v, less_than<int>(10));
test_sequence ( v, less_than<int>(99)); // all elements satisfy
// With bidirectional iterators.
std::list<int> l;
for ( int i = 5; i < 16; ++i )
l.push_back ( i );
test_sequence ( l, less_than<int>(3)); // no elements
test_sequence ( l, less_than<int>(6)); // only the first element
test_sequence ( l, less_than<int>(10));
test_sequence ( l, less_than<int>(99)); // all elements satisfy
}
static void fixed_sequences(void)
{
float seq1[] = {4, 4.5, 5, 0};
float seq2[] = {FLT_MAX, FLT_MAX};
float seq3[] = {33333330, 66666660, 9};
float seq4[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
float seq5[] = {66666666, 3, -66666666};
float seq6[] = {1 << 24, 1, 0, -1};
float seq7[] = {1.5e8, 100.5, -1.5e8, 99.5};
float seq8[] = {1e-45, 2e-45};
// add your own sequences here !
test_sequence(1, ARRAY_AND_COUNT(seq1));
test_sequence(2, ARRAY_AND_COUNT(seq2));
test_sequence(3, ARRAY_AND_COUNT(seq3));
test_sequence(4, ARRAY_AND_COUNT(seq4));
test_sequence(5, ARRAY_AND_COUNT(seq5));
test_sequence(6, ARRAY_AND_COUNT(seq6));
test_sequence(7, ARRAY_AND_COUNT(seq7));
test_sequence(8, ARRAY_AND_COUNT(seq8));
}
int main(int argc, char *argv[])
{
int mq_id;
int i, max;
int optc;
int debug_level = 0;
int addr = 0x10;
int reg_no=1000;
int reg_type = MB_TYPE_COILS;
int value = 0;
int timeout = 500;
int mult = 0;
mq_id = connect_ipc();
flush_msg_ipc(mq_id);
while ((optc = getopt(argc, argv, "a:t:r:m:s:g::S:T:R:hd::")) > 0) {
switch (optc){
case 'a': //address
addr = atoi_adv(optarg);
break;
case 't': //register type
reg_type = reg_type_get(optarg);
break;
case 'r': //register number
reg_no = atoi_adv(optarg);
break;
case 'm':
mult = atoi_adv(optarg);
break;
case 'g':{
enum eValueTypes val_type = MV_TYPE_SHORT;
if(optarg)
if(optarg[0]=='l')
val_type = MV_TYPE_LONG;
if(read_cmd(mq_id, addr, reg_type, reg_no, val_type, &value, 1)==1)
printf("Read value %d\n", value);
else{
fprintf(stderr, "Error reading value \n");
return 1;
}
}break;
case 's': //set register
value = atoi_adv(optarg);
write_cmd(mq_id,addr, reg_type, reg_no, mult, value, debug_level);
break;
case 'S':
addr_scan( mq_id, addr, atoi_adv(optarg) , reg_type, reg_no);
break;
case 'R':
reg_scan(mq_id, addr, reg_type , reg_no, atoi_adv(optarg));
break;
case 'T':
test_sequence(mq_id,addr, reg_no, reg_type, mult, optarg);
break;
case 'd':
debug_level = 1;
break;
case 'h': // Help
default:
fprintf(stderr, "%s", HelpText);
exit(0);
break;
}
}
return EXIT_SUCCESS;
}
static size_t fixed_tests(char const *range, size_t *counter)
{
size_t fail = 0;
Colour seq_001[] = { WHITE, BLACK, RED };
Colour seq_002[] = { WHITE, WHITE, WHITE };
Colour seq_003[] = { RED, RED, RED };
Colour seq_004[] = { BLACK, BLACK, BLACK };
Colour seq_005[] = { RED, BLACK, WHITE };
Colour seq_006[] = { WHITE, WHITE, RED, RED, BLACK, BLACK, WHITE };
Colour seq_007[] =
{
BLACK, BLACK, WHITE, WHITE, RED, RED, BLACK, BLACK, WHITE,
BLACK, BLACK,
};
Colour seq_008[] = { WHITE, BLACK };
Colour seq_009[] = { BLACK, BLACK, RED, RED, WHITE, WHITE, RED };
Colour seq_010[] = { BLACK, BLACK, RED, WHITE, RED };
Colour seq_011[] =
{
RED, BLACK, RED, WHITE, RED, RED, BLACK, WHITE, RED, BLACK, RED,
BLACK, BLACK, RED, BLACK, WHITE, BLACK, WHITE, WHITE, WHITE,
WHITE, RED, RED, RED, RED, BLACK, WHITE
};
Colour seq_012[] =
{
WHITE, WHITE, RED, WHITE, RED, BLACK, RED, BLACK, WHITE, BLACK,
RED, RED, RED, WHITE, RED, RED, BLACK, BLACK, BLACK, RED, RED,
BLACK, BLACK, WHITE, WHITE, RED, WHITE, BLACK, RED, BLACK,
WHITE, RED, WHITE, WHITE, RED, WHITE, BLACK, RED, RED, RED,
WHITE,
};
Colour seq_013[] = { RED, WHITE, RED, };
Colour seq_014[] = { RED, WHITE, };
Colour seq_015[] = { RED, BLACK, };
Colour seq_016[] = { RED, RED, };
Colour seq_017[] = { BLACK, WHITE, };
Colour seq_018[] = { BLACK, BLACK, };
Colour seq_019[] = { BLACK, RED, };
Colour seq_020[] = { WHITE, WHITE, };
Colour seq_021[] = { WHITE, RED, };
Colour seq_022[] = { RED, WHITE, RED, WHITE, };
Colour seq_023[] =
{
RED, WHITE, RED, WHITE, RED, RED, WHITE, WHITE, WHITE,
};
Test tests[] =
{
{ seq_001, sizeof(seq_001)/sizeof(seq_001[0]) },
{ seq_002, sizeof(seq_002)/sizeof(seq_002[0]) },
{ seq_003, sizeof(seq_003)/sizeof(seq_003[0]) },
{ seq_004, sizeof(seq_004)/sizeof(seq_004[0]) },
{ seq_005, sizeof(seq_005)/sizeof(seq_005[0]) },
{ seq_006, sizeof(seq_006)/sizeof(seq_006[0]) },
{ seq_007, sizeof(seq_007)/sizeof(seq_007[0]) },
{ seq_008, sizeof(seq_008)/sizeof(seq_008[0]) },
{ seq_009, sizeof(seq_009)/sizeof(seq_009[0]) },
{ seq_010, sizeof(seq_010)/sizeof(seq_010[0]) },
{ seq_011, sizeof(seq_011)/sizeof(seq_011[0]) },
{ seq_012, sizeof(seq_012)/sizeof(seq_012[0]) },
{ seq_013, sizeof(seq_013)/sizeof(seq_013[0]) },
{ seq_014, sizeof(seq_014)/sizeof(seq_014[0]) },
{ seq_015, sizeof(seq_015)/sizeof(seq_015[0]) },
{ seq_016, sizeof(seq_016)/sizeof(seq_016[0]) },
{ seq_017, sizeof(seq_017)/sizeof(seq_017[0]) },
{ seq_018, sizeof(seq_018)/sizeof(seq_018[0]) },
{ seq_019, sizeof(seq_019)/sizeof(seq_019[0]) },
{ seq_020, sizeof(seq_020)/sizeof(seq_020[0]) },
{ seq_021, sizeof(seq_021)/sizeof(seq_021[0]) },
{ seq_022, sizeof(seq_022)/sizeof(seq_022[0]) },
{ seq_023, sizeof(seq_023)/sizeof(seq_023[0]) },
};
enum { NUM_TESTS = sizeof(tests) / sizeof(tests[0]) };
*counter = 0;
if (range != 0)
{
const char *ptr = range;
const char *nxt;
long lo;
long hi;
while ((nxt = parse_range(ptr, &lo, &hi)) != 0)
{
if (nxt == ptr)
err_error("invalid range string (%s)\n", range);
if (hi == 0)
hi = NUM_TESTS-1;
for (long i = lo; i <= hi; i++)
{
(*counter)++;
if (test_sequence(tests[i]) == false)
{
printf("Test %ld: Failed\n", i);
fail++;
}
}
ptr = nxt;
}
}
else
{
for (size_t i = 0; i < NUM_TESTS; i++)
{
(*counter)++;
if (test_sequence(tests[i]) == false)
{
printf("Test %ld: Failed\n", i);
fail++;
}
}
}
return fail;
}
TEST_F(queue_test, iterator)
{
test_end();
test_sequence();
}
