static void JoinStringsIterator(const ITERATOR& start,
const ITERATOR& end,
const char* delim,
string* result) {
GOOGLE_CHECK(result != NULL);
result->clear();
int delim_length = strlen(delim);
// Precompute resulting length so we can reserve() memory in one shot.
int length = 0;
for (ITERATOR iter = start; iter != end; ++iter) {
if (iter != start) {
length += delim_length;
}
length += iter->size();
}
result->reserve(length);
// Now combine everything.
for (ITERATOR iter = start; iter != end; ++iter) {
if (iter != start) {
result->append(delim, delim_length);
}
result->append(iter->data(), iter->size());
}
}
void iterator_read_test ()
{
const int WIDTH = 4, HEIGHT = 4, CHANNELS = 3;
static float buf[HEIGHT][WIDTH][CHANNELS] = {
{ {0,0,0}, {1,0,1}, {2,0,2}, {3,0,3} },
{ {0,1,4}, {1,1,5}, {2,1,6}, {3,1,7} },
{ {0,2,8}, {1,2,9}, {2,2,10}, {3,2,11} },
{ {0,3,12}, {1,3,13}, {2,3,14}, {3,3,15} }
};
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
ImageBuf A (spec, buf);
ITERATOR p (A);
OIIO_CHECK_EQUAL (p[0], 0.0f);
OIIO_CHECK_EQUAL (p[1], 0.0f);
OIIO_CHECK_EQUAL (p[2], 0.0f);
// Explicit position
p.pos (2, 1);
OIIO_CHECK_EQUAL (p.x(), 2); OIIO_CHECK_EQUAL (p.y(), 1);
OIIO_CHECK_EQUAL (p[0], 2.0f);
OIIO_CHECK_EQUAL (p[1], 1.0f);
OIIO_CHECK_EQUAL (p[2], 6.0f);
// Iterate a few times
++p;
OIIO_CHECK_EQUAL (p.x(), 3); OIIO_CHECK_EQUAL (p.y(), 1);
OIIO_CHECK_EQUAL (p[0], 3.0f);
OIIO_CHECK_EQUAL (p[1], 1.0f);
OIIO_CHECK_EQUAL (p[2], 7.0f);
++p;
OIIO_CHECK_EQUAL (p.x(), 0); OIIO_CHECK_EQUAL (p.y(), 2);
OIIO_CHECK_EQUAL (p[0], 0.0f);
OIIO_CHECK_EQUAL (p[1], 2.0f);
OIIO_CHECK_EQUAL (p[2], 8.0f);
std::cout << "iterator_read_test result:";
int i = 0;
for (ITERATOR p (A); !p.done(); ++p, ++i) {
if ((i % 4) == 0)
std::cout << "\n ";
std::cout << " " << p[0] << ' ' << p[1] << ' ' << p[2];
}
std::cout << "\n";
}
static bool move(Grid &grid, Dynamics::MoveStats &stats) {
bool anyChange = false;
ITERATOR iterator;
do {
ITERATOR begin(iterator);
while (iterator.increment()) {
while (begin != iterator) {
auto source = grid.get(*iterator);
if (source == 0u)
break;
auto destination = grid.get(*begin);
if (destination == 0u) {
// Move source to destination.
grid.set(*begin, source);
grid.set(*iterator, 0u);
anyChange = true;
break;
} else if (destination == source) {
// Merge.
const size_t mergedValue = 2u * source;
grid.set(*begin, mergedValue);
grid.set(*iterator, 0u);
begin.increment();
stats.score += mergedValue;
if (mergedValue > stats.higherMergedValue)
stats.higherMergedValue = mergedValue;
anyChange = true;
break;
} else {
begin.increment();
}
}
}
} while (iterator.jump());
return anyChange;
}
static int
iterator_test (void)
{
const int ITERATIONS = 5;
ACE_TCHAR buffer[ITERATIONS][BUFSIZ];
// Use queue size from of 32 Kb (more if using wide-char), instead of the
// default of 16 Kb (defined by ACE_Message_Queue_Base::DEFAULT_HWM),
// so that the test runs on machines with 8Kb pagesizes.
// QUEUE queue (32 * 1024 * sizeof (ACE_TCHAR));
QUEUE queue (sizeof(buffer));
int i;
for (i = 0; i < ITERATIONS; i++)
{
ACE_OS::sprintf (buffer[i],
ACE_TEXT ("%d"),
i + 1);
ACE_Message_Block *entry = 0;
ACE_NEW_RETURN (entry,
ACE_Message_Block ((char *) buffer[i],
sizeof buffer[i]),
-1);
if (queue.is_full ())
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("QUEUE:: the message queue is full on iteration %u!\n"),
i + 1),
-1);
if (queue.enqueue (entry) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("QUEUE::enqueue\n")),
-1);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\nForward Iterations\n")));
{
ITERATOR iterator (queue);
for (ACE_Message_Block *entry = 0;
iterator.next (entry) != 0;
iterator.advance ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%s\n"),
entry->base ()));
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\nReverse Iterations\n")));
{
REVERSE_ITERATOR iterator (queue);
for (ACE_Message_Block *entry = 0;
iterator.next (entry) != 0;
iterator.advance ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%s\n"),
entry->base ()));
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\nForward Iterations\n")));
{
QUEUE::ITERATOR iterator (queue);
for (ACE_Message_Block *entry = 0;
iterator.next (entry) != 0;
iterator.advance ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%s\n"),
entry->base ()));
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\nReverse Iterations\n")));
{
QUEUE::REVERSE_ITERATOR iterator (queue);
for (ACE_Message_Block *entry = 0;
iterator.next (entry) != 0;
iterator.advance ())
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%s\n"),
entry->base ()));
}
return 0;
}
void iterator_wrap_test (ImageBuf::WrapMode wrap, std::string wrapname)
{
const int WIDTH = 4, HEIGHT = 4, CHANNELS = 3;
static float buf[HEIGHT][WIDTH][CHANNELS] = {
{ {0,0,0}, {1,0,1}, {2,0,2}, {3,0,3} },
{ {0,1,4}, {1,1,5}, {2,1,6}, {3,1,7} },
{ {0,2,8}, {1,2,9}, {2,2,10}, {3,2,11} },
{ {0,3,12}, {1,3,13}, {2,3,14}, {3,3,15} }
};
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
ImageBuf A (spec, buf);
std::cout << "iterator_wrap_test " << wrapname << ":";
int i = 0;
int noutside = 0;
for (ITERATOR p (A, ROI(-2, WIDTH+2, -2, HEIGHT+2), wrap);
!p.done(); ++p, ++i) {
if ((i % 8) == 0)
std::cout << "\n ";
std::cout << " " << p[0] << ' ' << p[1] << ' ' << p[2];
// Check wraps
if (! p.exists()) {
++noutside;
if (wrap == ImageBuf::WrapBlack) {
OIIO_CHECK_EQUAL (p[0], 0.0f);
OIIO_CHECK_EQUAL (p[1], 0.0f);
OIIO_CHECK_EQUAL (p[2], 0.0f);
} else if (wrap == ImageBuf::WrapClamp) {
ITERATOR q = p;
q.pos (clamp (p.x(), 0, WIDTH-1), clamp (p.y(), 0, HEIGHT-1));
OIIO_CHECK_EQUAL (p[0], q[0]);
OIIO_CHECK_EQUAL (p[1], q[1]);
OIIO_CHECK_EQUAL (p[2], q[2]);
} else if (wrap == ImageBuf::WrapPeriodic) {
ITERATOR q = p;
q.pos (p.x() % WIDTH, p.y() % HEIGHT);
OIIO_CHECK_EQUAL (p[0], q[0]);
OIIO_CHECK_EQUAL (p[1], q[1]);
OIIO_CHECK_EQUAL (p[2], q[2]);
} else if (wrap == ImageBuf::WrapMirror) {
ITERATOR q = p;
int x = p.x(), y = p.y();
wrap_mirror (x, 0, WIDTH);
wrap_mirror (y, 0, HEIGHT);
q.pos (x, y);
OIIO_CHECK_EQUAL (p[0], q[0]);
OIIO_CHECK_EQUAL (p[1], q[1]);
OIIO_CHECK_EQUAL (p[2], q[2]);
}
}
}
std::cout << "\n";
OIIO_CHECK_EQUAL (noutside, 48); // Should be 48 wrapped pixels
}
static void
test_map_manager (size_t table_size,
size_t iterations,
int test_iterators)
{
MAP_MANAGER map (table_size);
TYPE i;
TYPE j = 0;
ssize_t k;
for (i = 0; i < iterations; ++i)
ACE_ASSERT (map.bind (i, i) != -1);
if (test_iterators)
{
{
i = 0;
ITERATOR end = map.end ();
for (ITERATOR iter = map.begin ();
iter != end;
++iter)
{
MAP_ENTRY &entry = *iter;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d|%d)"),
i,
entry.ext_id_,
entry.int_id_));
++i;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_ASSERT (i == iterations);
}
{
i = 0;
MAP_ENTRY *entry = 0;
for (ITERATOR iterator (map);
iterator.next (entry) != 0;
iterator.advance ())
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d|%d)"),
i,
entry->ext_id_,
entry->int_id_));
++i;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_ASSERT (i == iterations);
}
{
k = iterations - 1;
REVERSE_ITERATOR rend = map.rend ();
for (REVERSE_ITERATOR iter = map.rbegin ();
iter != rend;
++iter)
{
MAP_ENTRY &entry = *iter;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d|%d)"),
k,
entry.ext_id_,
entry.int_id_));
k--;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_ASSERT (k == -1);
}
{
k = iterations - 1;
MAP_ENTRY *entry = 0;
for (REVERSE_ITERATOR iterator (map);
iterator.next (entry) != 0;
iterator.advance ())
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d|%d)"),
k,
entry->ext_id_,
entry->int_id_));
k--;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_ASSERT (k == -1);
}
{
i = 0;
MAP_MANAGER::iterator end = map.end ();
for (MAP_MANAGER::iterator iter = map.begin ();
iter != end;
++iter)
{
MAP_MANAGER::ENTRY &entry = *iter;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d|%d)"),
i,
entry.ext_id_,
entry.int_id_));
++i;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_ASSERT (i == iterations);
}
{
i = 0;
MAP_MANAGER::ENTRY *entry = 0;
for (MAP_MANAGER::ITERATOR iterator (map);
iterator.next (entry) != 0;
iterator.advance ())
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d|%d)"),
i,
entry->ext_id_,
entry->int_id_));
++i;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_ASSERT (i == iterations);
}
{
k = iterations - 1;
MAP_MANAGER::reverse_iterator rend = map.rend ();
for (MAP_MANAGER::reverse_iterator iter = map.rbegin ();
iter != rend;
++iter)
{
MAP_ENTRY &entry = *iter;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d|%d)"),
k,
entry.ext_id_,
entry.int_id_));
k--;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_ASSERT (k == -1);
}
{
k = iterations - 1;
MAP_MANAGER::ENTRY *entry = 0;
for (MAP_MANAGER::REVERSE_ITERATOR iterator (map);
iterator.next (entry) != 0;
iterator.advance ())
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d|%d)"),
k,
entry->ext_id_,
entry->int_id_));
k--;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_ASSERT (k == -1);
}
}
for (i = 0; i < iterations; ++i)
{
ACE_ASSERT (map.find (i, j) != -1);
ACE_ASSERT (i == j);
}
size_t remaining_entries = iterations;
for (i = 0; i < iterations; ++i)
{
ACE_ASSERT (map.unbind (i) != -1);
--remaining_entries;
ACE_ASSERT (map.current_size () == remaining_entries);
}
//
// This is extra for the map manager.
//
for (i = 0; i < iterations; ++i)
ACE_ASSERT (map.bind (i, i) != -1);
// Unbind in one swoop.
map.unbind_all ();
ACE_ASSERT (map.current_size () == 0);
for (i = 0; i < iterations; ++i)
ACE_ASSERT (map.bind (i, i) != -1);
// Unbind one at a time.
MAP_MANAGER::iterator end = map.end ();
while (1)
{
MAP_MANAGER::iterator iter = map.begin ();
if (iter == end)
break;
ACE_ASSERT (map.unbind ((*iter).ext_id_) != -1);
}
ACE_ASSERT (map.current_size () == 0);
}
int run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Vector_Test"));
VECTOR vector;
size_t i;
for (i = 0; i < TOP; ++i)
vector.push_back (i);
ACE_TEST_ASSERT (vector.size () == TOP);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Size: %d\n"),
vector.size ()));
for (i = 0; i < TOP; ++i)
ACE_TEST_ASSERT (vector[i] == i);
// Test to be sure the iterator gets the correct count and entries.
ITERATOR iter (vector);
DATA *p_item = 0 ;
size_t iter_count = 0;
while (!iter.done ())
{
if (iter.next (p_item) == 0)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Fail to get value on iter pass %d\n"),
iter_count));
if (*p_item != iter_count)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Iter pass %d got %d\n"),
iter_count, *p_item));
iter_count++;
iter.advance();
}
if (iter_count != TOP)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Iterated %d elements; expected %d\n"),
iter_count, TOP));
for (i = 0; i < (TOP - LEFT); ++i)
vector.pop_back ();
ACE_TEST_ASSERT (vector.size () == LEFT);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Size: %d\n"),
vector.size ()));
for (i = 0; i < LEFT; ++i)
{
ACE_TEST_ASSERT (vector[i] == i);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("vector[%d]:%d\n"),
i, vector[i]));
}
vector.resize(RESIZE, 0);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("After resize\n")));
for (i = 0; i < RESIZE ; ++i)
{
// The original vector of size LEFT must have the same original contents
// the new elements should have the value 0 (this value is passed as
// second argument of the resize() call.
if (i < LEFT)
{
ACE_TEST_ASSERT (vector[i] == i);
}
else
{
ACE_TEST_ASSERT (vector[i] == 0);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("vector[%d]:%d\n"),
i, vector[i]));
}
vector.clear ();
ACE_TEST_ASSERT (vector.size () == 0);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Size: %d\n"),
vector.size ()));
// test resize (shrink and enlarge with buffer realloc)
VECTOR vector2;
// should be around 32
size_t boundary = vector2.capacity ();
// we fill everything up with 1
// 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1,
for (i = 0; i < boundary; ++i)
vector2.push_back (FILLER1);
// we throw almost everything away.
vector2.resize (1, 0);
// we fill up with another pattern
// 1, 2, 2, 2, 2, 2, 2, 2,
// 2, 2, 2, 2, 2, 2, 2, 2,
// 2, 2, 2, 2, 2, 2, 2, 2,
// 2, 2, 2, 2, 2, 2, 2, 2,
// 2,
for (i = 0; i < boundary; ++i)
vector2.push_back (FILLER2);
// now we check the result
ACE_TEST_ASSERT (vector2[0] == FILLER1);
for (i = 0; i < boundary; ++i)
ACE_TEST_ASSERT (vector2[i+1] == FILLER2);
VECTOR v1;
VECTOR v2;
v1.push_back (1);
v2.push_back (1);
v1.push_back (2);
v2.push_back (2);
if (v1 != v2)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Inequality test failed!\n")));
if (!(v1 == v2))
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Equality test failed!\n")));
v1.push_back (3);
if (v1.size () != 3)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("v1's size should be 3\n")));
v1.swap (v2);
if (v2.size () != 3)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("v2's size should be 3\n")));
ACE_END_TEST;
return 0;
}
