LatValidate.cxx

Go to the documentation of this file.

// $Id: LatValidate.cxx,v 1.4 2003/03/25 07:20:58 west Exp $
//
// LatValidate
//
// Begin_Html<img src="../../pedestrians.gif" align=center>
// <a href="../source_warning.html">Warning for beginners</a>.<br>
// Also see <a href="../../root_crib/index.html">The ROOT Crib</a> and
// <a href="../index.html">The MINOS Class User Guide</a>End_Html
//
// N. West 03/2000
//
// Purpose: Validation system for Lat.
//
//    RunAllTests  can be used to run the full test suite.
//    RunTest      can be used to run a specific test.
//
//
// Example usage:-
// =============
//
//    LatValidate v;
//    v.RunAllTests();
//
//

#include <string.h>

#include "TList.h"

#include "MessageService/MsgService.h"
#include "Lattice/Lattice.h"
#include "Lattice/LatticeBuilder.h"
#include "Lattice/LatticeLink.h"
#include "Lattice/LatticeMaker.h"
#include "Lattice/test/LatValidate.h"


// Some typedefs to eliminate tedious typing.

typedef   Lattice::ID                ID;
typedef   Lattice::VectorID          VectorID;
typedef   VectorID::const_iterator   IDItr;
typedef   LatticeLink                Link;

ClassImp(LatValidate)

//   Internal classes and functions used in Test_3

typedef    Bool_t  AssociateFunc(const TObject*,const TObject*);

class Primary: public TObject {
public:
    Primary(Int_t id): fId(id) {}
   ~Primary() {}
  Int_t GetId() const { return fId; }
private:
    Int_t fId;
};

class Secondary: public TObject {
public:
    Secondary(Int_t id): fIdPrimary(id) {}
   ~Secondary() {}
  Int_t GetIdPrimary() const { return fIdPrimary; }
private:
    Int_t fIdPrimary;
};

static Bool_t MatchPrimSec(const TObject* p,const TObject* s) {
  const Primary*   pp = dynamic_cast<const Primary*>(p);
  const Secondary* ps = dynamic_cast<const Secondary*>(s);
  return ( pp && ps ) ? pp->GetId() == ps->GetIdPrimary() : kFALSE;
}

static Bool_t MatchSecPrim(const TObject* s,const TObject* p) {
  const Primary*   pp = dynamic_cast<const Primary*>(p);
  const Secondary* ps = dynamic_cast<const Secondary*>(s);
  return ( pp && ps ) ? pp->GetId() == ps->GetIdPrimary() : kFALSE;
}

static Long_t PrimaryKey(const TObject* p) {
  const Primary*   pp = dynamic_cast<const Primary*>(p);
  return ( pp ) ?  pp->GetId() : 0;
}

static Long_t SecondaryKey(const TObject* s) {
  const Secondary* ps = dynamic_cast<const Secondary*>(s);
  return ( ps ) ? ps->GetIdPrimary() : kFALSE;
}

//   Definition of static data members
//   *********************************

CVSID("$Id: LatValidate.cxx,v 1.4 2003/03/25 07:20:58 west Exp $");

// Definition of member functions (alphabetical order)
// ***************************************************

//.....................................................................

LatValidate::LatValidate() :
  fNumFail(0),
  fNumPass(0)
{

//  Purpose:   Default constructor.
//  Arguments: None.
//  Return:    None.

//  Contact:   N. West

//  Specification:-
//  =============

//  o  Create default object.


  MSG("Lat",Msg::kVerbose) << "LatValidate ctor 1 at " << this 
                             << "\n";

}


//.....................................................................

LatValidate::~LatValidate() {


//  Purpose:   Destructor.
//  Arguments: None.
//  Return:    None.

//  Contact:   N. West

//  Specification:-
//  =============

//  o  Destroy object.

  MSG("Lat",Msg::kVerbose) << "LatValidate dtor at " << this << "\n";

}


//.....................................................................

Bool_t LatValidate::RunAllTests() {


//  Purpose:   Run all tests.
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.

//  Contact:   N. West


//  Specification:-
//  =============

//  o  Run all tests


  Bool_t ok = kTRUE;

  for ( Int_t testNum = 1; testNum <= kNUMTESTS; testNum++  ) {
    if ( ! RunTest(testNum) ) ok = kFALSE;
  }
  return ok;
}


//.....................................................................

Bool_t LatValidate::RunTest(Int_t testNum) {


//  Purpose:   Run a specific test.
//  Arguments: 
//    testNum      in  Test to be run.

//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  

//  Contact:   N. West

//  Specification:-
//  =============

//  Program Notes
//  =============

//  Banner printing not yet implemented.

//  Dispatch to appropriate test.

  switch ( testNum ) {
  case 1: return Test_1();
  case 2: return Test_2();
  case 3: return Test_3();
  }
  MSG("Lat",Msg::kError) << "Undefined test: " << testNum << "\n";
  return kFALSE;

}
//.....................................................................

Bool_t LatValidate::Test_1() {


//  Purpose:   
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  

//  Contact:   N. West

//  Specification:-
//  =============

//  o Lattice builder tests.
 

  MSG("Lat",Msg::kInfo) 
    << "Test 1: Ignore warnings - they are part of the test." << endl;

  Bool_t ok = kTRUE;

  Lattice lat("apples","oranges",LatticeBase::RLinkMulti);
  LatticeBuilder builder;


  Int_t  obj;
  ID id  = &obj;

  //  Should not be able to add primary without a lattice
  if ( builder.AddPrimary(1,id) ) {
    MSG("Lat",Msg::kError) 
        << "Bulder accepted primary without lattice present"
        << endl;
    ok = kFALSE;
  }

  builder.DockLattice( &lat, Lattice::kLeft );

  //  Should not be able to add secondary without a primary
  if ( builder.AddSecondary(1,id) ) {
    MSG("Lat",Msg::kError) 
        << "Bulder accepted secondary without primary present"
        << endl;
    ok = kFALSE;
  }


  //  Should be able to add primary with a lattice
  if ( ! builder.AddPrimary(1,id) ) {
    MSG("Lat",Msg::kError) 
        << "Bulder did not accepted primary with lattice present"
        << endl;
    ok = kFALSE;
  }

  //  Should be able to add secondary with a primary.
  if ( ! builder.AddSecondary(1,id) ) {
    MSG("Lat",Msg::kError) 
        << "Bulder did not accepted secondary with primary present"
        << endl;
    ok = kFALSE;
  }
  

  //  Should not be able to add secondary with an invalid primary key
  if ( builder.AddSecondary(2,id) ) {
    MSG("Lat",Msg::kError) 
        << "Bulder accepted secondary with invalid primary key"
        << endl;
    ok = kFALSE;
  }


  //  The lattice should now have one primary and one secondary.

  VectorID  primIDs;
  VectorID  secIDs;
  lat.GetAllIDs( Lattice::kLeft,  primIDs);
  lat.GetAllIDs( Lattice::kRight, secIDs);

  if ( 1 != primIDs.size() || 1 != secIDs.size() ) {
    MSG("Lat",Msg::kError) << "Lattice should have 1 primary and 1 "
                           << "secondary. Has primaries: " 
                           << primIDs.size()
                           << ", secondaries: " << secIDs.size()  
                           << endl;
    ok = kFALSE;

  }

  
  MSG("Lat",Msg::kInfo) 
       << "Test 1: LatticeBuilder tests                   ...... ";
  MSG("Lat",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Lat",Msg::kInfo) << "\n";

  if ( ok ) fNumPass++; else fNumFail++;

  return ok;
  
}
//.....................................................................

Bool_t LatValidate::Test_2() {


//  Purpose:   
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  

//  Contact:   N. West

//  Specification:-
//  =============

//  o Set up simple 1:n lattice and check 2-way navigation.
 

  Bool_t ok = kTRUE;

  Lattice lat("apples","oranges",LatticeBase::RLinkMulti);

  //  0 terminated list of secondaries for each primary.

  UInt_t numSecForPrim[] = {5, 10, 3, 7, 0};

  UInt_t  numPrim = 0;
  UInt_t  numSec  = 0;

  for ( Int_t index = 0; numSecForPrim[index]; index++ ) {
    numPrim++;
    numSec += numSecForPrim[index];
  }

  MSG("Lat",Msg::kDebug) << "# primaries: " << numPrim
                         << " # secondaries: " << numSec  << endl;

  // The primaries and secondaries are simple Int_ts stored in a buffer

  Int_t* buffer = new Int_t[numPrim+numSec];
 

  // Fill the Lattice.

  LatticeBuilder builder;
  builder.DockLattice( &lat, Lattice::kLeft );

  Int_t*  objPtr   = buffer;
  for ( Int_t index = 0; numSecForPrim[index]; index++ ) {
    ID prim = objPtr++;
    MSG("Lat",Msg::kDebug) << "Primary " <<  index << " " << prim << endl;
    builder.AddPrimary(index, prim);
  }

  for ( Int_t index = 0; numSecForPrim[index]; index++ ) {
    for ( UInt_t iSec = 0; iSec < numSecForPrim[index]; iSec++ ) {
     ID sec  = objPtr++;
     MSG("Lat",Msg::kDebug) << "Secondary " << index << " " << sec << endl;
     builder.AddSecondary(index, sec);
    }
  }

  builder.DockLattice( 0, Lattice::kLeft );

  // Examine the lattice.


  VectorID  primIDs;
  VectorID  secIDs;
  lat.GetAllIDs( Lattice::kLeft,  primIDs);
  lat.GetAllIDs( Lattice::kRight, secIDs);


//  Check the total number of primaries and secondaries.


  if ( numPrim != primIDs.size() || numSec != secIDs.size() ) {
    MSG("Lat",Msg::kError) << "# primaries: " << primIDs.size()
                           << " != " << numPrim
                           << " || # secondaries: " << secIDs.size()  
                           << " != " << numSec
                           << endl;
    ok = kFALSE;

  }

//  Loop over all primaries checking each has the correct number
//  of secondaries and that each secondary points back to its
//  primary.

  
  Int_t iPrim = 0;
  for ( IDItr pItr = primIDs.begin(); pItr != primIDs.end(); pItr++ ) {
    lat.GetFarIDs( Lattice::kLeft, *pItr, secIDs );

    if ( secIDs.size() != numSecForPrim[iPrim] ) {
      MSG("Lat",Msg::kError) 
        << "Primary: " << iPrim << " has " << secIDs.size()
        << " secondaries but should have " <<  numSecForPrim[iPrim] 
        << endl;
      ok = kFALSE;
    }

    for ( IDItr sItr = secIDs.begin(); sItr != secIDs.end(); sItr++) {
      VectorID primIDs2;
      lat.GetFarIDs( Lattice::kRight, *sItr, primIDs2 );

      if ( primIDs2.size() != 1 || *(primIDs2.begin()) != *pItr ) {
        MSG("Lat",Msg::kError) 
          << "Primary: " << iPrim << " has a bad secondary"
          << " #primary " <<  primIDs2.size() 
          << " pID " << *pItr << " pID2 " << *(primIDs2.begin()) 
          << endl;
        ok = kFALSE;

      }
    }
    iPrim++;
  }


  // Finally remove the buffer.

  delete[] buffer;

  MSG("Lat",Msg::kInfo) 
       << "Test 2: 2-way test over 1:n lattice            ...... ";
  MSG("Lat",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Lat",Msg::kInfo) << "\n";

  if ( ok ) fNumPass++; else fNumFail++;

  return ok;
  
}

//.....................................................................

Bool_t LatValidate::Test_3() {


//  Purpose:   
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  

//  Contact:   N. West

//  Specification:-
//  =============

//  o Testing of LatticeMaker
 

  Bool_t ok = kTRUE;


// Create collections of primaries and secondaries.

  TList primaries;
  TList secondaries;
  UInt_t numSecondaries = 0;

  enum { NUM_PRIMARIES = 5 };
  Int_t NumSecForPrimary[NUM_PRIMARIES] = { 7, 9, 0, 4, 1 };

  for ( Int_t iPrim = 0; iPrim < NUM_PRIMARIES; ++iPrim) {
    primaries.AddLast(new Primary(iPrim));
    numSecondaries += NumSecForPrimary[iPrim];

    for ( Int_t iSec = 0; iSec < NumSecForPrimary[iPrim]; ++iSec ) {
      secondaries.AddLast(new Secondary(iPrim));
    }
  }


// Build  lattices in various ways and check them out.

  LatticeMaker maker;
  const char* testNames[] = { "n:m with 1 func",
                              "1:n with 1 func",
                              "n:1 with 1 func",
                              "1:n with 2 funcs" };


  for (UInt_t test =0; test < 4; ++test) {

    Lattice* lat = 0;
    switch ( test ) {
    case 0:
      lat = maker.CreateLattice(&primaries,
                                &secondaries,
                                MatchPrimSec,
                                "n:m");
      break;
    case 1:
      lat = maker.CreateLattice(&primaries,
                                &secondaries,
                                MatchPrimSec,
                                "1:n");
      break;
    case 2:
      lat = maker.CreateLattice(&secondaries,
                                &primaries,
                                MatchSecPrim,
                                "n:1");
      break;
    case 3:
      lat = maker.Create1ToNLattice(&primaries,
                                &secondaries,
                                PrimaryKey,
                                SecondaryKey);
      break;

    }
  
//  Check the sizes.

    VectorID  primIDs;
    VectorID  secIDs;
    if ( test != 2 ) {
      lat->GetAllIDs( Lattice::kLeft,  primIDs);
      lat->GetAllIDs( Lattice::kRight, secIDs);
    } else {
      lat->GetAllIDs( Lattice::kRight, primIDs);
      lat->GetAllIDs( Lattice::kLeft,  secIDs);
    }
  
// One primary has no secondary so is not in the lattice.
    if (    primIDs.size() != NUM_PRIMARIES-1 
         || secIDs.size()  != numSecondaries ) {
      MSG("Lat",Msg::kError)
          << "sub-test " << test << "(" << testNames[test]
          << ") No. of primaries " << primIDs.size()  
          << " but should be " << NUM_PRIMARIES-1
          << ", No. of secondaries " << secIDs.size()
          << " but should be " <<  numSecondaries 
          << endl;
      ok = kFALSE;
  
    }

    
// Loop over all primaries, checking that each has the right number
// of secondaries.

    IDItr pItr = primIDs.begin();
    for ( Int_t iPrim = 0; iPrim < NUM_PRIMARIES; ++iPrim) {
      UInt_t numSec = NumSecForPrimary[iPrim];
      if ( numSec == 0 ) continue;
      if ( test != 2 ) lat->GetFarIDs(Lattice::kLeft,  *pItr, secIDs);
      else             lat->GetFarIDs(Lattice::kRight, *pItr, secIDs);
      if (  secIDs.size() != numSec )  {
        MSG("Lat",Msg::kError)
            << "sub-test " << test << "(" << testNames[test]
            << ") For primary " << iPrim  
            << ", No. of secondaries " << secIDs.size()
            << " but should be " <<  numSec 
            << endl;
        ok = kFALSE;
      }
      ++pItr;
    }

    delete lat;
  }

  MSG("Lat",Msg::kInfo) 
       << "Test 3: 1:n, n:1 and n:m LatticeMaker test     ...... ";
  MSG("Lat",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Lat",Msg::kInfo) << "\n";

  if ( ok ) fNumPass++; else fNumFail++;

  return ok;
  
}

---