void test_group<test_data>::object::test<2>() {
set_test_name("Test adding valid key-pointers");
node.set_leftmost_pointer(0);
node.insert_key_in_order(100, 1);
node.insert_key_in_order(200, 2);
node.insert_key_in_order(50, 3);
ensure_equals(node.get_left_pointer_of(50), 0);
ensure_equals(node.get_right_pointer_of(50), 3);
ensure_equals(node.get_left_pointer_of(100), 3);
ensure_equals(node.get_right_pointer_of(100), 1);
ensure_equals(node.get_left_pointer_of(200), 1);
ensure_equals(node.get_right_pointer_of(200), 2);
}
void test_group<test_data>::object::test<3>() {
set_test_name("Test adding duplicate key-pointers");
node.insert_key_in_order(50, 1);
node.insert_key_in_order(100, 2);
node.insert_key_in_order(150, 3);
node.insert_key_in_order(250, 4);
try {
node.insert_key_in_order(150, 5);
fail("Failed to detect duplicate key-pointer");
} catch (duplicate &o) {
}
}
void object::test<4>()
{
set_test_name("Javascript Test 3: window.setInterval()");
canvas->startWithCode("window.setInterval(function() { console.log(\"Hello, World!\"); });");
ensure(canvas->lastLogEntry() == "");
canvas->paint(0);
canvas->paint(0);
// After we have painter two times, we should have two "Hello, World!" messages in the history
ensure(canvas->lastLogEntry() == "Hello, World!");
ensure(canvas->lastLogEntry() == "Hello, World!");
ensure(canvas->lastLogEntry() == "");
}
void object::test<5>()
{
set_test_name("Test LLMediaEntry::asLLSD() -> LLMediaEntry::fromLLSD()");
LLMediaEntry entry1, entry2;
// Add a whitelist to entry2
std::vector<std::string> whitelist;
whitelist.push_back("*.example.com");
entry2.setWhiteList(whitelist);
// Render entry1 (which has no whitelist) as an LLSD
LLSD sd;
entry1.asLLSD(sd);
// "read" that LLSD into entry 2
entry2.fromLLSD(sd);
ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, entry2.asLLSD());
}
void AsString_object::test<5>()
{
set_test_name("Equality test 3");
AsString_ref str1 = ASL("This is string");
AsString_ref str2 = AS_NULL;
AsString_ref str3 = AS_NULL;
bool succeed = true;
succeed = succeed && str1 != str2;
succeed = succeed && str2 != str1;
succeed = succeed && str2 == str3;
ensure(succeed);
}
void object::test<2>()
{
set_test_name("checks attempt to run test/tests in unexistent group");
try
{
tr.run_tests("unexistent");
fail("expected no_such_group");
}
catch (const no_such_group&)
{
// as expected
}
try
{
test_result r;
tr.run_test("unexistent", 1, r);
fail("expected tut::no_such_group");
}
catch (const no_such_group& )
{
// as expected
}
try
{
tr.set_callback(&callback);
tr.run_tests("unexistent");
fail("expected tut::no_such_group");
}
catch (const no_such_group&)
{
// as expected
}
try
{
tr.set_callback(&callback);
test_result r;
tr.run_test("unexistent", 1, r);
fail("expected tut::no_such_group");
}
catch (const no_such_group&)
{
// as expected
}
}
void object::test<11>()
{
set_test_name("Test to make sure both setWhiteList() functions behave the same");
// Test a valid list
std::vector<std::string> whitelist, empty;
LLSD whitelist_llsd;
whitelist.push_back(std::string(URL_OK));
whitelist_llsd.append(std::string(URL_OK));
LLMediaEntry entry1, entry2;
ensure(get_test_name() + " setWhiteList(s) don't match",
entry1.setWhiteList(whitelist) == LSL_STATUS_OK &&
entry2.setWhiteList(whitelist_llsd)== LSL_STATUS_OK );
ensure(get_test_name() + " failed",
entry1.getWhiteList() == entry2.getWhiteList());
}
void fixture::test<1>()
{
set_test_name("detach_state");
pthreadxx::thread_attribute attribute;
ensure_equals("default state", attribute.detach_state(),
PTHREAD_CREATE_JOINABLE);
attribute.detach_state(PTHREAD_CREATE_DETACHED);
ensure_equals("set detached state", attribute.detach_state(),
PTHREAD_CREATE_DETACHED);
attribute.detach_state(PTHREAD_CREATE_JOINABLE);
ensure_equals("set joinable state", attribute.detach_state(),
PTHREAD_CREATE_JOINABLE);
}
void AsString_object::test<13>()
{
set_test_name("replace test");
AsString_ref str1 = ASL("This is string");
bool succeed = true;
succeed = succeed && str1->replace(ASL(" is "), ASL("-")) == ASL("This-string");
succeed = succeed && str1->replace(ASL(" is "), ASL(" is a long ")) == ASL("This is a long string");
succeed = succeed && str1->replace(ASL(" is string"), ASL("")) == ASL("This");
succeed = succeed && str1->replace(ASL("This is "), ASL("")) == ASL("string");
succeed = succeed && str1->replace(ASL("This is string"), ASL("")) == ASL("");
succeed = succeed && str1->replace(ASL("This is string!"), ASL("")) == ASL("This is string");
succeed = succeed && str1->replace(ASL("is string!"), ASL("")) == ASL("This is string");
ensure(succeed);
}
void TestRegistry::test<1>()
{
set_test_name("RotateAboutX (3x3 matrix)");
a3f[0] = 2.0f; a3f[3] = 5.0f; a3f[6] = 8.0f;
a3f[1] = 3.0f; a3f[4] = 6.0f; a3f[7] = 9.0f;
a3f[2] = 4.0f; a3f[5] = 7.0f; a3f[8] = 10.0f;
degrees = 123.4f;
radians = toRadians(degrees);
c = std::cos(radians);
s = std::sin(radians);
jship::Hazmat::RotateAboutX(a3f, radians, b3f);
DOUBLES_EQUAL(a3f[ 0], 2.0, 1e-5);
DOUBLES_EQUAL(a3f[ 1], 3.0, 1e-5);
DOUBLES_EQUAL(a3f[ 2], 4.0, 1e-5);
DOUBLES_EQUAL(a3f[ 3], 5.0, 1e-5);
DOUBLES_EQUAL(a3f[ 4], 6.0, 1e-5);
DOUBLES_EQUAL(a3f[ 5], 7.0, 1e-5);
DOUBLES_EQUAL(a3f[ 6], 8.0, 1e-5);
DOUBLES_EQUAL(a3f[ 7], 9.0, 1e-5);
DOUBLES_EQUAL(a3f[ 8], 10.0, 1e-5);
DOUBLES_EQUAL(b3f[ 0], 2.0f, 1e-5);
DOUBLES_EQUAL(b3f[ 1], 3.0f * c - 4.0f * s, 1e-5);
DOUBLES_EQUAL(b3f[ 2], 4.0f * c + 3.0f * s, 1e-5);
DOUBLES_EQUAL(b3f[ 3], 5.0f, 1e-5);
DOUBLES_EQUAL(b3f[ 4], 6.0f * c - 7.0f * s, 1e-5);
DOUBLES_EQUAL(b3f[ 5], 7.0f * c + 6.0f * s, 1e-5);
DOUBLES_EQUAL(b3f[ 6], 8.0f, 1e-5);
DOUBLES_EQUAL(b3f[ 7], 9.0f * c - 10.0f * s, 1e-5);
DOUBLES_EQUAL(b3f[ 8], 10.0f * c + 9.0f * s, 1e-5);
jship::Hazmat::RotateAboutX(a3f, radians, a3f);
DOUBLES_EQUAL(a3f[ 0], 2.0f, 1e-5);
DOUBLES_EQUAL(a3f[ 1], 3.0f * c - 4.0f * s, 1e-5);
DOUBLES_EQUAL(a3f[ 2], 4.0f * c + 3.0f * s, 1e-5);
DOUBLES_EQUAL(a3f[ 3], 5.0f, 1e-5);
DOUBLES_EQUAL(a3f[ 4], 6.0f * c - 7.0f * s, 1e-5);
DOUBLES_EQUAL(a3f[ 5], 7.0f * c + 6.0f * s, 1e-5);
DOUBLES_EQUAL(a3f[ 6], 8.0f, 1e-5);
DOUBLES_EQUAL(a3f[ 7], 9.0f * c - 10.0f * s, 1e-5);
DOUBLES_EQUAL(a3f[ 8], 10.0f * c + 9.0f * s, 1e-5);
}
void object::test<3>()
{
set_test_name("checks no_throw");
try
{
ensure_NO_THROW( skip() );
throw std::runtime_error("no_throw doesn't work");
}
catch (const failure& ex)
{
if (std::string(ex.what()).find("skip()") == std::string::npos )
{
fail("no_throw doesn't contain proper message");
}
}
}
void object::test<1>()
{
set_test_name("checks throw");
try
{
ensure_THROW( foo(), bar_exception );
throw std::runtime_error("throw doesn't work");
}
catch (const failure& ex)
{
if (std::string(ex.what()).find("foo()") == std::string::npos )
{
fail("throw doesn't contain proper message");
}
}
}
void object::test<5>()
{
set_test_name("checks throw std::exception");
try
{
ensure_THROW( noop(), std::exception );
fail("throw doesn't work");
}
catch (const failure& ex)
{
if (std::string(ex.what()).find("noop()") == std::string::npos )
{
fail("throw doesn't contain proper message");
}
}
}
void processor_object_t::test<1>()
{
set_test_name("LLProcessorInfo regression test");
LLProcessorInfo pi;
F64 freq = pi.getCPUFrequency();
//bool sse = pi.hasSSE();
//bool sse2 = pi.hasSSE2();
//bool alitvec = pi.hasAltivec();
std::string family = pi.getCPUFamilyName();
std::string brand = pi.getCPUBrandName();
//std::string steam = pi.getCPUFeatureDescription();
ensure_not_equals("Unknown Brand name", brand, "Unknown");
ensure_not_equals("Unknown Family name", family, "Unknown");
ensure("Reasonable CPU Frequency > 100 && < 10000", freq > 100 && freq < 10000);
}
void object::test<1>() {
static int frame = 0;
set_test_name("Initialize network environment");
elf::net_listen(0, "test_server", "localhost", 6670);
elf::net_connect(0, "test_client", "localhost", 6670);
while (true) {
elf::net_proc();
usleep(50000);
if (++frame % 20 == 0) {
putchar('.');
fflush(stdout);
}
}
ensure(true);
}
void AsString_object::test<8>()
{
set_test_name("lastIndexOf test");
AsString_ref str1 = ASL("This is string");
bool succeed = true;
succeed = succeed && str1->lastIndexOf(ASL(" is ")) == 4;
succeed = succeed && str1->lastIndexOf(ASL(" iz ")) == -1;
succeed = succeed && str1->lastIndexOf(ASL(" string")) == 7;
succeed = succeed && str1->lastIndexOf(ASL("This ")) == 0;
succeed = succeed && str1->lastIndexOf(ASL("This "), 1) == -1;
succeed = succeed && str1->lastIndexOf(ASL("is"), 2) == 2;
succeed = succeed && str1->lastIndexOf(ASL("is"), 3) == 5;
succeed = succeed && str1->lastIndexOf(ASL("stra"), 3) == -1;
ensure(succeed);
}
void llprimitive_object_t::test<6>()
{
set_test_name("Test setVolume creation of new NOT-unique volume.");
LLPrimitive primitive;
LLVolumeParams params;
// Make sure volume starts off null
ensure(primitive.getVolume() == NULL);
// Make sure we have no texture entries before setting the volume
ensure_equals(primitive.getNumTEs(), 0);
// Test that GEOMETRY has not been flagged as changed.
ensure(!primitive.isChanged(LLXform::GEOMETRY));
// Make sure setVolume returns true
ensure(primitive.setVolume(params, 0, false) == TRUE);
LLVolume* new_volume = primitive.getVolume();
// make sure new volume was actually created
ensure(new_volume != NULL);
// Make sure that now that we've set the volume we have texture entries
ensure_not_equals(primitive.getNumTEs(), 0);
// Make sure that the number of texture entries equals the number of faces in the volume (should be 6)
ensure_equals(new_volume->getNumFaces(), 6);
ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces());
// Test that GEOMETRY has been flagged as changed.
ensure(primitive.isChanged(LLXform::GEOMETRY));
// Run it twice to make sure it doesn't create a different one if params are the same
ensure(primitive.setVolume(params, 0, false) == FALSE);
ensure(new_volume == primitive.getVolume());
// Change the param definition and try setting it again.
params.setRevolutions(4);
ensure(primitive.setVolume(params, 0, false) == TRUE);
// Ensure that we now have a different volume
ensure(new_volume != primitive.getVolume());
}
void object::test<3>()
{
set_test_name("function names");
setCode(),
"module Asia;",
"_() -> void { }",
" a() -> void { }",
" a15() -> void { }",
" _123135() -> void { }",
" aAa() -> void { }",
" _64_characters__________________________________________________() -> void { }";
parse();
ensure_success();
ensure_equals("6 declarations", module->decls.size(), 6u);
ensure("function", module->decls[0].type() == typeid(sl::cst::Function));
ensure("function", module->decls[1].type() == typeid(sl::cst::Function));
ensure("function", module->decls[2].type() == typeid(sl::cst::Function));
ensure("function", module->decls[3].type() == typeid(sl::cst::Function));
ensure("function", module->decls[4].type() == typeid(sl::cst::Function));
ensure("function", module->decls[5].type() == typeid(sl::cst::Function));
sl::cst::Function& f0 = boost::get<sl::cst::Function>(module->decls[0]);
sl::cst::Function& f1 = boost::get<sl::cst::Function>(module->decls[1]);
sl::cst::Function& f2 = boost::get<sl::cst::Function>(module->decls[2]);
sl::cst::Function& f3 = boost::get<sl::cst::Function>(module->decls[3]);
sl::cst::Function& f4 = boost::get<sl::cst::Function>(module->decls[4]);
sl::cst::Function& f5 = boost::get<sl::cst::Function>(module->decls[5]);
ensure("position 0", f0.name.pos == sl::FilePosition("", 2, 1));
ensure_equals("name 0", f0.name.str, "_");
ensure("position 1", f1.name.pos == sl::FilePosition("", 3, 2));
ensure_equals("name 1", f1.name.str, "a");
ensure("position 2", f2.name.pos == sl::FilePosition("", 4, 3));
ensure_equals("name 2", f2.name.str, "a15");
ensure("position 3", f3.name.pos == sl::FilePosition("", 5, 4));
ensure_equals("name 3", f3.name.str, "_123135");
ensure("position 4", f4.name.pos == sl::FilePosition("", 6, 5));
ensure_equals("name 4", f4.name.str, "aAa");
ensure("position 5", f5.name.pos == sl::FilePosition("", 7, 6));
ensure_equals("name 5", f5.name.str, "_64_characters__________________________________________________");
}
void filter_object::test<4>()
{
set_test_name("LLEventTimeout::errorAfter()");
WrapLLErrs capture;
LLEventPump& driver(pumps.obtain("driver"));
TestEventTimeout filter(driver);
listener0.reset(0);
LLTempBoundListener temp1(
listener0.listenTo(filter));
filter.errorAfter(20, "timeout");
// Okay, (fake) timer is ticking. 'filter' can only sense the timer
// when we pump mainloop. Do that right now to take the logic path
// before either the anticipated event arrives or the timer expires.
mainloop.post(17);
check_listener("no timeout 1", listener0, LLSD(0));
// Expected event arrives...
driver.post(1);
check_listener("event passed thru", listener0, LLSD(1));
// Should have canceled the timer. Verify that by asserting that the
// time has expired, then pumping mainloop again.
filter.forceTimeout();
mainloop.post(17);
check_listener("no timeout 2", listener0, LLSD(1));
// Set timer again.
filter.errorAfter(20, "timeout");
// Now let the timer expire.
filter.forceTimeout();
// Notice the timeout.
std::string threw;
try
{
mainloop.post(17);
}
catch (const WrapLLErrs::FatalException& e)
{
threw = e.what();
}
ensure_contains("errorAfter() timeout exception", threw, "timeout");
// Timing out cancels the timer. Verify that.
listener0.reset(0);
filter.forceTimeout();
mainloop.post(17);
check_listener("no timeout 3", listener0, LLSD(0));
}
void object::test<1>()
{
set_test_name("request validation");
WrapLL_ERRS capture;
LLSD request;
request["uri"] = uri;
std::string threw;
try
{
pumps.obtain("LLXMLRPCTransaction").post(request);
}
catch (const WrapLL_ERRS::FatalException& e)
{
threw = e.what();
}
ensure_contains("threw exception", threw, "missing params");
ensure_contains("identified missing", threw, "method");
ensure_contains("identified missing", threw, "reply");
}
void fixture::test<3>()
{
data d;
set_test_name("equal operator");
pthreadxx::thread t1, t2;
ensure("invalid threads are equal", t1 == t2);
ensure_not("invalid threads are not unequal", t1 != t2);
ensure("self compare are equal", t1 == t1);
ensure_not("self compare are not unequal", t1 != t1);
t1=t1;
ensure("self compare are equal", t1 == t1);
ensure_not("self compare are not unequal", t1 != t1);
t1 = pthreadxx::thread::create(d);
ensure_not("threads are unequal", t1 == t2);
ensure("invalid threads are not equal", t1 != t2);
t2 = pthreadxx::thread::create(d);
ensure_not("threads are unequal", t1 == t2);
ensure("invalid threads are not equal", t1 != t2);
}
void fixture::test<4>()
{
set_test_name("test add multiple node");
algorithm::const_hash hash;
int count = random (1, 20);
for (int i = 0; i < count; ++i)
{
int weight = random(100, 200);
hash.add(i, weight);
ensure_equals("hash weight", hash.weight(i), weight);
}
ensure_equals("hash count", hash.alive_set().size(), count);
int loop = random (200, 300);
for (int i = 0; i < loop; ++i)
{
ensure("node in alive_set",
hash.alive_set().count(hash.hash(random())) == 1);
}
}
void object::test<13>()
{
set_test_name("Test to make sure both setWhiteList() functions behave the same");
// Test an invalid list, too many
std::vector<std::string> whitelist, empty;
LLSD whitelist_llsd;
for (int i=0; i < LLMediaEntry::MAX_WHITELIST_SIZE+1; i++) {
whitelist.push_back("Q");
whitelist_llsd.append("Q");
}
LLMediaEntry entry1, entry2;
ensure(get_test_name() + " invalid result",
entry1.setWhiteList(whitelist) == LSL_STATUS_BOUNDS_ERROR &&
entry2.setWhiteList(whitelist_llsd) == LSL_STATUS_BOUNDS_ERROR);
ensure(get_test_name() + " failed",
empty == entry1.getWhiteList() &&
empty == entry2.getWhiteList());
}
void TestRegistry::test<2>()
{
set_test_name("Cofactor (3x3 matrix)");
// Determinant of this matrix is -2
a3f[0] = 5.0f; a3f[3] = 6.0f; a3f[6] = 3.0f;
a3f[1] = 4.0f; a3f[4] = 3.0f; a3f[7] = 1.0f;
a3f[2] = 1.0f; a3f[5] = 4.0f; a3f[8] = 3.0f;
jship::Hazmat::Cofactor(a3f, b3f);
DOUBLES_EQUAL(a3f[0], 5.0, 1e-5);
DOUBLES_EQUAL(a3f[1], 4.0, 1e-5);
DOUBLES_EQUAL(a3f[2], 1.0, 1e-5);
DOUBLES_EQUAL(a3f[3], 6.0, 1e-5);
DOUBLES_EQUAL(a3f[4], 3.0, 1e-5);
DOUBLES_EQUAL(a3f[5], 4.0, 1e-5);
DOUBLES_EQUAL(a3f[6], 3.0, 1e-5);
DOUBLES_EQUAL(a3f[7], 1.0, 1e-5);
DOUBLES_EQUAL(a3f[8], 3.0, 1e-5);
DOUBLES_EQUAL(b3f[0], 5.0, 1e-5);
DOUBLES_EQUAL(b3f[1], -6.0, 1e-5);
DOUBLES_EQUAL(b3f[2], -3.0, 1e-5);
DOUBLES_EQUAL(b3f[3], -11.0, 1e-5);
DOUBLES_EQUAL(b3f[4], 12.0, 1e-5);
DOUBLES_EQUAL(b3f[5], 7.0, 1e-5);
DOUBLES_EQUAL(b3f[6], 13.0, 1e-5);
DOUBLES_EQUAL(b3f[7], -14.0, 1e-5);
DOUBLES_EQUAL(b3f[8], -9.0, 1e-5);
jship::Hazmat::Cofactor(a3f, a3f);
DOUBLES_EQUAL(a3f[0], 5.0, 1e-5);
DOUBLES_EQUAL(a3f[1], -6.0, 1e-5);
DOUBLES_EQUAL(a3f[2], -3.0, 1e-5);
DOUBLES_EQUAL(a3f[3], -11.0, 1e-5);
DOUBLES_EQUAL(a3f[4], 12.0, 1e-5);
DOUBLES_EQUAL(a3f[5], 7.0, 1e-5);
DOUBLES_EQUAL(a3f[6], 13.0, 1e-5);
DOUBLES_EQUAL(a3f[7], -14.0, 1e-5);
DOUBLES_EQUAL(a3f[8], -9.0, 1e-5);
}
void object::test<7>()
{
set_test_name("delete Unkeyed with outstanding instance_iter");
std::string what;
Unkeyed* unkeyed = new Unkeyed;
{
WrapLL_ERRS wrapper;
Unkeyed::instance_iter i(Unkeyed::beginInstances());
try
{
delete unkeyed;
}
catch (const WrapLL_ERRS::FatalException& e)
{
what = e.what();
}
}
ensure(! what.empty());
}
void object::test<6>()
{
set_test_name("delete Keyed with outstanding key_iter");
std::string what;
Keyed* keyed = new Keyed("one");
{
WrapLL_ERRS wrapper;
Keyed::key_iter i(Keyed::beginKeys());
try
{
delete keyed;
}
catch (const WrapLL_ERRS::FatalException& e)
{
what = e.what();
}
}
ensure(! what.empty());
}
void TestRegistry::test<2>()
{
set_test_name("Transpose (3x3 matrix)");
a3f[0] = 0.0f; a3f[3] = 3.0f; a3f[6] = 6.0f;
a3f[1] = 1.0f; a3f[4] = 4.0f; a3f[7] = 7.0f;
a3f[2] = 2.0f; a3f[5] = 5.0f; a3f[8] = 8.0f;
jship::Hazmat::Transpose(a3f, b3f);
DOUBLES_EQUAL(a3f[0], 0.0, 1e-5);
DOUBLES_EQUAL(a3f[1], 1.0, 1e-5);
DOUBLES_EQUAL(a3f[2], 2.0, 1e-5);
DOUBLES_EQUAL(a3f[3], 3.0, 1e-5);
DOUBLES_EQUAL(a3f[4], 4.0, 1e-5);
DOUBLES_EQUAL(a3f[5], 5.0, 1e-5);
DOUBLES_EQUAL(a3f[6], 6.0, 1e-5);
DOUBLES_EQUAL(a3f[7], 7.0, 1e-5);
DOUBLES_EQUAL(a3f[8], 8.0, 1e-5);
DOUBLES_EQUAL(b3f[0], 0.0, 1e-5);
DOUBLES_EQUAL(b3f[1], 3.0, 1e-5);
DOUBLES_EQUAL(b3f[2], 6.0, 1e-5);
DOUBLES_EQUAL(b3f[3], 1.0, 1e-5);
DOUBLES_EQUAL(b3f[4], 4.0, 1e-5);
DOUBLES_EQUAL(b3f[5], 7.0, 1e-5);
DOUBLES_EQUAL(b3f[6], 2.0, 1e-5);
DOUBLES_EQUAL(b3f[7], 5.0, 1e-5);
DOUBLES_EQUAL(b3f[8], 8.0, 1e-5);
jship::Hazmat::Transpose(a3f, a3f);
DOUBLES_EQUAL(a3f[0], 0.0, 1e-5);
DOUBLES_EQUAL(a3f[1], 3.0, 1e-5);
DOUBLES_EQUAL(a3f[2], 6.0, 1e-5);
DOUBLES_EQUAL(a3f[3], 1.0, 1e-5);
DOUBLES_EQUAL(a3f[4], 4.0, 1e-5);
DOUBLES_EQUAL(a3f[5], 7.0, 1e-5);
DOUBLES_EQUAL(a3f[6], 2.0, 1e-5);
DOUBLES_EQUAL(a3f[7], 5.0, 1e-5);
DOUBLES_EQUAL(a3f[8], 8.0, 1e-5);
}
void object::test<4>()
{
set_test_name("bad function names");
setCode(),
"module Asia;",
"bad+x() -> void { }";
parse();
ensure_failure(1);
setCode(),
"module Asia;",
"123() -> void { }";
parse();
ensure_failure(1);
}
void test_group<test_data>::object::test<7>() {
set_test_name("Test merging overflow");
// Cantidad máxima de pares clave-valor que entran en el nodo
int number_of_pairs =
(block_size - 3 * sizeof(int)) / (sizeof(int) + sizeof(int));
left_node.set_leftmost_pointer(0);
for (int i = 1; i < number_of_pairs; i++) {
left_node.insert_key_in_order(i * 10, i);
}
right_node.set_leftmost_pointer(0);
for (int i = 1; i < number_of_pairs; i++) {
right_node.insert_key_in_order(i * 10, i);
}
node_type::merge_result r = left_node.try_merge(&left_node, &right_node, 350);
ensure(!r.success);
}
void object::test<2>()
{
set_test_name("param types validation");
WrapLL_ERRS capture;
LLSD request;
request["uri"] = uri;
request["method"] = "hello";
request["reply"] = "reply";
LLSD& params(request["params"]);
params["who"]["specifically"] = "world"; // LLXMLRPCListener only handles scalar params
std::string threw;
try
{
pumps.obtain("LLXMLRPCTransaction").post(request);
}
catch (const WrapLL_ERRS::FatalException& e)
{
threw = e.what();
}
ensure_contains("threw exception", threw, "unknown type");
}
