Go to the documentation of this file.00001 #define OROCOS_TARGET gnulinux
00002 #include <rtt/types/TypekitPlugin.hpp>
00003 #include <rtt/typekit/RealTimeTypekit.hpp>
00004 #include "simple/typekit/Types.hpp"
00005 #include "simple/typekit/Plugin.hpp"
00006 #include <string.h>
00007
00008 #ifdef WITH_CORBA
00009 #include <omniORB4/CORBA.h>
00010 #include <rtt/transports/corba/CorbaLib.hpp>
00011 #include <rtt/transports/corba/CorbaTypeTransporter.hpp>
00012 #include "transports/corba/simpleTypesC.h"
00013 #include "transports/corba/TransportPlugin.hpp"
00014 #endif
00015
00016 #ifdef WITH_TYPELIB
00017 #include "transports/typelib/TransportPlugin.hpp"
00018 #include <rtt/typelib/TypelibMarshallerBase.hpp>
00019 #endif
00020
00021 #include <rtt/os/main.h>
00022 #include <rtt/types/Types.hpp>
00023 #include <rtt/PropertyBag.hpp>
00024 #include <rtt/Property.hpp>
00025 #include <rtt/internal/DataSource.hpp>
00026 #include <rtt/types/PropertyDecomposition.hpp>
00027 #include <rtt/marsh/PropertyMarshaller.hpp>
00028 #include <rtt/marsh/PropertyDemarshaller.hpp>
00029 #include <iostream>
00030 #include <fstream>
00031 #include <typeinfo>
00032 #include <stdexcept>
00033
00034 using namespace RTT;
00035 using namespace RTT::types;
00036 using namespace RTT::internal;
00037 using namespace RTT::marsh;
00038 using std::cerr;
00039 using std::endl;
00040
00041 TypeInfo* assert_typeinfo_is_available(std::string const& name)
00042 {
00043 TypeInfoRepository::shared_ptr ti = TypeInfoRepository::Instance();
00044 TypeInfo* type = ti->type(name);
00045 if (! type)
00046 {
00047 cerr << "cannot find " << name << " in the type info repository" << endl;
00048 throw std::runtime_error("failed assertion");
00049 }
00050 return type;
00051 }
00052
00053 #ifdef WITH_CORBA
00054 template<typename T>
00055 bool generic_corba_test(T const& testValue, RTT::types::TypeInfo const& ti)
00056 {
00057 boost::intrusive_ptr< ValueDataSource<T> > source(new ValueDataSource<T>(testValue));
00058 source->ref();
00059
00060 RTT::corba::CorbaTypeTransporter* transport =
00061 dynamic_cast<RTT::corba::CorbaTypeTransporter*>(ti.getProtocol(ORO_CORBA_PROTOCOL_ID));
00062
00063 cerr << "- testing CORBA marshalling/unmarshalling ..." << endl;
00064 {
00065 CORBA::Any* result = transport->createAny(source);
00066
00067 ValueDataSource<T>* reader = new ValueDataSource<T>();
00068 reader->ref();
00069 transport->updateFromAny(result, reader);
00070
00071 T result_value = reader->get();
00072 if (!(result_value == testValue))
00073 {
00074 cerr << "discrepancy between original and unmarshalled values" << endl;
00075 return false;
00076 }
00077 }
00078 cerr << " done" << endl;
00079 return true;
00080 }
00081 #endif
00082
00083 #ifdef WITH_TYPELIB
00084 template<typename T>
00085 bool generic_typelib_test(T const& testValue, TypeInfo const& ti)
00086 {
00087 cerr << "- testing Typelib marshalling/unmarshalling ..." << endl;
00088 ConstantDataSource<T>* source
00089 = new ConstantDataSource<T>(testValue);
00090 source->ref();
00091
00092 orogen_transports::TypelibMarshallerBase* transport =
00093 dynamic_cast<orogen_transports::TypelibMarshallerBase*>(ti.getProtocol(orogen_transports::TYPELIB_MARSHALLER_ID));
00094
00095 std::vector<uint8_t> buffer;
00096 orogen_transports::TypelibMarshallerBase::Handle* handle =
00097 transport->createSample();
00098 transport->readDataSource(*source, handle);
00099 transport->marshal(buffer, handle);
00100 transport->deleteHandle(handle);
00101 source->deref();
00102
00103 handle = transport->createSample();
00104 transport->unmarshal(buffer, handle);
00105 T unmarshalled =
00106 reinterpret_cast<T const&>(*transport->getTypelibSample(handle));
00107 transport->deleteHandle(handle);
00108
00109 if (!(unmarshalled == testValue))
00110 {
00111 cerr << "unmarshalled Typelib data does not match original data" << endl;
00112 return false;
00113 }
00114 return true;
00115 }
00116 #endif
00117
00118
00119 template<typename T>
00120 bool generic_type_handling_test(std::string const& name, T const& testValue, TypeInfo const& ti)
00121 {
00122 cerr << "- testing composition/decomposition is disabled" << endl;
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172 #ifdef WITH_CORBA
00173 if (!generic_corba_test(testValue, ti))
00174 return false;
00175 #endif
00176 #ifdef WITH_TYPELIB
00177 if (!generic_typelib_test(testValue, ti))
00178 return false;
00179 #endif
00180 return true;
00181 }
00182
00183 bool test_base_types()
00184 {
00185 cerr << "Test handling of BaseTypes" << endl;
00186 TypeInfo* type = assert_typeinfo_is_available("/Test/BaseTypes");
00187
00188
00189
00190 Test::BaseTypes testValue;
00191 testValue.v0 = true;
00192 testValue.v1 = 'a';
00193 testValue.v5 = -100000;
00194 testValue.v6 = 3000000000UL;
00195 testValue.e = Test::VALUE_20;
00196 for (int i = 0; i < 20; ++i)
00197 testValue.a[i] = 'a' + i;
00198
00199 if (!generic_type_handling_test("basic", testValue, *type))
00200 return false;
00201 return true;
00202 }
00203
00204 bool test_handling_of_invalid_enum_values()
00205 {
00206 cerr << "- testing composition/decomposition is disabled" << endl;
00207
00208
00209
00210
00211
00212
00213
00214
00215
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226 return true;
00227 }
00228
00229 bool test_64bit_handling()
00230 {
00231 cerr << "- testing composition/decomposition is disabled" << endl;
00232
00233 TypeInfo* type = assert_typeinfo_is_available("/Test/Test64BitHandling");
00234
00235 Test::Test64BitHandling testValue;
00236 memset(&testValue, 0, sizeof(testValue));
00237 testValue.base.v0 = true;
00238 testValue.base.v1 = 'a';
00239 testValue.base.v5 = -100000;
00240 testValue.base.v6 = 3000000000UL;
00241 testValue.base.e = Test::VALUE_20;
00242 for (int i = 0; i < 20; ++i)
00243 testValue.base.a[i] = 'a' + i;
00244 testValue.ll = -(1LL << 40);
00245 testValue.ull = -(1LL << 40);
00246
00247
00248
00249
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260 #ifdef WITH_CORBA
00261 if (!generic_corba_test(testValue, *type))
00262 return false;
00263 #endif
00264 #ifdef WITH_TYPELIB
00265 if (!generic_typelib_test(testValue, *type))
00266 return false;
00267 #endif
00268 return true;
00269 }
00270
00271 bool test_simple_vector()
00272 {
00273 cerr << "Testing simple structure with vector<>" << endl;
00274 TypeInfo* type = assert_typeinfo_is_available("/Test/SimpleVector");
00275
00276 Test::SimpleVector testValue;
00277 testValue.field = 10;
00278 for (int i = 0; i < 20; ++i)
00279 testValue.data.push_back('a' + i);
00280
00281 return generic_type_handling_test("simple_vector", testValue, *type);
00282 }
00283
00284 bool test_complex_vector()
00285 {
00286 cerr << "Testing complex structure-in-vector<>" << endl;
00287 TypeInfo* type = assert_typeinfo_is_available("/Test/ComplexVector");
00288
00289 Test::ComplexVector testValue;
00290 testValue.field = 10;
00291 testValue.data.resize(20);
00292 for (int i = 0; i < 20; ++i)
00293 {
00294 Test::SimpleVector& el = testValue.data[i];
00295 el.field = i;
00296 for (int j = 0; j < i + 5; ++j)
00297 el.data.push_back(i * 20 + j);
00298 }
00299
00300 return generic_type_handling_test("complex_vector", testValue, *type);
00301 }
00302
00303 bool test_complex_array()
00304 {
00305 cerr << "Testing complex structure-in-array" << endl;
00306 TypeInfo* type = assert_typeinfo_is_available("/Test/ComplexArray");
00307
00308 Test::ComplexArray testValue;
00309 testValue.field = 10;
00310 for (int i = 0; i < 10; ++i)
00311 {
00312 Test::SimpleVector& el = testValue.data[i];
00313 el.field = i;
00314 for (int j = 0; j < i + 5; ++j)
00315 el.data.push_back(i * 20 + j);
00316 }
00317
00318 return generic_type_handling_test("complex_array", testValue, *type);
00319 }
00320
00321
00322
00323
00324 int ORO_main(int argc, char** argv)
00325 {
00326 log().setLogLevel( Logger::Debug );
00327 RTT::types::TypekitRepository::Import( new RTT::types::RealTimeTypekitPlugin );
00328 RTT::types::TypekitRepository::Import( new orogen_typekits::simpleTypekitPlugin );
00329 #ifdef WITH_CORBA
00330 RTT::types::TypekitRepository::Import( new orogen_typekits::simpleCorbaTransportPlugin );
00331 #endif
00332 #ifdef WITH_TYPELIB
00333 RTT::types::TypekitRepository::Import( new orogen_typekits::simpleTypelibTransportPlugin );
00334 #endif
00335
00336 TypeInfoRepository::shared_ptr ti = TypeInfoRepository::Instance();
00337
00338 if (!test_base_types())
00339 return 1;
00340
00341 cerr << endl;
00342 if (!test_handling_of_invalid_enum_values())
00343 return 1;
00344
00345 cerr << endl;
00346 if (!test_64bit_handling())
00347 return 1;
00348
00349 cerr << endl;
00350 if (!test_simple_vector())
00351 return 1;
00352
00353 cerr << endl;
00354 if (!test_complex_vector())
00355 return 1;
00356
00357 cerr << endl;
00358 if (!test_complex_array())
00359 return 1;
00360
00361 return 0;
00362 }
00363