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_typename_manipulation )
00066 {
00067 BOOST_CHECK_EQUAL("/NS2/", getNormalizedNamespace("/NS2"));
00068 BOOST_CHECK_EQUAL("/NS2/", getNormalizedNamespace("/NS2/"));
00069 BOOST_CHECK_EQUAL("NS2/", getNormalizedNamespace("NS2/"));
00070 BOOST_CHECK_EQUAL("NS2/", getNormalizedNamespace("NS2"));
00071
00072 BOOST_CHECK_EQUAL("NS3/Test", getRelativeName("/NS2/NS3/Test", "/NS2"));
00073
00074 BOOST_CHECK_EQUAL("/NS2/NS3/", getNamespace("/NS2/NS3/Test"));
00075 BOOST_CHECK_EQUAL("/wrappers/Matrix</double,3,1>/", getNamespace("/wrappers/Matrix</double,3,1>/Scalar"));
00076 BOOST_CHECK_EQUAL("Scalar", getTypename("/wrappers/Matrix</double,3,1>/Scalar"));
00077 BOOST_CHECK_EQUAL("/wrappers/Matrix</double,3,1>/Gaussian</double,3>/", getNamespace("/wrappers/Matrix</double,3,1>/Gaussian</double,3>/Scalar"));
00078 BOOST_CHECK_EQUAL("Scalar", getTypename("/wrappers/Matrix</double,3,1>/Gaussian</double,3>/Scalar"));
00079 BOOST_CHECK_EQUAL("/std/", getNamespace("/std/vector</wrappers/Matrix</double,3,1>>"));
00080
00081 BOOST_CHECK_EQUAL("Test", getTypename("/NS2/NS3/Test"));
00082 BOOST_CHECK_EQUAL("Scalar", getTypename("/wrappers/Matrix</double,3,1>/Scalar"));
00083 BOOST_CHECK_EQUAL("vector</wrappers/Matrix</double,3,1>>", getTypename("/std/vector</wrappers/Matrix</double,3,1>>"));
00084 }
00085
00086 BOOST_AUTO_TEST_CASE( test_typename_path_to )
00087 {
00088 BOOST_CHECK_EQUAL("B/", getMinimalPathTo("/A/B/Type", "/A/C"));
00089 BOOST_CHECK_EQUAL("B/", getMinimalPathTo("/A/B/Type", "/A/C/"));
00090 BOOST_CHECK_EQUAL("/B/B/", getMinimalPathTo("/B/B/Type", "/B/A"));
00091 BOOST_CHECK_EQUAL("/B/B/", getMinimalPathTo("/B/B/Type", "/B/A/"));
00092 BOOST_CHECK_EQUAL("/A/B/", getMinimalPathTo("/A/B/Type", "/A/B/C"));
00093 BOOST_CHECK_EQUAL("/A/B/", getMinimalPathTo("/A/B/Type", "/A/B/C/"));
00094 BOOST_CHECK_EQUAL("C/", getMinimalPathTo("/A/B/C/Type", "/A/B"));
00095 BOOST_CHECK_EQUAL("C/", getMinimalPathTo("/A/B/C/Type", "/A/B/"));
00096 BOOST_CHECK_EQUAL("", getMinimalPathTo("/A/B/Type", "/A/B"));
00097 BOOST_CHECK_EQUAL("", getMinimalPathTo("/A/B/Type", "/A/B/"));
00098 BOOST_CHECK_EQUAL("/A/", getMinimalPathTo("/A/B", "/C/A"));
00099 }
00100
00101 BOOST_AUTO_TEST_CASE( test_registry_namespaces )
00102 {
00103
00104 Registry registry;
00105 registry.add( new Numeric("/NS1/Test", 1, Numeric::SInt) );
00106 registry.add( new Numeric("/NS2/Test", 2, Numeric::SInt) );
00107
00108 registry.setDefaultNamespace("/NS2");
00109 BOOST_REQUIRE_EQUAL("/NS2/Test", registry.getFullName("Test"));
00110 BOOST_REQUIRE_EQUAL("/NS2/NS3/Test", registry.getFullName("NS3/Test"));
00111 BOOST_REQUIRE_EQUAL("/Test", registry.getFullName("/Test"));
00112 registry.add( new Numeric("/NS2/NS3/Test", 3, Numeric::SInt) );
00113 registry.add( new Numeric("/Test", 4, Numeric::SInt) );
00114 registry.setDefaultNamespace("");
00115
00116 Numeric const* ns1, *ns2, *ns3, *ns;
00117 BOOST_REQUIRE(( ns1 = dynamic_cast<Numeric const*>(registry.get("/NS1/Test")) ));
00118 BOOST_REQUIRE(( ns2 = dynamic_cast<Numeric const*>(registry.get("/NS2/Test")) ));
00119 BOOST_REQUIRE(( ns3 = dynamic_cast<Numeric const*>(registry.get("/NS2/NS3/Test")) ));
00120 BOOST_REQUIRE(( ns = dynamic_cast<Numeric const*>(registry.get("/Test")) ));
00121
00122 BOOST_REQUIRE_EQUAL(1, ns1->getSize());
00123 BOOST_REQUIRE_EQUAL(2, ns2->getSize());
00124 BOOST_REQUIRE_EQUAL(3, ns3->getSize());
00125 BOOST_REQUIRE_EQUAL(4, ns->getSize());
00126
00127 { registry.setDefaultNamespace("/NS2");
00128 Type const* relative;
00129 BOOST_REQUIRE(( relative = registry.get("Test") ));
00130 BOOST_REQUIRE_EQUAL(relative, ns2);
00131 BOOST_REQUIRE(( relative = registry.get("NS3/Test") ));
00132 BOOST_REQUIRE_EQUAL(relative, ns3);
00133 BOOST_REQUIRE(( relative = registry.get("/Test") ));
00134 BOOST_REQUIRE_EQUAL(relative, ns);
00135 BOOST_REQUIRE(( relative = registry.get("/NS1/Test") ));
00136 BOOST_REQUIRE_EQUAL(relative, ns1);
00137 }
00138
00139 }
00140
00141 BOOST_AUTO_TEST_CASE( test_namespace_update_at_insertion )
00142 {
00143 Registry registry;
00144 registry.setDefaultNamespace("/A/B/B");
00145 registry.add( new Numeric("/A/B/B/Test", 3, Numeric::SInt) );
00146 BOOST_REQUIRE(( registry.get("Test") ));
00147 BOOST_REQUIRE(( registry.get("B/Test") ));
00148 BOOST_REQUIRE(( registry.get("B/B/Test") ));
00149 BOOST_REQUIRE(( registry.get("A/B/B/Test") ));
00150
00151 registry.add( new Numeric("/A/B/Test", 3, Numeric::SInt) );
00152 BOOST_REQUIRE(( registry.get("Test") ));
00153 BOOST_REQUIRE(( registry.get("B/Test") ));
00154 BOOST_REQUIRE(( registry.get("B/B/Test") ));
00155 BOOST_REQUIRE(( registry.get("A/B/B/Test") ));
00156 BOOST_REQUIRE(( registry.get("A/B/Test") ));
00157
00158 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/Test"), registry.get("Test"));
00159 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/Test"), registry.get("B/Test"));
00160
00161 registry.setDefaultNamespace("/A/B/B/B");
00162 registry.add( new Numeric("/A/B/B/B/Test", 3, Numeric::SInt) );
00163 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/B/Test"), registry.get("Test"));
00164 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/B/Test"), registry.get("B/Test"));
00165 BOOST_REQUIRE_EQUAL(registry.get("/A/B/B/B/Test"), registry.get("B/B/Test"));
00166 }
00167
00168 static void assert_registries_equal(Registry const& registry, Registry const& ref)
00169 {
00170 BOOST_REQUIRE_EQUAL(ref.size(), registry.size());
00171
00172 Registry::Iterator
00173 t_it = registry.begin(),
00174 t_end = registry.end(),
00175 r_it = ref.begin(),
00176 r_end = ref.end();
00177
00178 for (; t_it != t_end && r_it != r_end; ++t_it, ++r_it)
00179 {
00180 BOOST_REQUIRE_EQUAL(t_it.getName(), r_it.getName());
00181 BOOST_REQUIRE_EQUAL(t_it->getName(), r_it->getName());
00182 BOOST_REQUIRE_MESSAGE(t_it->isSame(*r_it), "definitions of " << t_it->getName() << " differ: " << *t_it << "\n" << *r_it);
00183 }
00184
00185 BOOST_REQUIRE(t_it == t_end);
00186 BOOST_REQUIRE(r_it == r_end);
00187 }
00188
00189 BOOST_AUTO_TEST_CASE( test_repositories_merge )
00190 {
00191 static const char* test_file = TEST_DATA_PATH("test_cimport.tlb");
00192
00193 utilmm::config_set config;
00194 PluginManager::self manager;
00195
00196 std::auto_ptr<Registry> ref( manager->load("tlb", test_file, config));
00197 Registry target;
00198 target.merge(*ref);
00199 assert_registries_equal(target, *ref);
00200
00201 target.merge(*ref);
00202 assert_registries_equal(target, *ref);
00203 }
00204
00205 BOOST_AUTO_TEST_CASE( test_array_auto_alias )
00206 {
00207 Registry registry;
00208 Typelib::CXX::addStandardTypes(registry);
00209 registry.alias("/int", "/A");
00210 registry.add(new Array(*registry.get("/int"), 10));
00211 BOOST_REQUIRE(registry.get("/A[10]"));
00212 BOOST_REQUIRE(*registry.get("/A[10]") == *registry.get("/int[10]"));
00213 registry.alias("/int", "/B");
00214 BOOST_REQUIRE(registry.get("/B[10]"));
00215 BOOST_REQUIRE(*registry.get("/B[10]") == *registry.get("/int[10]"));
00216 }
00217
00218 BOOST_AUTO_TEST_CASE( test_registry_merge_keeps_alias_persistent_flag )
00219 {
00220 Registry registry;
00221 Typelib::CXX::addStandardTypes(registry);
00222
00223 registry.alias("/int", "/Persistent", true);
00224 registry.alias("/int", "/Temporary", false);
00225 BOOST_REQUIRE(registry.get("/Persistent"));
00226 BOOST_REQUIRE(registry.find("/Persistent") != registry.end());
00227
00228 Registry target;
00229 target.merge(registry);
00230 { RegistryIterator it = target.find("/Persistent");
00231 BOOST_REQUIRE(it != target.end());
00232 BOOST_REQUIRE(it.isPersistent());
00233 }
00234
00235 { RegistryIterator it = target.find("/Temporary");
00236 BOOST_REQUIRE(it != target.end());
00237 BOOST_REQUIRE(!it.isPersistent());
00238 }
00239 }
00240
00241 BOOST_AUTO_TEST_CASE( test_registry_minimal_keeps_alias_persistent_flag )
00242 {
00243 Registry registry;
00244 Typelib::CXX::addStandardTypes(registry);
00245 Registry target;
00246 Typelib::CXX::addStandardTypes(target);
00247 target.alias("/int", "/Persistent", true);
00248 target.alias("/int", "/Temporary", false);
00249
00250 target.minimal(registry);
00251 { RegistryIterator it = target.find("/Persistent");
00252 BOOST_REQUIRE(it != target.end());
00253 BOOST_REQUIRE(it.isPersistent());
00254 }
00255
00256 { RegistryIterator it = target.find("/Temporary");
00257 BOOST_REQUIRE(it != target.end());
00258 BOOST_REQUIRE(!it.isPersistent());
00259 }
00260 }
00261
00262 BOOST_AUTO_TEST_CASE( test_registry_range )
00263 {
00264 Registry registry;
00265 Typelib::CXX::addStandardTypes(registry);
00266 registry.alias("/int", "/A/A", true);
00267 registry.alias("/int", "/A/C", true);
00268 registry.alias("/int", "/A/F", true);
00269 registry.alias("/int", "/A/B/A", true);
00270 registry.alias("/int", "/A/B/C", true);
00271 registry.alias("/int", "/A/B/F", true);
00272 registry.alias("/int", "/B/A", true);
00273 registry.alias("/int", "/B/C", true);
00274 registry.alias("/int", "/B/F", true);
00275
00276 BOOST_REQUIRE_EQUAL("/A/A", registry.begin("/A").getName());
00277 BOOST_REQUIRE_EQUAL("/B/A", registry.end("/A").getName());
00278 }
00279