fixtures.hpp

Go to the documentation of this file.

/*
---------------------------------------------------------------------------

    This file is part of uHAL.

    uHAL is a hardware access library and programming framework
    originally developed for upgrades of the Level-1 trigger of the CMS
    experiment at CERN.

    uHAL is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    uHAL is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with uHAL.  If not, see <http://www.gnu.org/licenses/>.

      Andrew Rose, Imperial College, London
      email: awr01 <AT> imperial.ac.uk

      Tom Williams, Rutherford Appleton Laboratory, Oxfordshire
      email: tom.williams <AT> cern.ch

---------------------------------------------------------------------------
*/

#ifndef _uhal_tests_fixtures_hpp_
#define _uhal_tests_fixtures_hpp_


#include <stdint.h>
#include <string>


#include "uhal/ConnectionManager.hpp"
#include "uhal/HwInterface.hpp"
#include "uhal/tests/definitions.hpp"
#include "uhal/tests/tools.hpp"


namespace uhal {
namespace tests {

struct AbstractFixture {
protected:
  AbstractFixture() {}
  virtual ~AbstractFixture() {}

public:
  static std::string connectionFileURI;
};



template <DeviceType type> struct MinimalFixture;


template <DeviceType type>
struct MinimalFixture : public AbstractFixture {
  MinimalFixture();
  virtual ~MinimalFixture();

  uhal::HwInterface getHwInterface() const;

  static const DeviceType deviceType;

protected:
  uint16_t devicePort;
  std::string deviceId;
};


template <>
struct MinimalFixture<IPBUS_2_0_PCIE> : public AbstractFixture {
  MinimalFixture(); 
  ~MinimalFixture();

  uhal::HwInterface getHwInterface() const;

  static const DeviceType deviceType;
  std::string hardwareToClientFile;
  std::string clientToHardwareFile;
  std::string deviceId;
};

template <DeviceType type>
const DeviceType MinimalFixture<type>::deviceType = type;

template <>
MinimalFixture<IPBUS_1_3_UDP>::MinimalFixture();

template <>
MinimalFixture<IPBUS_1_3_TCP>::MinimalFixture();

template <>
MinimalFixture<IPBUS_1_3_CONTROLHUB>::MinimalFixture();

template <>
MinimalFixture<IPBUS_2_0_UDP>::MinimalFixture();

template <>
MinimalFixture<IPBUS_2_0_TCP>::MinimalFixture();

template <>
MinimalFixture<IPBUS_2_0_CONTROLHUB>::MinimalFixture();


template <DeviceType type>
MinimalFixture<type>::~MinimalFixture()
{
}

template <DeviceType type>
HwInterface MinimalFixture<type>::getHwInterface() const
{
  ConnectionManager manager(connectionFileURI);
  return manager.getDevice(deviceId);
}




template <DeviceType type>
struct DummyHardwareFixture : public MinimalFixture<type> {
  DummyHardwareFixture();
  ~DummyHardwareFixture() {}

  DummyHardwareRunner hwRunner;
};


template <>
DummyHardwareFixture<IPBUS_1_3_UDP>::DummyHardwareFixture();

template <>
DummyHardwareFixture<IPBUS_1_3_TCP>::DummyHardwareFixture();

template <>
DummyHardwareFixture<IPBUS_1_3_CONTROLHUB>::DummyHardwareFixture();

template <>
DummyHardwareFixture<IPBUS_2_0_UDP>::DummyHardwareFixture();

template <>
DummyHardwareFixture<IPBUS_2_0_TCP>::DummyHardwareFixture();

template <>
DummyHardwareFixture<IPBUS_2_0_CONTROLHUB>::DummyHardwareFixture();

template <>
DummyHardwareFixture<IPBUS_2_0_PCIE>::DummyHardwareFixture();


} // end ns tests
} // end ns uhal


#endif