TEST(plankton, cycles) {
CREATE_RUNTIME();
value_t i0 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species));
value_t k0 = new_integer(78);
ASSERT_SUCCESS(set_instance_field(runtime, i0, k0, i0));
value_t d0 = transcode_plankton(runtime, NULL, NULL, i0);
ASSERT_SAME(d0, get_instance_field(d0, k0));
value_t i1 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species));
value_t i2 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species));
value_t i3 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species));
value_t k1 = new_integer(79);
ASSERT_SUCCESS(set_instance_field(runtime, i1, k0, i2));
ASSERT_SUCCESS(set_instance_field(runtime, i1, k1, i3));
ASSERT_SUCCESS(set_instance_field(runtime, i2, k1, i3));
ASSERT_SUCCESS(set_instance_field(runtime, i3, k0, i1));
value_t d1 = transcode_plankton(runtime, NULL, NULL, i1);
value_t d2 = get_instance_field(d1, k0);
value_t d3 = get_instance_field(d1, k1);
ASSERT_NSAME(d1, d2);
ASSERT_NSAME(d1, d3);
ASSERT_SAME(d3, get_instance_field(d2, k1));
ASSERT_SAME(d1, get_instance_field(d3, k0));
DISPOSE_RUNTIME();
}
void CTestAsyncSuiteAssert::TestAssertSame()
/**
* TestAssertSame
*/
{
INFO_PRINTF1(_L("Running AsyncSuiteAssert:AssertSame"));
CTestConfig* aPtr = NULL;
ASSERT_SAME( aPtr, &iConfig );
}
TEST(tagged, float_32) {
ASSERT_EQ(sizeof(uint32_t), sizeof(float32_t));
value_t one = new_float_32(1.0);
ASSERT_TRUE(get_float_32_value(one) == 1.0);
value_t zero = new_float_32(0.0);
ASSERT_TRUE(get_float_32_value(zero) == 0.0);
value_t minus_one = new_float_32(-1.0);
ASSERT_TRUE(get_float_32_value(minus_one) == -1.0);
ASSERT_VALEQ(equal(), value_ordering_compare(one, one));
ASSERT_VALEQ(equal(), value_ordering_compare(zero, zero));
ASSERT_VALEQ(equal(), value_ordering_compare(minus_one, minus_one));
ASSERT_VALEQ(less_than(), value_ordering_compare(minus_one, zero));
ASSERT_VALEQ(less_than(), value_ordering_compare(zero, one));
ASSERT_VALEQ(greater_than(), value_ordering_compare(zero, minus_one));
ASSERT_VALEQ(greater_than(), value_ordering_compare(one, zero));
value_t nan = float_32_nan();
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, nan));
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, one));
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, zero));
ASSERT_VALEQ(unordered(), value_ordering_compare(zero, nan));
ASSERT_VALEQ(unordered(), value_ordering_compare(one, nan));
ASSERT_SAME(nan, nan);
value_t inf = float_32_infinity();
value_t minf = float_32_minus_infinity();
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, inf));
ASSERT_VALEQ(unordered(), value_ordering_compare(inf, nan));
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, minf));
ASSERT_VALEQ(unordered(), value_ordering_compare(minf, nan));
ASSERT_VALEQ(less_than(), value_ordering_compare(one, inf));
ASSERT_VALEQ(greater_than(), value_ordering_compare(inf, one));
ASSERT_VALEQ(greater_than(), value_ordering_compare(one, minf));
ASSERT_VALEQ(less_than(), value_ordering_compare(minf, one));
ASSERT_VALEQ(equal(), value_ordering_compare(inf, inf));
ASSERT_VALEQ(greater_than(), value_ordering_compare(inf, minf));
ASSERT_VALEQ(less_than(), value_ordering_compare(minf, inf));
ASSERT_TRUE(is_float_32_nan(nan));
ASSERT_FALSE(is_float_32_nan(minus_one));
ASSERT_FALSE(is_float_32_nan(zero));
ASSERT_FALSE(is_float_32_nan(one));
ASSERT_FALSE(is_float_32_nan(inf));
ASSERT_FALSE(is_float_32_nan(minf));
ASSERT_FALSE(is_float_32_finite(nan));
ASSERT_TRUE(is_float_32_finite(minus_one));
ASSERT_TRUE(is_float_32_finite(zero));
ASSERT_TRUE(is_float_32_finite(one));
ASSERT_FALSE(is_float_32_finite(inf));
ASSERT_FALSE(is_float_32_finite(minf));
}
TEST(plankton, references) {
CREATE_RUNTIME();
value_t i0 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species));
value_t i1 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species));
value_t i2 = new_heap_instance(runtime, ROOT(runtime, empty_instance_species));
value_t array = new_heap_array(runtime, 6);
set_array_at(array, 0, i0);
set_array_at(array, 1, i2);
set_array_at(array, 2, i0);
set_array_at(array, 3, i1);
set_array_at(array, 4, i2);
set_array_at(array, 5, i1);
value_t decoded = check_plankton(runtime, array);
ASSERT_SAME(get_array_at(decoded, 0), get_array_at(decoded, 2));
ASSERT_NSAME(get_array_at(decoded, 0), get_array_at(decoded, 1));
ASSERT_SAME(get_array_at(decoded, 1), get_array_at(decoded, 4));
ASSERT_NSAME(get_array_at(decoded, 1), get_array_at(decoded, 3));
ASSERT_SAME(get_array_at(decoded, 3), get_array_at(decoded, 5));
DISPOSE_RUNTIME();
}
TEST(tagged, score_successor) {
ASSERT_SAME(new_score(scEq, 1), get_score_successor(new_score(scEq, 0)));
ASSERT_SAME(new_score(scEq, 2), get_score_successor(new_score(scEq, 1)));
ASSERT_SAME(new_score(scEq, 0xFFFFFFFF), get_score_successor(new_score(scEq, 0xFFFFFFFE)));
ASSERT_SAME(new_score(scIs, 1), get_score_successor(new_score(scIs, 0)));
ASSERT_SAME(new_score(scIs, 2), get_score_successor(new_score(scIs, 1)));
ASSERT_SAME(new_score(scIs, 0xFFFFFFFF), get_score_successor(new_score(scIs, 0xFFFFFFFE)));
}
