00001 #include <boost/test/auto_unit_test.hpp>
00002
00003 #include <lang/csupport/standard_types.hh>
00004
00005 #include <test/testsuite.hh>
00006 #include <typelib/typemodel.hh>
00007 #include <typelib/typename.hh>
00008 #include <typelib/registry.hh>
00009 #include <typelib/typedisplay.hh>
00010 #include <typelib/registryiterator.hh>
00011 #include <typelib/pluginmanager.hh>
00012 using namespace Typelib;
00013
00014 BOOST_AUTO_TEST_CASE( test_typename_validation )
00015 {
00016 BOOST_CHECK(!isValidTypename("std::string", false));
00017 BOOST_CHECK(!isValidTypename("std::string", true));
00018 BOOST_CHECK(!isValidTypename("/std/string<double>", false));
00019 BOOST_CHECK(isValidTypename("/std/string</double>", false));
00020 BOOST_CHECK(isValidTypename("/std/string</double>", true));
00021 BOOST_CHECK(!isValidTypename("std/string<double>", false));
00022 BOOST_CHECK(isValidTypename("std/string</double>", false));
00023 BOOST_CHECK(!isValidTypename("std/string</double>", true));
00024
00025 BOOST_CHECK(isValidTypename("/std/string</double,9,/std/string>", true));
00026 BOOST_CHECK(isValidTypename("/std/string<3>", true));
00027
00028 BOOST_CHECK(isValidTypename("/double[3]", true));
00029 BOOST_CHECK(isValidTypename("/std/string</double[3]>", true));
00030 BOOST_CHECK(isValidTypename("/wrappers/Matrix</double,3,1>/Scalar", true));
00031 BOOST_CHECK(isValidTypename("/std/vector</wrappers/Matrix</double,3,1>>", true));
00032 BOOST_CHECK(isValidTypename("/std/vector</wrappers/Matrix</double,3,1>>[4]", true));
00033
00034 BOOST_CHECK(isValidTypename("s", false));
00035 BOOST_CHECK(!isValidTypename(":blabla", false));
00036
00037 BOOST_CHECK(isValidTypename("/std/map</std/string,/trigger/behaviour/Description,/std/less</std/string>,/std/allocator</std/pair</const std/basic_string</char,/std/char_traits</char>,/std/allocator</char>>,/trigger/behaviour/Description>>>", true));
00038 }
00039
00040 BOOST_AUTO_TEST_CASE( test_typename_is_in_namespace )
00041 {
00042 BOOST_CHECK(!isInNamespace("/A/B/Type" , "/A/C" , false));
00043 BOOST_CHECK(!isInNamespace("/A/B/Type" , "/A/C/" , false));
00044 BOOST_CHECK(!isInNamespace("/B/B/Type" , "/B/A" , false));
00045 BOOST_CHECK(!isInNamespace("/B/B/Type" , "/B/A/" , false));
00046 BOOST_CHECK(!isInNamespace("/A/B/Type" , "/A/B/C" , false));
00047 BOOST_CHECK(!isInNamespace("/A/B/Type" , "/A/B/C/" , false));
00048 BOOST_CHECK(!isInNamespace("/A/B/Type" , "/A/C" , true));
00049 BOOST_CHECK(!isInNamespace("/A/B/Type" , "/A/C/" , true));
00050 BOOST_CHECK(!isInNamespace("/B/B/Type" , "/B/A" , true));
00051 BOOST_CHECK(!isInNamespace("/B/B/Type" , "/B/A/" , true));
00052 BOOST_CHECK(!isInNamespace("/A/B/Type" , "/A/B/C" , true));
00053 BOOST_CHECK(!isInNamespace("/A/B/Type" , "/A/B/C/" , true));
00054
00055 BOOST_CHECK(!isInNamespace("/A/B/C/Type" , "/A/B" , false));
00056 BOOST_CHECK(!isInNamespace("/A/B/C/Type" , "/A/B/" , false));
00057 BOOST_CHECK( isInNamespace("/A/B/Type" , "/A/B" , false));
00058 BOOST_CHECK( isInNamespace("/A/B/Type" , "/A/B/" , false));
00059 BOOST_CHECK( isInNamespace("/A/B/C/Type" , "/A/B" , true));
00060 BOOST_CHECK( isInNamespace("/A/B/C/Type" , "/A/B/" , true));
00061 BOOST_CHECK( isInNamespace("/A/B/Type" , "/A/B" , true));
00062 BOOST_CHECK( isInNamespace("/A/B/Type" , "/A/B/" , true));
00063 }
00064
00065 BOOST_AUTO_TEST_CASE( test_nameSort )
00066 {
00067 BOOST_CHECK(!nameSort("/A/B/Type" , "/A/B/Type"));
00068
00069 BOOST_CHECK(nameSort("/A/B" , "/A/B/Type"));
00070 BOOST_CHECK(!nameSort("/A/B/Type" , "/A/B"));
00071
00072 BOOST_CHECK(nameSort("/A/A" , "/A/B/Type"));
00073 BOOST_CHECK(!nameSort("/A/B/Type" , "/A/A"));
00074
00075 BOOST_CHECK(nameSort("/A/B/Type" , "/AA"));
00076 BOOST_CHECK(!nameSort("/AA" , "/A/B/Type"));
00077
00078 BOOST_CHECK(nameSort("/A/B/Ty" , "/A/B/Type"));
00079 BOOST_CHECK(!nameSort("/A/B/Type" , "/A/B/Ty"));
00080 }
00081
00082 BOOST_AUTO_TEST_CASE( test_typename_manipulation )
00083 {
00084 BOOST_CHECK_EQUAL("/NS2/", getNormalizedNamespace("/NS2"));
00085 BOOST_CHECK_EQUAL("/NS2/", getNormalizedNamespace("/NS2/"));
00086 BOOST_CHECK_EQUAL("NS2/", getNormalizedNamespace("NS2/"));
00087 BOOST_CHECK_EQUAL("NS2/", getNormalizedNamespace("NS2"));
00088
00089 BOOST_CHECK_EQUAL("NS3/Test", getRelativeName("/NS2/NS3/Test", "/NS2"));
00090
00091 BOOST_CHECK_EQUAL("/NS2/NS3/", getNamespace("/NS2/NS3/Test"));
00092 BOOST_CHECK_EQUAL("/wrappers/Matrix</double,3,1>/", getNamespace("/wrappers/Matrix</double,3,1>/Scalar"));
00093 BOOST_CHECK_EQUAL("Scalar", getTypename("/wrappers/Matrix</double,3,1>/Scalar"));
00094 BOOST_CHECK_EQUAL("/wrappers/Matrix</double,3,1>/Gaussian</double,3>/", getNamespace("/wrappers/Matrix</double,3,1>/Gaussian</double,3>/Scalar"));
00095 BOOST_CHECK_EQUAL("Scalar", getTypename("/wrappers/Matrix</double,3,1>/Gaussian</double,3>/Scalar"));
00096 BOOST_CHECK_EQUAL("/std/", getNamespace("/std/vector</wrappers/Matrix</double,3,1>>"));
00097
00098 BOOST_CHECK_EQUAL("Test", getTypename("/NS2/NS3/Test"));
00099 BOOST_CHECK_EQUAL("Scalar", getTypename("/wrappers/Matrix</double,3,1>/Scalar"));
00100 BOOST_CHECK_EQUAL("vector</wrappers/Matrix</double,3,1>>", getTypename("/std/vector</wrappers/Matrix</double,3,1>>"));
00101 }
00102
00103 BOOST_AUTO_TEST_CASE( test_typename_path_to )
00104 {
00105 BOOST_CHECK_EQUAL("B/", getMinimalPathTo("/A/B/Type", "/A/C"));
00106 BOOST_CHECK_EQUAL("B/", getMinimalPathTo("/A/B/Type", "/A/C/"));
00107 BOOST_CHECK_EQUAL("/B/B/", getMinimalPathTo("/B/B/Type", "/B/A"));
00108 BOOST_CHECK_EQUAL("/B/B/", getMinimalPathTo("/B/B/Type", "/B/A/"));
00109 BOOST_CHECK_EQUAL("/A/B/", getMinimalPathTo("/A/B/Type", "/A/B/C"));
00110 BOOST_CHECK_EQUAL("/A/B/", getMinimalPathTo("/A/B/Type", "/A/B/C/"));
00111 BOOST_CHECK_EQUAL("C/", getMinimalPathTo("/A/B/C/Type", "/A/B"));
00112 BOOST_CHECK_EQUAL("C/", getMinimalPathTo("/A/B/C/Type", "/A/B/"));
00113 BOOST_CHECK_EQUAL("", getMinimalPathTo("/A/B/Type", "/A/B"));
00114 BOOST_CHECK_EQUAL("", getMinimalPathTo("/A/B/Type", "/A/B/"));
00115 BOOST_CHECK_EQUAL("/A/", getMinimalPathTo("/A/B", "/C/A"));
00116 }
00117
00118 BOOST_AUTO_TEST_CASE( test_registry_namespaces )
00119 {
00120
00121 Registry registry;
00122 registry.add( new Numeric("/NS1/Test", 1, Numeric::SInt) );
00123 registry.add( new Numeric("/NS2/Test", 2, Numeric::SInt) );
00124
00125 registry.setDefaultNamespace("/NS2");
00126 BOOST_REQUIRE_EQUAL("/NS2/Test", registry.getFullName("Test"));
00127 BOOST_REQUIRE_EQUAL("/NS2/NS3/Test", registry.getFullName("NS3/Test"));
00128 BOOST_REQUIRE_EQUAL("/Test", registry.getFullName("/Test"));
00129 registry.add( new Numeric("/NS2/NS3/Test", 3, Numeric::SInt) );
00130 registry.add( new Numeric("/Test", 4, Numeric::SInt) );
00131 registry.setDefaultNamespace("");
00132
00133 Numeric const* ns1, *ns2, *ns3, *ns;
00134 BOOST_REQUIRE(( ns1 = dynamic_cast<Numeric const*>(registry.get("/NS1/Test")) ));
00135 BOOST_REQUIRE(( ns2 = dynamic_cast<Numeric const*>(registry.get("/NS2/Test")) ));
00136 BOOST_REQUIRE(( ns3 = dynamic_cast<Numeric const*>(registry.get("/NS2/NS3/Test")) ));
00137 BOOST_REQUIRE(( ns = dynamic_cast<Numeric const*>(registry.get("/Test")) ));
00138
00139 BOOST_REQUIRE_EQUAL(1, ns1->getSize());
00140 BOOST_REQUIRE_EQUAL(2, ns2->getSize());
00141 BOOST_REQUIRE_EQUAL(3, ns3->getSize());
00142 BOOST_REQUIRE_EQUAL(4, ns->getSize());
00143
00144 { registry.setDefaultNamespace("/NS2");
00145 Type const* relative;
00146 BOOST_REQUIRE(( relative = registry.get("Test") ));
00147 BOOST_REQUIRE_EQUAL(relative, ns2);
00148 BOOST_REQUIRE(( relative = registry.get("NS3/Test") ));
00149 BOOST_REQUIRE_EQUAL(relative, ns3);
00150 BOOST_REQUIRE(( relative = registry.get("/Test") ));
00151 BOOST_REQUIRE_EQUAL(relative, ns);
00152 BOOST_REQUIRE(( relative = registry.get("/NS1/Test") ));
00153 BOOST_REQUIRE_EQUAL(relative, ns1);
00154 }
00155
00156 }
00157
00158 BOOST_AUTO_TEST_CASE( test_namespace_update_at_insertion )
00159 {
00160 Registry registry;
00161 registry.setDefaultNamespace("/A/B/B");
00162 registry.add( new Numeric("/A/B/B/Test", 3, Numeric::SInt) );
00163 BOOST_REQUIRE(( registry.get("Test") ));
00164 BOOST_REQUIRE(( registry.get("B/Test") ));
00165 BOOST_REQUIRE(( registry.get("B/B/Test") ));
00166 BOOST_REQUIRE(( registry.get("A/B/B/Test") ));
00167
00168 registry.add( new Numeric("/A/B/Test", 3, Numeric::SInt) );
00169 BOOST_REQUIRE(( registry.get("Test") ));
00170 BOOST_REQUIRE(( registry.get("B/Test") ));
00171 BOOST_REQUIRE(( registry.get("B/B/Test") ));
00172 BOOST_REQUIRE(( registry.get("A/B/B/Test") ));
00173 BOOST_REQUIRE(( registry.get("A/B/Test") ));
00174
00175 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/Test"), registry.get("Test"));
00176 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/Test"), registry.get("B/Test"));
00177
00178 registry.setDefaultNamespace("/A/B/B/B");
00179 registry.add( new Numeric("/A/B/B/B/Test", 3, Numeric::SInt) );
00180 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/B/Test"), registry.get("Test"));
00181 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/B/Test"), registry.get("B/Test"));
00182 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/B/Test"), registry.get("B/B/Test"));
00183 }
00184
00185 static void assert_registries_equal(Registry const& registry, Registry const& ref)
00186 {
00187 BOOST_REQUIRE_EQUAL(ref.size(), registry.size());
00188
00189 Registry::Iterator
00190 t_it = registry.begin(),
00191 t_end = registry.end(),
00192 r_it = ref.begin(),
00193 r_end = ref.end();
00194
00195 for (; t_it != t_end && r_it != r_end; ++t_it, ++r_it)
00196 {
00197 BOOST_REQUIRE_EQUAL(t_it.getName(), r_it.getName());
00198 BOOST_REQUIRE_EQUAL(t_it->getName(), r_it->getName());
00199 BOOST_REQUIRE_MESSAGE(t_it->isSame(*r_it), "definitions of " << t_it->getName() << " differ: " << *t_it << "\n" << *r_it);
00200 }
00201
00202 BOOST_REQUIRE(t_it == t_end);
00203 BOOST_REQUIRE(r_it == r_end);
00204 }
00205
00206 BOOST_AUTO_TEST_CASE( test_repositories_merge )
00207 {
00208 static const char* test_file = TEST_DATA_PATH("test_cimport.tlb");
00209
00210 utilmm::config_set config;
00211 PluginManager::self manager;
00212
00213 std::auto_ptr<Registry> ref( manager->load("tlb", test_file, config));
00214 Registry target;
00215 target.merge(*ref);
00216 assert_registries_equal(target, *ref);
00217
00218 target.merge(*ref);
00219 assert_registries_equal(target, *ref);
00220 }
00221
00222 BOOST_AUTO_TEST_CASE( test_array_auto_alias )
00223 {
00224 Registry registry;
00225 Typelib::CXX::addStandardTypes(registry);
00226 registry.alias("/int", "/A");
00227 registry.add(new Array(*registry.get("/int"), 10));
00228 BOOST_REQUIRE(registry.get("/A[10]"));
00229 BOOST_REQUIRE(*registry.get("/A[10]") == *registry.get("/int[10]"));
00230 registry.alias("/int", "/B");
00231 BOOST_REQUIRE(registry.get("/B[10]"));
00232 BOOST_REQUIRE(*registry.get("/B[10]") == *registry.get("/int[10]"));
00233 }
00234
00235 BOOST_AUTO_TEST_CASE( test_registry_merge_keeps_alias_persistent_flag )
00236 {
00237 Registry registry;
00238 Typelib::CXX::addStandardTypes(registry);
00239
00240 registry.alias("/int", "/Persistent", true);
00241 registry.alias("/int", "/Temporary", false);
00242 BOOST_REQUIRE(registry.get("/Persistent"));
00243 BOOST_REQUIRE(registry.find("/Persistent") != registry.end());
00244
00245 Registry target;
00246 target.merge(registry);
00247 { RegistryIterator it = target.find("/Persistent");
00248 BOOST_REQUIRE(it != target.end());
00249 BOOST_REQUIRE(it.isPersistent());
00250 }
00251
00252 { RegistryIterator it = target.find("/Temporary");
00253 BOOST_REQUIRE(it != target.end());
00254 BOOST_REQUIRE(!it.isPersistent());
00255 }
00256 }
00257
00258 BOOST_AUTO_TEST_CASE( test_registry_minimal_keeps_alias_persistent_flag )
00259 {
00260 Registry registry;
00261 Typelib::CXX::addStandardTypes(registry);
00262 Registry target;
00263 Typelib::CXX::addStandardTypes(target);
00264 target.alias("/int", "/Persistent", true);
00265 target.alias("/int", "/Temporary", false);
00266
00267 target.minimal(registry);
00268 { RegistryIterator it = target.find("/Persistent");
00269 BOOST_REQUIRE(it != target.end());
00270 BOOST_REQUIRE(it.isPersistent());
00271 }
00272
00273 { RegistryIterator it = target.find("/Temporary");
00274 BOOST_REQUIRE(it != target.end());
00275 BOOST_REQUIRE(!it.isPersistent());
00276 }
00277 }
00278
00279 BOOST_AUTO_TEST_CASE( test_registry_range )
00280 {
00281 Registry registry;
00282 Typelib::CXX::addStandardTypes(registry);
00283 registry.alias("/int", "/A/A", true);
00284 registry.alias("/int", "/A/C", true);
00285 registry.alias("/int", "/A/F", true);
00286 registry.alias("/int", "/A/B/A", true);
00287 registry.alias("/int", "/A/B/C", true);
00288 registry.alias("/int", "/A/B/F", true);
00289 registry.alias("/int", "/B/A", true);
00290 registry.alias("/int", "/B/C", true);
00291 registry.alias("/int", "/B/F", true);
00292
00293 BOOST_REQUIRE_EQUAL("/A/A", registry.begin("/A").getName());
00294 BOOST_REQUIRE_EQUAL("/B/A", registry.end("/A").getName());
00295 }
00296