diff --git a/InnerDetector/InDetG4/SCT_G4_SD/CMakeLists.txt b/InnerDetector/InDetG4/SCT_G4_SD/CMakeLists.txt
index 63d19e77dde05384b09f69fd594ac0f1ace10295..90c62199cfa81e32689062ce94d0c1ea93463a78 100644
--- a/InnerDetector/InDetG4/SCT_G4_SD/CMakeLists.txt
+++ b/InnerDetector/InDetG4/SCT_G4_SD/CMakeLists.txt
@@ -12,12 +12,14 @@ atlas_depends_on_subdirs( PRIVATE
                           InnerDetector/InDetSimEvent
                           Simulation/G4Atlas/G4AtlasTools
                           Simulation/G4Sim/MCTruth
+                          AtlasTest/TestTools
                            )
 
 # External dependencies:
 find_package( CLHEP )
 find_package( Geant4 )
 find_package( XercesC )
+find_package( GTest )
 
 # Component(s) in the package:
 atlas_add_component( SCT_G4_SD
@@ -26,10 +28,28 @@ atlas_add_component( SCT_G4_SD
                      INCLUDE_DIRS ${GEANT4_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
                      LINK_LIBRARIES ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} StoreGateLib SGtests GaudiKernel InDetSimEvent G4AtlasToolsLib MCTruth )
 
+atlas_add_library( SCT_G4_SDLib
+                   src/*.cxx
+                   NO_PUBLIC_HEADERS SCT_G4_SD
+                   INCLUDE_DIRS ${GEANT4_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS}
+                     LINK_LIBRARIES ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} ${GMOCK_LIBRARIES}  CxxUtils StoreGateLib SGtests GaudiKernel InDetSimEvent G4AtlasToolsLib MCTruth )
+
 atlas_add_test( SCT_G4_SDToolConfig_test
                 SCRIPT test/SCT_G4_SDToolConfig_test.py
                 PROPERTIES TIMEOUT 300 )
 
+atlas_add_test( SctSensorSD_gtest
+                SOURCES test/SctSensorSD_gtest.cxx
+                INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+                LINK_LIBRARIES TestTools  ${GTEST_LIBRARIES} ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} SCT_G4_SDLib CxxUtils StoreGateLib SGtests GaudiKernel InDetSimEvent G4AtlasToolsLib MCTruth
+)
+
+atlas_add_test( SctSensor_CTB_gtest
+                SOURCES test/SctSensor_CTB_gtest.cxx
+                INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} ${GEANT4_INCLUDE_DIRS} ${XERCESC_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+                LINK_LIBRARIES TestTools  ${GTEST_LIBRARIES} ${GEANT4_LIBRARIES} ${XERCESC_LIBRARIES} ${CLHEP_LIBRARIES} SCT_G4_SDLib CxxUtils StoreGateLib SGtests GaudiKernel InDetSimEvent G4AtlasToolsLib MCTruth
+)
+
 # Install files from the package:
 atlas_install_python_modules( python/*.py )
-
+atlas_install_joboptions( share/optionForTest.txt )
diff --git a/InnerDetector/InDetG4/SCT_G4_SD/share/optionForTest.txt b/InnerDetector/InDetG4/SCT_G4_SD/share/optionForTest.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d326fe9edfdf697b28f4407761e0dd2b1b3f9f7
--- /dev/null
+++ b/InnerDetector/InDetG4/SCT_G4_SD/share/optionForTest.txt
@@ -0,0 +1,3 @@
+ApplicationMgr.ExtSvc += { "StoreGateSvc/DetectorStore", "StoreGateSvc/HistoryStore" };
+AuditorSvc.Auditors  += { "AlgContextAuditor"};
+
diff --git a/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensorSD.h b/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensorSD.h
index 417901b891f485f7d3838558c58778d32a5e04cb..2695af0528bff124219a3fbe3a802ee3a75a16e5 100644
--- a/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensorSD.h
+++ b/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensorSD.h
@@ -15,6 +15,7 @@
 // For the hits
 #include "InDetSimEvent/SiHitCollection.h"
 #include "StoreGate/WriteHandle.h"
+#include <gtest/gtest_prod.h>
 
 // G4 needed classes
 class G4Step;
@@ -22,6 +23,11 @@ class G4TouchableHistory;
 
 class SctSensorSD : public G4VSensitiveDetector
 {
+
+ FRIEND_TEST( SctSensorSDtest, Initialize );
+ FRIEND_TEST( SctSensorSDtest, ProcessHits );
+ FRIEND_TEST( SctSensorSDtest, indexMethod );
+ FRIEND_TEST( SctSensorSDtest, AddHit );
 public:
   // Constructor
   SctSensorSD(const std::string& name, const std::string& hitCollectionName);
@@ -39,7 +45,6 @@ public:
       could get rather tricky, but the idea is to allow fast simulations to use the very
       same SD classes as the standard simulation. */
   template <class... Args> void AddHit(Args&&... args){ m_HitColl->Emplace( args... ); }
-
 private:
   void indexMethod(const G4TouchableHistory *myTouch, double coord1z, int &brlEcap, int &layerDisk, int &etaMod, int &phiMod, int &side);
 protected:
diff --git a/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensor_CTB.h b/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensor_CTB.h
index f50fccae53866c6cddd799c210946a3987610780..28d1a14e919c5c38e2ac36bc7cd8e01523b71b63 100644
--- a/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensor_CTB.h
+++ b/InnerDetector/InDetG4/SCT_G4_SD/src/SctSensor_CTB.h
@@ -16,6 +16,7 @@
 // For the hits
 #include "StoreGate/WriteHandle.h"
 #include "InDetSimEvent/SiHitCollection.h"
+#include <gtest/gtest_prod.h>
 
 // G4 needed classes
 class G4Step;
@@ -25,6 +26,10 @@ class G4TouchableHistory;
 
 class SctSensor_CTB : public G4VSensitiveDetector
 {
+
+ FRIEND_TEST( SctSensor_CTBtest, Initialize );
+ FRIEND_TEST( SctSensor_CTBtest, ProcessHits );
+ FRIEND_TEST( SctSensor_CTBtest, AddHit );
  public:
   // Constructor
   SctSensor_CTB( const std::string& name, const std::string& hitCollectionName );
diff --git a/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensorSD_gtest.cxx b/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensorSD_gtest.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..41fe752ec2aebf85c58448bb9d43ff4b2c14d504
--- /dev/null
+++ b/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensorSD_gtest.cxx
@@ -0,0 +1,211 @@
+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "src/SctSensorSD.h"
+
+#include "gtest/gtest.h"
+
+#include "TestTools/initGaudi.h"
+
+#include "G4HCofThisEvent.hh"
+#include "G4Step.hh"
+#include "G4TouchableHistory.hh"
+
+#include "G4Track.hh"
+#include "G4StepPoint.hh"
+#include "G4DynamicParticle.hh"
+#include "G4ThreeVector.hh"
+#include "G4Box.hh"
+#include "G4NistManager.hh"
+#include "G4Material.hh"
+#include "G4VPhysicalVolume.hh"
+
+#include "G4AtlasTools/DerivedG4PhysicalVolume.h"
+#include "G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h"
+#include "MCTruth/TrackHelper.h"
+
+//set environment
+class GaudiEnvironment : public ::testing::Environment {
+  protected:
+  virtual void SetUp() override {
+    Athena_test::initGaudi("SCT_G4_SD/optionForTest.txt", m_svcLoc);
+  }
+  ISvcLocator* m_svcLoc = nullptr;
+};
+class SctSensorSDtest : public ::testing::Test {	
+  protected:
+    virtual void SetUp() override {
+    }
+
+    virtual void TearDown() override {
+    }
+};
+//end of environment setting
+
+TEST_F( SctSensorSDtest, Initialize ) {
+  G4HCofThisEvent hce;
+  SctSensorSD sd1("name1", "name1" );
+  sd1.Initialize( &hce );
+  ASSERT_TRUE(sd1.m_HitColl.isValid()); //check if initialization of m_HitColl is successful
+}
+
+TEST_F( SctSensorSDtest, ProcessHits ) 
+{
+  G4Step sp;
+  G4TouchableHistory th; 
+  G4HCofThisEvent hce;  
+
+  G4double totalenergydeposit = 3.0;
+  G4String physicalname = "physicalName";
+  G4String logicalname = "BBBBBBBBBTubeGas";
+  G4int copyno = 1000;
+  G4ThreeVector preStepPos = G4ThreeVector(0,0,1);
+  G4ThreeVector postStepPos = G4ThreeVector(0,0,2);
+  G4double globaltime0 = 0.5;
+  G4double kineticenergy0 = 1.5;
+  G4double velocity0 = 99.93100;
+  G4double globaltime = 5.0;
+  G4double kineticenergy = 0.5;
+  G4double globaltime1 = 0.5;
+  G4double kineticenergy1 = 0.5;
+  G4double velocity1 = 99.93100;
+  G4double steplength = 1.0;
+  G4double charge = 1.0;
+  G4int encoding = 22;
+  G4int antiencoding = 22;
+  G4String astring = "Cerenkov";
+  G4ProcessType atype = (G4ProcessType)0;
+  G4String nop1 = "opticalphoton";
+  G4String nop2 = "opticalphoton";
+  G4String nop3 = "photon";
+  DerivedG4SensitiveDetectorTestSetting(sp, totalenergydeposit, physicalname, logicalname, copyno, preStepPos, postStepPos, globaltime0, kineticenergy0, velocity0, globaltime, kineticenergy, globaltime1, kineticenergy1, velocity1, steplength, charge, encoding, antiencoding, astring, atype, nop1, nop2, nop3);
+
+  SctSensorSD sd2("name2", "name2");
+  sd2.Initialize( &hce );
+  sd2.ProcessHits(&sp, &th );
+
+  HepGeom::Point3D<double> P1,P2;
+  P1[SiHit::xEta] = 1;
+  P1[SiHit::xPhi] = 0;
+  P1[SiHit::xDep] = 0;
+  P2[SiHit::xEta] = 2;
+  P2[SiHit::xPhi] = 0;
+  P2[SiHit::xDep] = 0;
+
+  int barcode = 0;
+  HepMcParticleLink plink(barcode);
+
+  SiHitCollection* a = sd2.m_HitColl.ptr();
+  ASSERT_EQ(a->begin()->localStartPosition(), P1); //test if the localStartPosition value of the Hit generated by this member function is right, the same below
+  ASSERT_EQ(a->begin()->localEndPosition(), P2);
+  ASSERT_EQ(a->begin()->energyLoss(), 3.0);
+  ASSERT_EQ(a->begin()->meanTime(), 0.5);
+  ASSERT_EQ(a->begin()->particleLink(), plink);
+  ASSERT_EQ(a->begin()->identify(),4101273733);
+
+  ASSERT_EQ(a->size(), 1); //test the current size of the Hit container
+}
+
+TEST_F( SctSensorSDtest, indexMethod )
+{
+// decorate G4TouchableHistory object that will be used as the actual para of indexMethod
+  G4NavigationHistory* navigationHistory = new G4NavigationHistory();
+  G4String boxName = "name";
+  G4Box* box = new G4Box(boxName, 1.0, 1.0, 1.0);
+  G4NistManager* man = G4NistManager::Instance();
+  G4Material* material = man->FindOrBuildMaterial("G4_AIR");
+  G4String name = "logicalName";
+  G4LogicalVolume fLogical(box, material, name);
+  G4String name1 = "physicalName";
+  G4VPhysicalVolume* pPhysical = NULL;
+  G4MyPhysicalVolume physicalVolume(0, G4ThreeVector(0,0,0), name1, &fLogical, pPhysical);
+  physicalVolume.SetCopyNo(1000);
+  G4int nReplica = 2;
+  navigationHistory->SetFirstEntry(&physicalVolume);
+  navigationHistory->NewLevel(&physicalVolume, kNormal, nReplica);
+  navigationHistory->NewLevel(&physicalVolume, kNormal, nReplica);
+  navigationHistory->NewLevel(&physicalVolume, kNormal, nReplica);
+  navigationHistory->NewLevel(&physicalVolume, kNormal, nReplica);
+  navigationHistory->NewLevel(&physicalVolume, kNormal, nReplica);
+  G4TouchableHistory th(*navigationHistory);
+// end
+
+  G4HCofThisEvent hce;
+
+  double coord1z = 1;
+  int brlEcap = 0;
+  int layerDisk = 0;
+  int etaMod = 0;
+  int phiMod = 0;
+  int side = 0;
+
+  SctSensorSD sd3("name3", "name3");
+  sd3.Initialize( &hce );
+  sd3.indexMethod(&th, coord1z, brlEcap, layerDisk, etaMod, phiMod, side );
+
+  ASSERT_EQ(brlEcap, 0); //test the value of brlEcap changed by the member function indexMethod, it should be 0 in this case. The same below
+  ASSERT_EQ(layerDisk, 1000);
+  ASSERT_EQ(etaMod, 1000);
+  ASSERT_EQ(phiMod, 1000);
+  ASSERT_EQ(side, 1000);
+
+}
+
+TEST_F( SctSensorSDtest, AddHit )
+{
+  HepGeom::Point3D<double> lP1,lP2;
+  lP1[SiHit::xEta] = 1;
+  lP1[SiHit::xPhi] = 0;
+  lP1[SiHit::xDep] = 0;
+  lP2[SiHit::xEta] = 2;
+  lP2[SiHit::xPhi] = 0;
+  lP2[SiHit::xDep] = 0;
+  
+  G4DynamicParticle* dynamicPar = new G4DynamicParticle();
+  G4double aValueTime = 1;
+  G4ThreeVector ValuePosition(1.0, 1.0, 1.0);
+  G4Track track(dynamicPar, aValueTime, ValuePosition);
+  TrackHelper trHelp(&track);
+  
+  int brlEcap = 0;
+  int layerDisk = 0;
+  int etaMod = 0;
+  int phiMod = 0;
+  int side = 0;
+  SctSensorSD sd4("name4", "name4");
+  G4HCofThisEvent hce;
+  sd4.Initialize( &hce );
+  sd4.AddHit(lP1, lP2, 2.0, 1.0, trHelp.GetParticleLink(), 1, brlEcap, layerDisk, etaMod, phiMod, side);
+
+  HepGeom::Point3D<double> P1,P2;
+  P1[SiHit::xEta] = 1;
+  P1[SiHit::xPhi] = 0;
+  P1[SiHit::xDep] = 0;
+  P2[SiHit::xEta] = 2;
+  P2[SiHit::xPhi] = 0;
+  P2[SiHit::xDep] = 0;
+  
+  int barcode = 0;
+  HepMcParticleLink plink(barcode);
+  
+  SiHitCollection* a = sd4.m_HitColl.ptr();
+  ASSERT_EQ(a->begin()->localStartPosition(), P1); //test the localStartPosition value of the Hit generated by the member function AddHit, the same below
+  ASSERT_EQ(a->begin()->localEndPosition(), P2);
+  ASSERT_EQ(a->begin()->energyLoss(), 2.0);
+  ASSERT_EQ(a->begin()->meanTime(), 1.0);
+  ASSERT_EQ(a->begin()->particleLink(), plink);
+  ASSERT_EQ(a->begin()->identify(), 10245);
+  ASSERT_EQ(a->size(), 1); //test the current size of the Hit container
+
+}
+
+int main( int argc, char** argv ) {
+
+  auto g=new GaudiEnvironment;
+  ::testing::AddGlobalTestEnvironment(g);
+  ::testing::InitGoogleTest( &argc, argv );
+  return RUN_ALL_TESTS();
+
+}
+
diff --git a/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensor_CTB_gtest.cxx b/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensor_CTB_gtest.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..c025887a67935d363dcf07d1d70c4ab76d0fff24
--- /dev/null
+++ b/InnerDetector/InDetG4/SCT_G4_SD/test/SctSensor_CTB_gtest.cxx
@@ -0,0 +1,167 @@
+/*
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "src/SctSensor_CTB.h"
+
+#include "gtest/gtest.h"
+
+#include "TestTools/initGaudi.h"
+
+#include "G4HCofThisEvent.hh"
+#include "G4Step.hh"
+#include "G4TouchableHistory.hh"
+
+#include "G4Track.hh"
+#include "G4StepPoint.hh"
+#include "G4DynamicParticle.hh"
+#include "G4ThreeVector.hh"
+#include "G4Box.hh"
+#include "G4NistManager.hh"
+#include "G4Material.hh"
+#include "G4VPhysicalVolume.hh"
+
+#include "G4AtlasTools/DerivedG4PhysicalVolume.h"
+#include "G4AtlasTools/DerivedG4SensitiveDetectorTestSetting.h"
+#include "MCTruth/TrackHelper.h"
+
+//set environment
+class GaudiEnvironment : public ::testing::Environment {
+  protected:
+  virtual void SetUp() override {
+    Athena_test::initGaudi("SCT_G4_SD/optionForTest.txt", m_svcLoc);
+  }
+  ISvcLocator* m_svcLoc = nullptr;
+};
+class SctSensor_CTBtest : public ::testing::Test {	
+  protected:
+    virtual void SetUp() override {
+    }
+
+    virtual void TearDown() override {
+    }
+};
+//end of environment setting
+
+TEST_F( SctSensor_CTBtest, Initialize )
+{
+  G4HCofThisEvent hce;
+  SctSensor_CTB sd1("name1", "name1" );
+  sd1.Initialize( &hce );
+  ASSERT_TRUE(sd1.m_HitColl.isValid());//check if initialization of m_HitColl is successful
+}
+
+TEST_F( SctSensor_CTBtest, ProcessHits )
+{
+  G4Step sp;
+  G4TouchableHistory th; 
+  G4HCofThisEvent hce;
+
+  G4double totalenergydeposit = 3.0;
+  G4String physicalname = "physicalName";
+  G4String logicalname = "BBBBBBBBBTubeGas";
+  G4int copyno = 1000;
+  G4ThreeVector preStepPos = G4ThreeVector(0,0,1);
+  G4ThreeVector postStepPos = G4ThreeVector(0,0,2);
+  G4double globaltime0 = 0.5;
+  G4double kineticenergy0 = 1.5;
+  G4double velocity0 = 99.93100;
+  G4double globaltime = 5.0;
+  G4double kineticenergy = 0.5;
+  G4double globaltime1 = 0.5;
+  G4double kineticenergy1 = 0.5;
+  G4double velocity1 = 99.93100;
+  G4double steplength = 1.0;
+  G4double charge = 1.0;
+  G4int encoding =22;
+  G4int antiencoding = 22;
+  G4String astring = "Cerenkov";
+  G4ProcessType atype = (G4ProcessType)0;
+  G4String nop1 = "opticalphoton";
+  G4String nop2 = "opticalphoton";
+  G4String nop3 = "photon";
+  DerivedG4SensitiveDetectorTestSetting(sp, totalenergydeposit, physicalname, logicalname, copyno, preStepPos, postStepPos, globaltime0, kineticenergy0, velocity0, globaltime, kineticenergy, globaltime1, kineticenergy1, velocity1, steplength, charge, encoding, antiencoding, astring, atype, nop1, nop2, nop3);
+
+  SctSensor_CTB sd2("name2", "name2");
+  sd2.Initialize( &hce );
+  sd2.ProcessHits(&sp, &th );
+
+  HepGeom::Point3D<double> P1,P2;
+  P1[SiHit::xEta] = 1;
+  P1[SiHit::xPhi] = 0;
+  P1[SiHit::xDep] = 0;
+  P2[SiHit::xEta] = 2;
+  P2[SiHit::xPhi] = 0;
+  P2[SiHit::xDep] = 0;
+
+  int barcode = 0;
+  HepMcParticleLink plink(barcode);
+
+  SiHitCollection* a = sd2.m_HitColl.ptr();
+  ASSERT_EQ(a->begin()->localStartPosition(), P1); //test the localStartPosition value of the Hit generated by the member function ProcessHits, and it should be P1 according to my setting, the same below
+  ASSERT_EQ(a->begin()->localEndPosition(), P2);
+  ASSERT_EQ(a->begin()->energyLoss(), 3.0);
+  ASSERT_EQ(a->begin()->meanTime(), 0.5);
+  ASSERT_EQ(a->begin()->particleLink(), plink);
+  ASSERT_EQ(a->begin()->identify(),4093651781);
+
+  ASSERT_EQ(a->size(), 1); //test the size of the Hit container, it should be 1 since just 1 Hit was stored in it
+}
+
+TEST_F( SctSensor_CTBtest, AddHit )
+{
+  HepGeom::Point3D<double> lP1,lP2;
+  lP1[SiHit::xEta] = 1;
+  lP1[SiHit::xPhi] = 0;
+  lP1[SiHit::xDep] = 0;
+  lP2[SiHit::xEta] = 2;
+  lP2[SiHit::xPhi] = 0;
+  lP2[SiHit::xDep] = 0;
+  
+  G4DynamicParticle* dynamicPar = new G4DynamicParticle();
+  G4double aValueTime = 1;
+  G4ThreeVector ValuePosition(1.0, 1.0, 1.0);
+  G4Track track(dynamicPar, aValueTime, ValuePosition);
+  TrackHelper trHelp(&track);
+  
+  int brlEcap = 0;
+  int layerDisk = 0;
+  int etaMod = 0;
+  int phiMod = 0;
+  int side = 0;
+  SctSensor_CTB sd4("name4", "name4");
+  G4HCofThisEvent hce;
+  sd4.Initialize( &hce );
+  sd4.AddHit(lP1, lP2, 2.0, 1.0, trHelp.GetParticleLink(), 1, brlEcap, layerDisk, etaMod, phiMod, side);
+
+  HepGeom::Point3D<double> P1,P2;
+  P1[SiHit::xEta] = 1;
+  P1[SiHit::xPhi] = 0;
+  P1[SiHit::xDep] = 0;
+  P2[SiHit::xEta] = 2;
+  P2[SiHit::xPhi] = 0;
+  P2[SiHit::xDep] = 0;
+  
+  int barcode = 0;
+  HepMcParticleLink plink(barcode);
+  
+  SiHitCollection* a = sd4.m_HitColl.ptr();
+  ASSERT_EQ(a->begin()->localStartPosition(), P1); //test the localStartPosition value of the Hit added by the member function AddHit, and it should be P1 based on the setting, the same below
+  ASSERT_EQ(a->begin()->localEndPosition(), P2);
+  ASSERT_EQ(a->begin()->energyLoss(), 2.0);
+  ASSERT_EQ(a->begin()->meanTime(), 1.0);
+  ASSERT_EQ(a->begin()->particleLink(), plink);
+  ASSERT_EQ(a->begin()->identify(), 10245);
+  ASSERT_EQ(a->size(), 1); //test the current size of the Hit container
+
+}
+
+int main( int argc, char** argv ) {
+
+  auto g=new GaudiEnvironment;
+  ::testing::AddGlobalTestEnvironment(g);
+  ::testing::InitGoogleTest( &argc, argv );
+  return RUN_ALL_TESTS();
+
+}
+
diff --git a/Simulation/G4Atlas/G4AtlasTools/src/G4FieldManagerToolBase.cxx b/Simulation/G4Atlas/G4AtlasTools/src/G4FieldManagerToolBase.cxx
index ae3efd9378b38ca012f4f6cd12bab0eb450e9777..9b82794ab97f1d82717bc475a73ccbb2dd03c7eb 100644
--- a/Simulation/G4Atlas/G4AtlasTools/src/G4FieldManagerToolBase.cxx
+++ b/Simulation/G4Atlas/G4AtlasTools/src/G4FieldManagerToolBase.cxx
@@ -16,18 +16,7 @@
 #include "G4NystromRK4.hh"
 #include "G4ClassicalRK4.hh"
 #include "G4AtlasRK4.hh"
-#include "G4BogackiShampine23.hh"
-#include "G4BogackiShampine45.hh"
-#include "G4CashKarpRKF45.hh"
-#include "G4DoLoMcPriRK34.hh"
-#include "G4DormandPrince745.hh"
-#include "G4DormandPrinceRK56.hh"
-#include "G4DormandPrinceRK78.hh"
-#include "G4RK547FEq1.hh"
-#include "G4RK547FEq2.hh"
-#include "G4RK547FEq3.hh"
-#include "G4RKG3_Stepper.hh"
-#include "G4TsitourasRK45.hh"
+
 // CLHEP includes
 #include "CLHEP/Units/SystemOfUnits.h"
 
@@ -120,18 +109,6 @@ G4FieldManagerToolBase::getStepper(std::string name, G4MagneticField* field) con
   else if (name=="NystromRK4") return new G4NystromRK4(eqRhs);
   else if (name=="ClassicalRK4") return new G4ClassicalRK4(eqRhs);
   else if (name=="AtlasRK4") return new G4AtlasRK4(eqRhs);
-  else if (name=="BogackiShampine23") return new G4BogackiShampine23(eqRhs);
-  else if (name=="BogackiShampine45") return new G4BogackiShampine45(eqRhs);
-  else if (name=="CashKarpRKF45") return new G4CashKarpRKF45(eqRhs);
-  else if (name=="DoLoMcPriRK34") return new G4DoLoMcPriRK34(eqRhs);
-  else if (name=="DormandPrince745") return new G4DormandPrince745(eqRhs);
-  else if (name=="DormandPrinceRK56") return new G4DormandPrinceRK56(eqRhs);
-  else if (name=="DormandPrinceRK78") return new G4DormandPrinceRK78(eqRhs);
-  else if (name=="RK547FEq1") return new G4RK547FEq1(eqRhs);
-  else if (name=="RK547FEq2") return new G4RK547FEq2(eqRhs);
-  else if (name=="RK547FEq3") return new G4RK547FEq3(eqRhs);
-  else if (name=="RKG3_Stepper") return new G4RKG3_Stepper(eqRhs);
-  else if (name=="TsitourasRK45") return new G4TsitourasRK45(eqRhs);
   else {
     ATH_MSG_ERROR("Stepper " << name << " not available! returning NystromRK4!");
     return new G4NystromRK4(eqRhs);