static void teardown(int fd)
{
alarm(0);
assert_empty(fd);
close(fd);
errno = 0;
}
DEF_TEST(Reader32, reporter) {
SkReader32 reader;
assert_empty(reporter, reader);
REPORTER_ASSERT(reporter, NULL == reader.base());
REPORTER_ASSERT(reporter, NULL == reader.peek());
size_t i;
const int32_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
const SkScalar data2[] = { 0, SK_Scalar1, -SK_Scalar1, SK_Scalar1/2 };
const size_t bufsize = sizeof(data) > sizeof(data2) ?
sizeof(data) : sizeof(data2);
char buffer[bufsize];
reader.setMemory(data, sizeof(data));
for (i = 0; i < SK_ARRAY_COUNT(data); ++i) {
REPORTER_ASSERT(reporter, sizeof(data) == reader.size());
REPORTER_ASSERT(reporter, i*4 == reader.offset());
REPORTER_ASSERT(reporter, (const void*)data == reader.base());
REPORTER_ASSERT(reporter, (const void*)&data[i] == reader.peek());
REPORTER_ASSERT(reporter, data[i] == reader.readInt());
}
assert_eof(reporter, reader);
reader.rewind();
assert_start(reporter, reader);
reader.read(buffer, sizeof(data));
REPORTER_ASSERT(reporter, !memcmp(data, buffer, sizeof(data)));
reader.setMemory(data2, sizeof(data2));
for (i = 0; i < SK_ARRAY_COUNT(data2); ++i) {
REPORTER_ASSERT(reporter, sizeof(data2) == reader.size());
REPORTER_ASSERT(reporter, i*4 == reader.offset());
REPORTER_ASSERT(reporter, (const void*)data2 == reader.base());
REPORTER_ASSERT(reporter, (const void*)&data2[i] == reader.peek());
REPORTER_ASSERT(reporter, data2[i] == reader.readScalar());
}
assert_eof(reporter, reader);
reader.rewind();
assert_start(reporter, reader);
reader.read(buffer, sizeof(data2));
REPORTER_ASSERT(reporter, !memcmp(data2, buffer, sizeof(data2)));
reader.setMemory(NULL, 0);
assert_empty(reporter, reader);
REPORTER_ASSERT(reporter, NULL == reader.base());
REPORTER_ASSERT(reporter, NULL == reader.peek());
}
void test_ipc_basic(){
ipc_push(&worker, IPC_TESTING, NULL, 0);
enum IPC command = ipc_fetch(&worker, NULL, 0);
CPPUNIT_ASSERT_EQUAL(command, IPC_TESTING);
assert_empty();
}
void test_ipc_flush(){
static const char src[] = "0123456789";
ipc_push(&worker, IPC_TESTING, src, sizeof(src));
enum IPC command = ipc_fetch(&worker, NULL, NULL);
CPPUNIT_ASSERT_EQUAL(IPC_TESTING, command);
assert_empty();
}
static void malloc_check(void)
{
MALLOCER(test1);
assert_empty(&mallocer_test1);
// Can malloc and deref
char *ptr = MALLOC(test1, 1);
assert(ptr);
ptr[1] = 'a';
assert(mallocer_test1.tot_size == 1);
assert(mallocer_test1.nb_blocks == 1);
FREE(ptr);
assert_empty(&mallocer_test1);
// Can malloc(0) then free it
ptr = MALLOC(test1, 0);
FREE(ptr);
assert_empty(&mallocer_test1);
}
Integer str_to_int(InputIterator first,
InputIterator last,
const char *function)
{
Integer sign = 1;
Integer value = 0;
std::tie(sign, first) = parse_sign<Integer>(first, last, function);
std::tie(value, first) = parse_integer<Integer>(first, last, function);
assert_empty(first, last, function);
return sign * value;
}
void test_ipc_reset(){
ipc_push(&worker, IPC_TESTING, NULL, 0);
char* dst = (char*)1;
size_t size;
enum IPC command = ipc_fetch(&worker, (void**)&dst, &size);
CPPUNIT_ASSERT_EQUAL(command, IPC_TESTING);
CPPUNIT_ASSERT_EQUAL((size_t)0, size);
CPPUNIT_ASSERT_EQUAL((char*)NULL, dst);
assert_empty();
}
static void realloc_check(void)
{
MALLOCER(test2);
// Can resize down
char *ptr = MALLOC(test2, 2);
assert(ptr);
ptr = REALLOC(test2, ptr, 1);
assert(ptr);
FREE(ptr);
assert_empty(&mallocer_test2);
// Resize to 0 means free
ptr = MALLOC(test2, 1);
REALLOC(test2, ptr, 0);
assert_empty(&mallocer_test2);
// Realloc of NULL means alloc
ptr = REALLOC(test2, NULL, 1);
assert(ptr);
assert(mallocer_test2.tot_size == 1);
FREE(ptr);
assert_empty(&mallocer_test2);
}
void test_ipc_payload(){
static const char src[] = "0123456789";
ipc_push(&worker, IPC_TESTING, src, sizeof(src));
char* dst;
size_t size;
enum IPC command = ipc_fetch(&worker, (void**)&dst, &size);
CPPUNIT_ASSERT_EQUAL(IPC_TESTING, command);
CPPUNIT_ASSERT_EQUAL(sizeof(src), size);
CPPUNIT_ASSERT_EQUAL(std::string(src), std::string(dst));
free(dst);
assert_empty();
}
void
test_clear()
{
HeapBitmap hb;
bool ok;
ok = dvmHeapBitmapInit(&hb, HEAP_BASE, HEAP_SIZE, "test");
assert(ok);
assert_empty(&hb);
/* Set the highest address.
*/
dvmHeapBitmapSetObjectBit(&hb, HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT);
assert(!is_zeroed(&hb));
/* Clear the bitmap.
*/
dvmHeapBitmapZero(&hb);
assert_empty(&hb);
/* Clean up.
*/
dvmHeapBitmapDelete(&hb);
}
Float str_to_float(InputIterator first,
InputIterator last,
const char *function)
{
Float sign = 0;
Float i_value = 0;
Float d_value = 0;
Float e_value = 0;
std::tie(sign, first) = parse_sign<Float>(first, last, function);
std::tie(i_value, first) = parse_integer<Float>(first, last, function);
std::tie(d_value, first) = parse_decimal<Float>(first, last, function);
std::tie(e_value, first) = parse_exponent<Float>(first, last, function);
assert_empty(first, last, function);
return sign * ((i_value + d_value) * std::pow(10, e_value));
}
inline void PreservedMarksSet::restore(RestorePreservedMarksTaskExecutor* executor) {
volatile size_t total_size = 0;
#ifdef ASSERT
// This is to make sure the total_size we'll calculate below is correct.
size_t total_size_before = 0;
for (uint i = 0; i < _num; i += 1) {
total_size_before += get(i)->size();
}
#endif // def ASSERT
executor->restore(this, &total_size);
assert_empty();
assert(total_size == total_size_before,
"total_size = " SIZE_FORMAT " before = " SIZE_FORMAT,
total_size, total_size_before);
log_trace(gc)("Restored " SIZE_FORMAT " marks", total_size);
}
static int setup(int in, int nonblock)
{
int fd;
alarm(0);
fd = dup(in);
if (nonblock) {
int ret = -1;
if (fd != -1)
ret = fcntl(fd, F_GETFL);
if (ret != -1) {
ret |= O_NONBLOCK;
ret = fcntl(fd, F_SETFL, ret);
}
igt_require(ret != -1);
}
assert_empty(fd);
return fd;
}
void
test_bits()
{
HeapBitmap hb;
bool ok;
ok = dvmHeapBitmapInit(&hb, HEAP_BASE, HEAP_SIZE, "test");
assert(ok);
assert_empty(&hb);
/* Set the lowest address.
*/
dvmHeapBitmapSetObjectBit(&hb, HEAP_BASE);
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
/* Set the highest address.
*/
dvmHeapBitmapSetObjectBit(&hb, HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT);
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE));
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
/* Clear the lowest address.
*/
dvmHeapBitmapClearObjectBit(&hb, HEAP_BASE);
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
assert(!is_zeroed(&hb));
/* Clear the highest address.
*/
dvmHeapBitmapClearObjectBit(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT);
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
assert(is_zeroed(&hb));
/* Clean up.
*/
dvmHeapBitmapDelete(&hb);
}
void
run_xor(ssize_t offset, size_t step)
{
assert(step != 0);
assert(step < HEAP_SIZE);
/* Figure out the range.
*/
uintptr_t base;
uintptr_t top;
if (offset >= 0) {
base = (uintptr_t)HEAP_BASE + offset;
} else {
base = (uintptr_t)HEAP_BASE + (uintptr_t)HEAP_SIZE + offset;
}
if (base < (uintptr_t)HEAP_BASE) {
base = (uintptr_t)HEAP_BASE;
} else if (base > (uintptr_t)(HEAP_BASE + HEAP_SIZE)) {
base = (uintptr_t)(HEAP_BASE + HEAP_SIZE);
} else {
base = (base + HB_OBJECT_ALIGNMENT - 1) & ~(HB_OBJECT_ALIGNMENT - 1);
}
step *= HB_OBJECT_ALIGNMENT;
top = base + step * NUM_XOR_PTRS;
if (top > (uintptr_t)(HEAP_BASE + HEAP_SIZE)) {
top = (uintptr_t)(HEAP_BASE + HEAP_SIZE);
}
/* Create the pointers.
*/
gNumPtrs = 0;
memset(gXorPtrs, 0, sizeof(gXorPtrs));
memset(gClearedPtrs, 0, sizeof(gClearedPtrs));
memset(gSeenPtrs, 0, sizeof(gSeenPtrs));
uintptr_t addr;
void **p = gXorPtrs;
for (addr = base; addr < top; addr += step) {
*p++ = (void *)addr;
gNumPtrs++;
}
assert(seenAndClearedMatch());
/* Set up the bitmaps.
*/
HeapBitmap hb1, hb2;
bool ok;
ok = dvmHeapBitmapInit(&hb1, HEAP_BASE, HEAP_SIZE, "test1");
assert(ok);
ok = dvmHeapBitmapInitFromTemplate(&hb2, &hb1, "test2");
assert(ok);
/* Walk two empty bitmaps.
*/
TRACE("walk 0\n");
ok = dvmHeapBitmapXorWalk(&hb1, &hb2, xorCallback, gCallbackArg);
assert(ok);
assert(seenAndClearedMatch());
/* Walk one empty bitmap.
*/
TRACE("walk 1\n");
dvmHeapBitmapSetObjectBit(&hb1, (void *)base);
ok = dvmHeapBitmapXorWalk(&hb1, &hb2, xorCallback, gCallbackArg);
assert(ok);
/* Make the bitmaps match.
*/
TRACE("walk 2\n");
dvmHeapBitmapSetObjectBit(&hb2, (void *)base);
ok = dvmHeapBitmapXorWalk(&hb1, &hb2, xorCallback, gCallbackArg);
assert(ok);
/* Clear the bitmaps.
*/
dvmHeapBitmapZero(&hb1);
assert_empty(&hb1);
dvmHeapBitmapZero(&hb2);
assert_empty(&hb2);
/* Set the pointers we created in one of the bitmaps,
* then visit them.
*/
size_t i;
for (i = 0; i < gNumPtrs; i++) {
dvmHeapBitmapSetObjectBit(&hb1, gXorPtrs[i]);
}
TRACE("walk 3\n");
ok = dvmHeapBitmapXorWalk(&hb1, &hb2, xorCallback, gCallbackArg);
assert(ok);
/* Set every third pointer in the other bitmap, and visit again.
*/
for (i = 0; i < gNumPtrs; i += 3) {
dvmHeapBitmapSetObjectBit(&hb2, gXorPtrs[i]);
}
TRACE("walk 4\n");
ok = dvmHeapBitmapXorWalk(&hb1, &hb2, xorCallback, gCallbackArg);
assert(ok);
/* Set every other pointer in the other bitmap, and visit again.
*/
for (i = 0; i < gNumPtrs; i += 2) {
dvmHeapBitmapSetObjectBit(&hb2, gXorPtrs[i]);
}
TRACE("walk 5\n");
ok = dvmHeapBitmapXorWalk(&hb1, &hb2, xorCallback, gCallbackArg);
assert(ok);
/* Walk just one bitmap.
*/
TRACE("walk 6\n");
ok = dvmHeapBitmapWalk(&hb2, xorCallback, gCallbackArg);
assert(ok);
//xxx build an expect list for the callback
//xxx test where max points to beginning, middle, and end of a word
/* Clean up.
*/
dvmHeapBitmapDelete(&hb1);
dvmHeapBitmapDelete(&hb2);
}
void
test_modify()
{
HeapBitmap hb;
bool ok;
unsigned long bit;
ok = dvmHeapBitmapInit(&hb, HEAP_BASE, HEAP_SIZE, "test");
assert(ok);
assert_empty(&hb);
/* Set the lowest address.
*/
bit = dvmHeapBitmapSetAndReturnObjectBit(&hb, HEAP_BASE);
assert(bit == 0);
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
/* Set the lowest address again.
*/
bit = dvmHeapBitmapSetAndReturnObjectBit(&hb, HEAP_BASE);
assert(bit != 0);
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
/* Set the highest address.
*/
bit = dvmHeapBitmapSetAndReturnObjectBit(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT);
assert(bit == 0);
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE));
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
/* Set the highest address again.
*/
bit = dvmHeapBitmapSetAndReturnObjectBit(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT);
assert(bit != 0);
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE));
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
assert(!dvmHeapBitmapMayContainObject(&hb,
HEAP_BASE + HEAP_SIZE));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE));
assert(!dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HB_OBJECT_ALIGNMENT));
assert(dvmHeapBitmapIsObjectBitSet(&hb,
HEAP_BASE + HEAP_SIZE - HB_OBJECT_ALIGNMENT));
/* Clean up.
*/
dvmHeapBitmapDelete(&hb);
}
lock_m::~lock_m()
{
assert_empty();
delete _core;
}
