int
main (int argc, char *argv[])
{
const char *result;
const char *file_name;
int i;
test_glob_type ();
test_aliasing ();
test_subclassing ();
test_matches ();
test_icons ();
for (i = 1; i < argc; i++)
{
file_name = argv[i];
result = xdg_mime_get_mime_type_for_file (file_name, NULL);
printf ("File \"%s\" has a mime-type of %s\n", file_name, result);
}
#if 0
xdg_mime_dump ();
#endif
return 0;
}
void llsdutil_object::test<9>()
{
set_test_name("llsd_matches");
// for this test, construct a map of all possible LLSD types
LLSD map;
map.insert("empty", LLSD());
map.insert("Boolean", LLSD::Boolean());
map.insert("Integer", LLSD::Integer(0));
map.insert("Real", LLSD::Real(0.0));
map.insert("String", LLSD::String("bah"));
map.insert("NumString", LLSD::String("1"));
map.insert("UUID", LLSD::UUID());
map.insert("Date", LLSD::Date());
map.insert("URI", LLSD::URI());
map.insert("Binary", LLSD::Binary());
map.insert("Map", LLSD().with("foo", LLSD()));
// Only an empty array can be constructed on the fly
LLSD array;
array.append(LLSD());
map.insert("Array", array);
// These iterators are declared outside our various for loops to avoid
// fatal MSVC warning: "I used to be broken, but I'm all better now!"
LLSD::map_const_iterator mi, mend(map.endMap());
/*-------------------------- llsd_matches --------------------------*/
// empty prototype matches anything
for (mi = map.beginMap(); mi != mend; ++mi)
{
ensure_equals(std::string("empty matches ") + mi->first, llsd_matches(LLSD(), mi->second), "");
}
LLSD proto_array, data_array;
for (int i = 0; i < 3; ++i)
{
proto_array.append(LLSD());
data_array.append(LLSD());
}
// prototype array matches only array
for (mi = map.beginMap(); mi != mend; ++mi)
{
ensure(std::string("array doesn't match ") + mi->first,
! llsd_matches(proto_array, mi->second).empty());
}
// data array must be at least as long as prototype array
proto_array.append(LLSD());
ensure_equals("data array too short", llsd_matches(proto_array, data_array),
"Array size 4 required instead of Array size 3");
data_array.append(LLSD());
ensure_equals("data array just right", llsd_matches(proto_array, data_array), "");
data_array.append(LLSD());
ensure_equals("data array longer", llsd_matches(proto_array, data_array), "");
// array element matching
data_array[0] = LLSD::String();
ensure_equals("undefined prototype array entry", llsd_matches(proto_array, data_array), "");
proto_array[0] = LLSD::Binary();
ensure_equals("scalar prototype array entry", llsd_matches(proto_array, data_array),
"[0]: Binary required instead of String");
data_array[0] = LLSD::Binary();
ensure_equals("matching prototype array entry", llsd_matches(proto_array, data_array), "");
// build a coupla maps
LLSD proto_map, data_map;
data_map["got"] = LLSD();
data_map["found"] = LLSD();
for (LLSD::map_const_iterator dmi(data_map.beginMap()), dmend(data_map.endMap());
dmi != dmend; ++dmi)
{
proto_map[dmi->first] = dmi->second;
}
proto_map["foo"] = LLSD();
proto_map["bar"] = LLSD();
// prototype map matches only map
for (mi = map.beginMap(); mi != mend; ++mi)
{
ensure(std::string("map doesn't match ") + mi->first,
! llsd_matches(proto_map, mi->second).empty());
}
// data map must contain all keys in prototype map
std::string error(llsd_matches(proto_map, data_map));
ensure_contains("missing keys", error, "missing keys");
ensure_contains("missing foo", error, "foo");
ensure_contains("missing bar", error, "bar");
ensure_does_not_contain("found found", error, "found");
ensure_does_not_contain("got got", error, "got");
data_map["bar"] = LLSD();
error = llsd_matches(proto_map, data_map);
ensure_contains("missing foo", error, "foo");
ensure_does_not_contain("got bar", error, "bar");
data_map["foo"] = LLSD();
ensure_equals("data map just right", llsd_matches(proto_map, data_map), "");
data_map["extra"] = LLSD();
ensure_equals("data map with extra", llsd_matches(proto_map, data_map), "");
// map element matching
data_map["foo"] = LLSD::String();
ensure_equals("undefined prototype map entry", llsd_matches(proto_map, data_map), "");
proto_map["foo"] = LLSD::Binary();
ensure_equals("scalar prototype map entry", llsd_matches(proto_map, data_map),
"['foo']: Binary required instead of String");
data_map["foo"] = LLSD::Binary();
ensure_equals("matching prototype map entry", llsd_matches(proto_map, data_map), "");
// String
{
static const char* matches[] = { "String", "NumString", "Boolean", "Integer",
"Real", "UUID", "Date", "URI" };
test_matches("String", map, boost::begin(matches), boost::end(matches));
}
// Boolean, Integer, Real
static const char* numerics[] = { "Boolean", "Integer", "Real" };
for (const char **ni = boost::begin(numerics), **nend = boost::end(numerics);
ni != nend; ++ni)
{
static const char* matches[] = { "Boolean", "Integer", "Real", "String", "NumString" };
test_matches(*ni, map, boost::begin(matches), boost::end(matches));
}
// UUID
{
static const char* matches[] = { "UUID", "String", "NumString" };
test_matches("UUID", map, boost::begin(matches), boost::end(matches));
}
// Date
{
static const char* matches[] = { "Date", "String", "NumString" };
test_matches("Date", map, boost::begin(matches), boost::end(matches));
}
// URI
{
static const char* matches[] = { "URI", "String", "NumString" };
test_matches("URI", map, boost::begin(matches), boost::end(matches));
}
// Binary
{
static const char* matches[] = { "Binary" };
test_matches("Binary", map, boost::begin(matches), boost::end(matches));
}
/*-------------------------- llsd_equals ---------------------------*/
// Cross-product of each LLSD type with every other
for (LLSD::map_const_iterator lmi(map.beginMap()), lmend(map.endMap());
lmi != lmend; ++lmi)
{
for (LLSD::map_const_iterator rmi(map.beginMap()), rmend(map.endMap());
rmi != rmend; ++rmi)
{
// Name this test based on the map keys naming the types of
// interest, e.g "String::Integer".
// We expect the values (xmi->second) to be equal if and only
// if the type names (xmi->first) are equal.
ensure(STRINGIZE(lmi->first << "::" << rmi->first),
bool(lmi->first == rmi->first) ==
bool(llsd_equals(lmi->second, rmi->second)));
}
}
// Array cases
LLSD rarray;
rarray.append(1.0);
rarray.append(2);
rarray.append("3");
LLSD larray(rarray);
ensure("llsd_equals(equal arrays)", llsd_equals(larray, rarray));
rarray[2] = "4";
ensure("llsd_equals(different [2])", ! llsd_equals(larray, rarray));
rarray = larray;
rarray.append(LLSD::Date());
ensure("llsd_equals(longer right array)", ! llsd_equals(larray, rarray));
rarray = larray;
rarray.erase(2);
ensure("llsd_equals(shorter right array)", ! llsd_equals(larray, rarray));
// Map cases
LLSD rmap;
rmap["San Francisco"] = 65;
rmap["Phoenix"] = 92;
rmap["Boston"] = 77;
LLSD lmap(rmap);
ensure("llsd_equals(equal maps)", llsd_equals(lmap, rmap));
rmap["Boston"] = 80;
ensure("llsd_equals(different [\"Boston\"])", ! llsd_equals(lmap, rmap));
rmap = lmap;
rmap["Atlanta"] = 95;
ensure("llsd_equals(superset right map)", ! llsd_equals(lmap, rmap));
rmap = lmap;
lmap["Seattle"] = 72;
ensure("llsd_equals(superset left map)", ! llsd_equals(lmap, rmap));
}
