Skip to content
Snippets Groups Projects
Commit db9cb60f authored by janwych's avatar janwych
Browse files

added factory for arrays 

git-svn-id: https://svnsrv.desy.de/desy/mtca4u_applications/DOOCS_Adapter/trunk@70 688d77b5-b833-4f6b-b27f-eb88d88625d6
parent 9087fb3a
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
DOOCS_Adapter/include/DOOCSProcessVariableFactory.hpp
+ 29
− 1
View file @ db9cb60f
......@@ -9,6 +9,9 @@
#include "m4uD_type.hpp"
#include "DOOCSProcessVariableAdapter.hpp"
#include "m4uD_array.hpp"
#include "DOOCSProcessVariableArray.hpp"
namespace mtca4u{
......@@ -54,7 +57,32 @@ protected:
}
boost::any createProcessArray ( std::type_info const & variableType, std::string name, size_t arraySize) { return NULL; } // TODO proper implementation to come after arrays support
boost::any createProcessArray ( std::type_info const & variableType, std::string name, size_t arraySize)
{
if(variableType == typeid(int) ) {
boost::shared_ptr< mtca4u::m4uD_array<int> > darray ( new mtca4u::m4uD_array<int> ( name.c_str(), arraySize, ef ) );
return boost::shared_ptr < ProcessArray<int> > ( new mtca4u::DOOCSProcessVariableArray<int, mtca4u::m4uD_array<int> > (darray , arraySize));
} else
if(variableType == typeid(float) ) {
boost::shared_ptr< mtca4u::m4uD_array<float> > darray ( new mtca4u::m4uD_array<float> ( name.c_str(), arraySize, ef ) );
return boost::shared_ptr < ProcessArray<float> > ( new mtca4u::DOOCSProcessVariableArray<float, mtca4u::m4uD_array<float> > (darray , arraySize));
} else
if(variableType == typeid(double) ) {
boost::shared_ptr< mtca4u::m4uD_array<double> > darray ( new mtca4u::m4uD_array<double> ( name.c_str(), arraySize, ef ) );
return boost::shared_ptr < ProcessArray<double> > ( new mtca4u::DOOCSProcessVariableArray<double, mtca4u::m4uD_array<double> > (darray , arraySize));
} else
{
throw std::bad_typeid();
}
}
public:
......
DOOCS_Adapter/tests/include/m4uD_array_testCases_numericals.hpp 0 → 100644
+ 531
− 0
View file @ db9cb60f
#ifndef __m4uD_array_testCases_numericals__
#define __m4uD_array_testCases_numericals__
#include <boost/test/included/unit_test.hpp>
using namespace boost::unit_test;
// for: int, double, float
BOOST_FIXTURE_TEST_SUITE( test_operation, CallbacksTestFixture ) // operation check: return values matter
BOOST_AUTO_TEST_CASE( test_length )
{
BOOST_CHECK_EQUAL(mydarray.length(), 4);
}
BOOST_AUTO_TEST_CASE( test_getset_nocb )
{
// vec_test = [0,0,0,0]
vec_test.assign(4, 0.0);
const TypedVector & vec_mydarray = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray.begin(), vec_mydarray.end(), vec_test.begin(), vec_test.end());
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
mydarray.setspectrum(vec_test, pa);
const TypedVector & vec_mydarray1 = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray1.begin(), vec_mydarray1.end(), vec_test.begin(), vec_test.end());
}
BOOST_AUTO_TEST_CASE( test_getwcsetwc_nocb )
{
// vec_test = [0,0,0,0]
vec_test.assign(4, 0.0);
const TypedVector & vec_mydarray = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray.begin(), vec_mydarray.end(), vec_test.begin(), vec_test.end());
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
mydarray.setspectrum_without_callback(vec_test);
const TypedVector & vec_mydarray1 = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray1.begin(), vec_mydarray1.end(), vec_test.begin(), vec_test.end());
}
BOOST_AUTO_TEST_CASE( test_randomaccess ) // a "random access"
{
mydarray.fill_spectrum (0, 1.0);
mydarray.fill_spectrum (1, 2.0);
mydarray.fill_spectrum (2, 3.0);
mydarray.fill_spectrum (3, 4.0);
BOOST_CHECK_EQUAL(mydarray.read_spectrum(0), 1.0);
BOOST_CHECK_EQUAL(mydarray.read_spectrum(1), 2.0);
BOOST_CHECK_EQUAL(mydarray.read_spectrum(2), 3.0);
BOOST_CHECK_EQUAL(mydarray.read_spectrum(3), 4.0);
}
BOOST_AUTO_TEST_CASE( test_getset_cb )
{
// vec_test = [0,0,0,0]
vec_test.assign(4, 0.0);
const TypedVector & vec_mydarray = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray.begin(), vec_mydarray.end(), vec_test.begin(), vec_test.end());
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
mydarray.setspectrum(vec_test, pa);
const TypedVector & vec_mydarray1 = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray1.begin(), vec_mydarray1.end(), vec_test.begin(), vec_test.end());
mydarray.setOnSetCallbackFunction(boost::bind (&CallbacksTestFixture::on_set_callback, this, _1));
// vec_test = [2,2,2,2], then [5,2,2,2]
vec_test.assign(4, 2.0);
mydarray.setspectrum(vec_test, pa);
vec_test[0] = 5;// vec_test[3] = 6;
const TypedVector & vec_mydarray2 = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray2.begin(), vec_mydarray2.end(), vec_test.begin(), vec_test.end());
mydarray.setOnGetCallbackFunction(boost::bind (&CallbacksTestFixture::on_get_callback, this, _1));
// vec_test = [3,3,3,3], then [5,3,3,6]
vec_test.assign(4, 3.0);
mydarray.setspectrum(vec_test, pa);
vec_test[0] = 5; vec_test[3] = 6;
const TypedVector & vec_mydarray3 = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray3.begin(), vec_mydarray3.end(), vec_test.begin(), vec_test.end());
}
BOOST_AUTO_TEST_CASE( test_getwcsetwc_cb )
{
// vec_test = [0,0,0,0]
vec_test.assign(4, 0.0);
const TypedVector & vec_mydarray = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray.begin(), vec_mydarray.end(), vec_test.begin(), vec_test.end());
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
mydarray.setspectrum_without_callback(vec_test);
const TypedVector & vec_mydarray1 = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray1.begin(), vec_mydarray1.end(), vec_test.begin(), vec_test.end());
mydarray.setOnSetCallbackFunction(boost::bind (&CallbacksTestFixture::on_set_callback, this, _1));
// vec_test = [2,2,2,2]
vec_test.assign(4, 2.0);
mydarray.setspectrum_without_callback(vec_test);
// vec_test[0] = 5;// vec_test[3] = 6;
const TypedVector & vec_mydarray2 = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray2.begin(), vec_mydarray2.end(), vec_test.begin(), vec_test.end());
mydarray.setOnGetCallbackFunction(boost::bind (&CallbacksTestFixture::on_get_callback, this, _1));
// vec_test = [3,3,3,3]
vec_test.assign(4, 3.0);
mydarray.setspectrum_without_callback(vec_test);
// vec_test[0] = 5; vec_test[3] = 6;
const TypedVector & vec_mydarray3 = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL_COLLECTIONS(vec_mydarray3.begin(), vec_mydarray3.end(), vec_test.begin(), vec_test.end());
}
BOOST_AUTO_TEST_CASE( test_cachesync )
{
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true); // D_spectrum has 0's after creation
// vec_test = [0,0,0,0]
vec_test.assign(4, 0.0);
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), false);
mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
// vec_test = [0,0,0,0]
vec_test.assign(4, 0.0);
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), false);
mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.fill_spectrum (0, 0.0);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.read_spectrum(0);
mydarray.read_spectrum(1);
mydarray.read_spectrum(2);
mydarray.read_spectrum(3);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.fill_spectrum (1, 2.0);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), false);
mydarray.read_spectrum(0);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), false);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), false);
TypedVector v(4);
mydarray.fillVector(v);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
// FIXME: a series for callbacks presence advised?
/*
// vec_test = [0,0,0,0]
vec_test.assign(4, 0.0);
vec_mydarray = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
mydarray.setspectrum(vec_test, pa);
vec_mydarray = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.setOnSetCallbackFunction(boost::bind (&CallbacksTestFixture::on_set_callback, this, _1));
// vec_test = [2,2,2,2], then [5,2,2,2]
vec_test.assign(4, 2.0);
mydarray.setspectrum(vec_test, pa);
vec_test[0] = 5;// vec_test[3] = 6;
vec_mydarray = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.setOnGetCallbackFunction(boost::bind (&CallbacksTestFixture::on_get_callback, this, _1));
// vec_test = [3,3,3,3], then [5,3,3,6]
vec_test.assign(4, 3.0);
mydarray.setspectrum(vec_test, pa);
vec_test[0] = 5; vec_test[3] = 6;
vec_mydarray = mydarray.getspectrum(pa);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
// vec_test = [0,0,0,0]
vec_test.assign(4, 0.0);
vec_mydarray = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
mydarray.setspectrum_without_callback(vec_test);
vec_mydarray = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.setOnSetCallbackFunction(boost::bind (&CallbacksTestFixture::on_set_callback, this, _1));
// vec_test = [2,2,2,2]
vec_test.assign(4, 2.0);
mydarray.setspectrum_without_callback(vec_test);
// vec_test[0] = 5;// vec_test[3] = 6;
vec_mydarray = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
mydarray.setOnGetCallbackFunction(boost::bind (&CallbacksTestFixture::on_get_callback, this, _1));
// vec_test = [3,3,3,3]
vec_test.assign(4, 3.0);
mydarray.setspectrum_without_callback(vec_test);
// vec_test[0] = 5; vec_test[3] = 6;
vec_mydarray = mydarray.getspectrum_without_callback();
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_flag(), true);
BOOST_CHECK_EQUAL(mydarray.__is_cache_synced_vect(), true);
*/
}
BOOST_AUTO_TEST_CASE( test_fill )
{
mydarray.fill(30);
for(int i=0; i<mydarray.length(); ++i)
BOOST_CHECK_EQUAL(mydarray.read_spectrum (i), 30);
}
BOOST_AUTO_TEST_CASE( test_fillvector )
{
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
mydarray.setspectrum(vec_test, pa);
TypedVector v(4);
mydarray.fillVector(v);
BOOST_CHECK_EQUAL_COLLECTIONS(v.begin(), v.end(), vec_test.begin(), vec_test.end());
}
BOOST_AUTO_TEST_SUITE_END()
// ============================================================================
BOOST_FIXTURE_TEST_SUITE( test_callbacks, CallbacksTestFixture ) // callback arbitrarily present: callback counters matter, return values don't
BOOST_AUTO_TEST_CASE( test_get_cb_count )
{
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.setOnGetCallbackFunction(boost::bind (&CallbacksTestFixture::on_get_callback, this, _1));
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 1 );
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 2 );
mydarray.clearOnGetCallbackFunction();
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 2 );
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 2 );
mydarray.setOnGetCallbackFunction(boost::bind (&CallbacksTestFixture::on_get_callback, this, _1));
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 3 );
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 4 );
mydarray.clearOnGetCallbackFunction();
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 4 );
mydarray.getspectrum(pa);
BOOST_CHECK( _get_cb_counter == 4 );
}
BOOST_AUTO_TEST_CASE( test_set_cb_count )
{
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setOnSetCallbackFunction(boost::bind (&CallbacksTestFixture::on_set_callback, this, _1));
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 1 );
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 2 );
mydarray.clearOnSetCallbackFunction();
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 2 );
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 2 );
mydarray.setOnSetCallbackFunction(boost::bind (&CallbacksTestFixture::on_set_callback, this, _1));
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 3 );
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 4 );
mydarray.clearOnSetCallbackFunction();
mydarray.setspectrum(vec_test, pa);
BOOST_CHECK( _set_cb_counter == 4 );
}
BOOST_AUTO_TEST_SUITE_END()
// ============================================================================
BOOST_FIXTURE_TEST_SUITE( test_no_callbacks, CallbacksTestFixture ) // callback absent: callback counters matter, return values don't
BOOST_AUTO_TEST_CASE( test_get_nocb_count )
{
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.setOnGetCallbackFunction(boost::bind (&CallbacksTestFixture::on_get_callback, this, _1));
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.clearOnGetCallbackFunction();
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.setOnGetCallbackFunction(boost::bind (&CallbacksTestFixture::on_get_callback, this, _1));
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.clearOnGetCallbackFunction();
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
mydarray.getspectrum_without_callback();
BOOST_CHECK( _get_cb_counter == 0 );
}
BOOST_AUTO_TEST_CASE( test_set_nocb_count )
{
// vec_test = [1,1,1,1]
vec_test.assign(4, 1.0);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setOnSetCallbackFunction(boost::bind (&CallbacksTestFixture::on_set_callback, this, _1));
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.clearOnSetCallbackFunction();
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setOnSetCallbackFunction(boost::bind (&CallbacksTestFixture::on_set_callback, this, _1));
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
mydarray.clearOnSetCallbackFunction();
mydarray.setspectrum_without_callback(vec_test);
BOOST_CHECK( _set_cb_counter == 0 );
}
BOOST_AUTO_TEST_SUITE_END()
#endif /* __m4uD_array_testCases_numericals__ */
DOOCS_Adapter/tests/src/testDOOCSProcessVariableFactory.cpp
+ 86
− 27
View file @ db9cb60f
......@@ -7,6 +7,12 @@ using namespace boost::unit_test;
#include "DOOCSProcessVariableFactory.hpp"
#include <vector>
static const size_t ARRAY_SIZE = 15;
static const size_t WRONG_ARRAY_SIZE = 35;
......@@ -23,8 +29,6 @@ BOOST_AUTO_TEST_CASE( testGetProcessVariable_basicoperation )
Double ->set(2); BOOST_CHECK_EQUAL(Double->get() , 2);
Float ->set(3); BOOST_CHECK_EQUAL(Float->get() , 3);
String ->set(std::string("teststr")); BOOST_CHECK_EQUAL(String->get() , std::string("teststr"));
}
......@@ -48,42 +52,97 @@ BOOST_AUTO_TEST_CASE( testGetProcessVariable_map )
// exceptions
BOOST_CHECK_THROW( DOOCSPVFactory.getProcessVariable<uint64_t>("tooLong"), std::bad_typeid );
BOOST_CHECK_THROW( DOOCSPVFactory.getProcessVariable<double>("firstInteger"), std::bad_cast ); // not boost::bad_any_cast
// check that name conflicts with arrays work
boost::shared_ptr<mtca4u::ProcessArray<int> > intArray = DOOCSPVFactory.getProcessArray<int>("intArray", ARRAY_SIZE);
BOOST_CHECK_THROW( DOOCSPVFactory.getProcessVariable<int>("intArray"), boost::bad_any_cast );
}
/*
BOOST_AUTO_TEST_CASE( testGetProcessVariable )
BOOST_AUTO_TEST_CASE( testGetProcessArray_basicoperation )
{
// check that name conflicts with arrays work
//~ boost::shared_ptr<mtca4u::ProcessArray<int> > intArray = DOOCSPVFactory.getProcessArray<int>("intArray", 42);
//~ BOOST_CHECK_THROW( DOOCSPVFactory.getProcessVariable<int>("intArray"), boost::bad_any_cast );
mtca4u::DOOCSProcessVariableFactory DOOCSPVFactory( NULL );
boost::shared_ptr<mtca4u::ProcessArray<int> > IntegerA = DOOCSPVFactory.getProcessArray<int> ("Integer", ARRAY_SIZE);
boost::shared_ptr<mtca4u::ProcessArray<double> > DoubleA = DOOCSPVFactory.getProcessArray<double> ("Double" , ARRAY_SIZE);
boost::shared_ptr<mtca4u::ProcessArray<float> > FloatA = DOOCSPVFactory.getProcessArray<float> ("Float" , ARRAY_SIZE);
IntegerA->fill(1);
DoubleA ->fill(2);
FloatA ->fill(3);
//~ the below sequence is really ugly. The aim is to read the arrays contents. So:
//~ 1. getting the raw pointer
mtca4u::ProcessArray<int> const * IntegerA_raw = IntegerA.get();
mtca4u::ProcessArray<double> const * DoubleA_raw = DoubleA.get();
mtca4u::ProcessArray<float> const * FloatA_raw = FloatA.get();
//~ 2. typecast to DOOCSProcessVariableArray const *
mtca4u::DOOCSProcessVariableArray< int , mtca4u::m4uD_array<int > > const * DPVA_IntegerA_rawconst = static_cast< mtca4u::DOOCSProcessVariableArray< int , mtca4u::m4uD_array<int> > const * >( IntegerA_raw );
mtca4u::DOOCSProcessVariableArray< double, mtca4u::m4uD_array<double> > const * DPVA_DoubleA_rawconst = static_cast< mtca4u::DOOCSProcessVariableArray< double, mtca4u::m4uD_array<double> > const * >( DoubleA_raw );
mtca4u::DOOCSProcessVariableArray< float , mtca4u::m4uD_array<float > > const * DPVA_FloatA_rawconst = static_cast< mtca4u::DOOCSProcessVariableArray< float , mtca4u::m4uD_array<float> > const * >( FloatA_raw );
//~ 3. de-const'ing to DOOCSProcessVariableArray *
mtca4u::DOOCSProcessVariableArray< int , mtca4u::m4uD_array<int> > * DPVA_IntegerA_raw = const_cast< mtca4u::DOOCSProcessVariableArray< int , mtca4u::m4uD_array<int> > * >( DPVA_IntegerA_rawconst );
mtca4u::DOOCSProcessVariableArray< double, mtca4u::m4uD_array<double> > * DPVA_DoubleA_raw = const_cast< mtca4u::DOOCSProcessVariableArray< double, mtca4u::m4uD_array<double> > * >( DPVA_DoubleA_rawconst );
mtca4u::DOOCSProcessVariableArray< float , mtca4u::m4uD_array<float> > * DPVA_FloatA_raw = const_cast< mtca4u::DOOCSProcessVariableArray< float , mtca4u::m4uD_array<float> > * >( DPVA_FloatA_rawconst );
//~ only now get() is accessible
const std::vector<int> & intV = DPVA_IntegerA_raw->get();
const std::vector<double> & doubleV = DPVA_DoubleA_raw ->get();
const std::vector<float> & floatV = DPVA_FloatA_raw ->get();
//~ the reason for such way is that the current ProcessArray interface has no get()'s,
//~ while at the same time the nature of DOOCS data storage prevents iterators implementation
//~ Off course this should not be like that in the end!
for (std::vector<int> ::const_iterator it = intV .begin(); it != intV .end(); ++it) BOOST_CHECK(*it == 1);
for (std::vector<double>::const_iterator it = doubleV.begin(); it != doubleV.end(); ++it) BOOST_CHECK(*it == 2);
for (std::vector<float> ::const_iterator it = floatV .begin(); it != floatV .end(); ++it) BOOST_CHECK(*it == 3);
}
*/
/*
BOOST_AUTO_TEST_CASE( testGetProcessVariable )
BOOST_AUTO_TEST_CASE( testGetProcessArray_map )
{
mtca4u::StubProcessVariableFactory stubProcessVariableFactory;
mtca4u::DOOCSProcessVariableFactory DOOCSPVFactory( NULL );
boost::shared_ptr<mtca4u::ProcessVariable<int> > firstInteger = stubProcessVariableFactory.getProcessVariable<int>("firstInteger");
boost::shared_ptr<mtca4u::ProcessArray<int> > firstIntegerA = DOOCSPVFactory.getProcessArray<int>("firstInteger", ARRAY_SIZE); // 1
boost::shared_ptr<mtca4u::ProcessArray<int> > secondIntegerA = DOOCSPVFactory.getProcessArray<int>("firstInteger", ARRAY_SIZE); // 1
boost::shared_ptr<mtca4u::ProcessArray<int> > thirdIntegerA = DOOCSPVFactory.getProcessArray<int>("thirdInteger", ARRAY_SIZE); // 2
firstInteger->set(42);
firstIntegerA->fill(42);
thirdIntegerA->fill(55);
boost::shared_ptr<mtca4u::ProcessVariable<int> > secondInteger = stubProcessVariableFactory.getProcessVariable<int>("firstInteger");
boost::shared_ptr<mtca4u::ProcessVariable<int> > thirdInteger = stubProcessVariableFactory.getProcessVariable<int>("thirdInteger");
thirdInteger->set(55);
mtca4u::ProcessArray<int> const * firstIntegerA_raw = firstIntegerA.get();
mtca4u::ProcessArray<int> const * secondIntegerA_raw = secondIntegerA.get();
mtca4u::ProcessArray<int> const * thirdIntegerA_raw = thirdIntegerA.get();
// make sure the second integer is the same instance as the first integer, but the third is not
BOOST_CHECK(*secondInteger == 42);
secondInteger->set(43);
BOOST_CHECK(*firstInteger == 43);
BOOST_CHECK(*thirdInteger == 55);
mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > const * DPVA_firstIntegerA_rawconst = static_cast< mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > const * >( firstIntegerA_raw );
mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > const * DPVA_secondIntegerA_rawconst = static_cast< mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > const * >( secondIntegerA_raw );
mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > const * DPVA_thirdIntegerA_rawconst = static_cast< mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > const * >( thirdIntegerA_raw );
BOOST_CHECK_THROW( stubProcessVariableFactory.getProcessVariable<uint64_t>("tooLong"), std::bad_typeid );
BOOST_CHECK_THROW( stubProcessVariableFactory.getProcessVariable<double>("firstInteger"), boost::bad_any_cast );
mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > * DPVA_firstIntegerA_raw = const_cast< mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > * >( DPVA_firstIntegerA_rawconst );
mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > * DPVA_secondIntegerA_raw = const_cast< mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > * >( DPVA_secondIntegerA_rawconst );
mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > * DPVA_thirdIntegerA_raw = const_cast< mtca4u::DOOCSProcessVariableArray< int, mtca4u::m4uD_array<int> > * >( DPVA_thirdIntegerA_rawconst );
// check that name conflicts with arrays work
boost::shared_ptr<mtca4u::ProcessArray<int> > intArray = stubProcessVariableFactory.getProcessArray<int>("intArray", 42);
BOOST_CHECK_THROW( stubProcessVariableFactory.getProcessVariable<int>("intArray"), boost::bad_any_cast );
const std::vector<int> & firstV = DPVA_firstIntegerA_raw ->get();
const std::vector<int> & secondV = DPVA_secondIntegerA_raw->get();
const std::vector<int> & thirdV = DPVA_thirdIntegerA_raw ->get();
// make sure the second integer array is the same instance as the first one, but the third is not
for (std::vector<int>::const_iterator it = secondV.begin(); it != secondV.end(); ++it) BOOST_CHECK(*it == 42);
secondIntegerA->fill(43);
DPVA_firstIntegerA_raw ->get(); // sync cache
for (std::vector<int>::const_iterator it = firstV.begin(); it != firstV.end(); ++it) BOOST_CHECK(*it == 43);
DPVA_thirdIntegerA_raw ->get(); // sync cache
for (std::vector<int>::const_iterator it = thirdV.begin(); it != thirdV.end(); ++it) BOOST_CHECK(*it == 55);
// exceptions
BOOST_CHECK_THROW( DOOCSPVFactory.getProcessArray<uint64_t>("unknownType" , ARRAY_SIZE) , std::bad_typeid ); // unknown type
BOOST_CHECK_THROW( DOOCSPVFactory.getProcessArray<double> ("firstInteger", ARRAY_SIZE) , std::bad_cast ); // not boost::bad_any_cast
BOOST_CHECK_THROW( DOOCSPVFactory.getProcessArray<int> ("firstInteger", WRONG_ARRAY_SIZE), std::length_error );
// check that name conflicts with variables work
boost::shared_ptr<mtca4u::ProcessVariable<int> > firstInt = DOOCSPVFactory.getProcessVariable<int>("firstInt");
BOOST_CHECK_THROW( DOOCSPVFactory.getProcessArray<int>("firstInt", ARRAY_SIZE), boost::bad_any_cast );
}
*/
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

imprint | privacy | Conditions of Use