NavValidate.cxx

Go to the documentation of this file.

// $Id: NavValidate.cxx,v 1.17 2007/02/01 22:11:53 rhatcher Exp $
//
// NavValidate
//
// 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:-
// =============
//
//    NavValidate v;
//    v.RunAllTests();
//
//

#include <string.h>
#include "MessageService/MsgService.h"
#include "LeakChecker/Lea.h"
#include "LeakChecker/LeaLeakChecker.h"
#include "Lattice/Lattice.h"
#include "Navigation/NavGenLattice.h"
#include "Navigation/NavGenTCollection.h"
#include "Navigation/NavItr.h"
#include "Navigation/NavItrT.h"
#include "Navigation/NavKey.h"
#include "Navigation/NavMask.h"
#include "Navigation/NavPrimer.h"
#include "Navigation/NavSet.h"
#include "Navigation/test/NavTestPlanet.h"
#include "Navigation/test/NavTestMoon.h"
#include "Navigation/test/NavValidate.h"
#include "TObjArray.h"
#include "TCollection.h"
#include "TList.h"

// Some typedefs to eliminate tedious typing.

typedef   Lattice::ID                ID;
typedef   Lattice::VectorID          VectorID;
typedef   NavMask::Mask_t            Mask_t;

//   Private functions and functors  used in validation.  
//   See Tests 2, 5, 6 and 8.

static NavKey KeyPlanet_Name(TObject* obj) { 
  return ((NavTestPlanet*)obj)->GetName(); 
}

static NavKey KeyPlanet_NameSafe(const NavTestPlanet* obj) { 
  return obj->GetName(); 
}

static NavKey KeyMoon_NameSafe(const NavTestMoon* obj) { 
  return obj->GetName(); 
}

static NavKey KeyMoon_ParentSafe(const NavTestMoon* obj) { 
  return obj->GetParent(); 
}

static NavKey KeyPlanet_OrderSafe(const NavTestPlanet* obj) { 
  return obj->GetOrder(); 
}

static NavKey KeyPlanet_MassSafe(const NavTestPlanet* obj) { 
  return obj->GetMass(); 
}

static NavKey KeyPlanet_Order(TObject* obj) { 
  return ((NavTestPlanet*)obj)->GetOrder(); 
}

static NavKey KeyMoon_Parent(TObject* obj) { 
  return ((NavTestMoon*)obj)->GetParent(); 
}

static NavKey KeyMoon_Order(TObject* obj) { 
  return ((NavTestMoon*)obj)->GetOrder(); 
}

static NavKey SelPlanet(const NavTestPlanet* obj) { 
  return (   obj->GetOrder() < 4
          || ( obj->GetOrder() > 6 && obj->GetOrder() < 9 ) ); 
}


class MoonKeyFunctor : public NavTestMoonKeyFunctor {
public:
   MoonKeyFunctor(string lo = "",string hi = "");
   MoonKeyFunctor(const MoonKeyFunctor& that) 
     : NavTestMoonKeyFunctor(that) 
       { LEA_CTOR_NM("MoonKeyFunctor",this); *this = that; };
  ~MoonKeyFunctor(){ LEA_DTOR_NM("MoonKeyFunctor",this) }
  virtual NavTestMoonKeyFunctor* Clone() const { return 
                                            new MoonKeyFunctor(*this); }
  virtual NavKey operator()(const NavTestMoon* obj) const;
private:
  string fLoName;
  string fHiName;
};
MoonKeyFunctor::MoonKeyFunctor(string lo,string hi) :
fLoName(lo),
fHiName(hi)
{ LEA_CTOR_NM("MoonKeyFunctor",this) }
NavKey MoonKeyFunctor::operator()(const NavTestMoon* obj) const {
  string name = obj->GetName();
  if ( fLoName != "" && name < fLoName ) return 0;
  if ( fHiName != "" && name > fHiName ) return 0;
  return 1;
}

XXXITRIMP(TObject)

ClassImp(NavValidate)

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

CVSID("$Id: NavValidate.cxx,v 1.17 2007/02/01 22:11:53 rhatcher Exp $");

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

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

void NavValidate::EraseTestObjects() {
//
//
//  Purpose:   Erase the set of test objects created by 
//             PrepareTestObjects.
//  Arguments: None.
//  Return:    = n/a 
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
// o  Delete generators adopted by singleton NavPrimer.
//
// o  Delete TCollections fPlanets and fMoons.
 

  NavPrimer* primer = NavPrimer::Instance();

  primer->DeleteAdoptedGenerators();
  fMoons->Delete();
  delete fMoons; 
  LEA_DTOR_NM("TList",fMoons) 
  fMoons   = 0;

  fPlanets->Delete();
  delete fPlanets;
  LEA_DTOR_NM("TList",fPlanets) 

  fPlanets = 0;   
}

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

TCollection* NavValidate::MakeTCollection(Int_t model /*= 0*/) const {
//
//  Purpose:   Create a test TCollection.
//  Arguments:
//    model        in  Model number:-
//                      = 0  Planets
//                      = 1  Moons
//
//  Return:    new TCollection.  Caller must delete!!
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Create heap TCollection, fill with NavTestPlanet objects and
//     return to user.

//  Program Notes:-
//  =============

//  TCollection is abstract so we make a TList - but any concrete
//  class inheriting from TCollection should do.

  TList* tcol = new TList();

  LEA_CTOR_NM("TList",tcol);

  switch ( model ) {

  case 0:

  
    tcol->Add( new NavTestPlanet("Mercury",  1,  0.055 ) );
    tcol->Add( new NavTestPlanet("Venus  ",  2,  0.81  ) );
    tcol->Add( new NavTestPlanet("Earth",    3,  1.00  ) );
    tcol->Add( new NavTestPlanet("Mars",     4,  0.11  ) );
    tcol->Add( new NavTestPlanet("Jupiter",  5,  318.0 ) );
    tcol->Add( new NavTestPlanet("Saturn",   6,  95.0  ) );
    tcol->Add( new NavTestPlanet("Uranus",   7,  15.0  ) );
    tcol->Add( new NavTestPlanet("Neptune",  8,  17.0  ) );
    tcol->Add( new NavTestPlanet("Pluto",    9,  0.002 ) );
  
    return tcol;

  case 1:

  
    tcol->Add( new NavTestMoon("Moon",    "Earth",    3 ) );
    tcol->Add( new NavTestMoon("Phobos",  "Mars",     4 ) );
    tcol->Add( new NavTestMoon("Deimos",  "Mars",     4 ) );
    tcol->Add( new NavTestMoon("Io",      "Jupiter",  5 ) );
    tcol->Add( new NavTestMoon("Europa",  "Jupiter",  5 ) );
    tcol->Add( new NavTestMoon("Ganymed", "Jupiter",  5 ) );
    tcol->Add( new NavTestMoon("Callist", "Jupiter",  5 ) );
    tcol->Add( new NavTestMoon("Titan",   "Saturn",   6 ) );
    tcol->Add( new NavTestMoon("Ariel",   "Uranus",   7 ) );
    tcol->Add( new NavTestMoon("Umbriel", "Uranus",   7 ) );
    tcol->Add( new NavTestMoon("Triton",  "Neptune",  8 ) );
  
    return tcol;

  default:

    MSG("Nav",Msg::kError) << "Unknown model" << model << endl;

    tcol->Delete();
    delete tcol;
    LEA_DTOR_NM("TList",tcol)

    return 0;
  }
}

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

NavValidate::NavValidate() :
  fNumFail(0),
  fNumPass(0),
  fMoons(0),
  fPlanets(0)
{
//
//  Purpose:   Default constructor.
//  Arguments: None.
//  Return:    None.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Create default object.


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

}


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

NavValidate::~NavValidate() {
//
//
//  Purpose:   Destructor.
//  Arguments: None.
//  Return:    None.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Destroy object.

  MSG("Nav",Msg::kVerbose) << "NavValidate dtor at " << this << "\n";

}


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

void NavValidate::PrepareTestObjects() {
//
//
//  Purpose:   Prepare a set of test objects.
//  Arguments: None.
//  Return:    = n/a 
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Build TCollections fPlanets and fMoons.
//
// o  Load singleton NavPrimer with generators for the above TCollections
//    and also Lattices using two different relationships between them.
 

//  Create generators for NavTestPlanet and NavTestMoon TCollections
//  and Lattices and give them to NavPrimer.

  fMoons   = MakeTCollection(1);
  fPlanets = MakeTCollection(0);

  NavPrimer* primer = NavPrimer::Instance();

  primer->AdoptGenerator( 
           new NavGenTCollection("NavTestPlanet", fPlanets)  );
  primer->AdoptGenerator( 
           new NavGenTCollection("NavTestMoon",   fMoons)  );

  primer->AdoptGenerator( 
           new NavGenLattice("NavTestPlanet", KeyPlanet_Order,
                             "NavTestMoon",   KeyMoon_Order,  0 )  );
  primer->AdoptGenerator( 
           new NavGenLattice("NavTestPlanet", KeyPlanet_Name,
                             "NavTestMoon",   KeyMoon_Parent, 1 )  );
    
}

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

Bool_t NavValidate::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
//
//  o  Check for leaks.


//  Clear leak checker.

  LeaLeakChecker* lea = LeaLeakChecker::Instance();
  lea->Reset();

//  Run all tests.

  Bool_t ok = kTRUE;
  Nav::SetLogLevel(Msg::kInfo);

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

// Delete any residual objects and check for leaks.

  delete NavPrimer::Instance();

  if ( lea->GetNumCreated() == 0 ) {
    MSG("Nav",Msg::kInfo) << "Warning: Leak checking disabled!!"
                          << endl;
  }
  else if ( lea->GetNumActive() ) {
    MSG("Nav",Msg::kInfo) << "\nError, leaks detected! " << lea;
    ok = kFALSE;
  }
  else  {
    MSG("Nav",Msg::kInfo) << "\nO.K., no leaks detected! " << lea;
  }

  MSG("Nav",Msg::kInfo) << "\nOverall test status: " 
                        << ( ok ? "O.K.\n" : "failed!\n") << endl;

  return ok;
}


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

Bool_t NavValidate::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();
  case 4:  return Test_4();
  case 5:  return Test_5();
  case 6:  return Test_6();
  case 7:  return Test_7();
  case 8:  return Test_8();
  case 9:  return Test_9();
  case 10: return Test_10();
 }
  MSG("Nav",Msg::kError) << "Undefined test: " << testNum << "\n";
  return kFALSE;

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

Bool_t NavValidate::Test_1() {
//
//
//  Purpose:  Iterators over simple set. 
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Check set size from TCollection and TIiter.
//
//  o Iterator accesses valid objects (ensures TObject addresses
//    correctly converted).
//
//  o Iterating in both directions.
//
//  o Iterator invalid outside range.
//
//  o Cannot instantiate iterator of wrong type.
 
  Bool_t ok = kTRUE;

// Create TCollection and iterator.

  TCollection* tcol = MakeTCollection();
  UInt_t tcolSize = tcol->Capacity();
  NavTestPlanetItr itr(tcol);

  TIter rootIter(tcol);
  NavTestPlanetItr  itr2(&rootIter);
  NavTestPlanetItr  itr2a(rootIter);


//  Check set size.  Tests: Size.

  UInt_t size = itr.Size();
  if (    size         != tcolSize 
       || itr2.Size()  != tcolSize
       || itr2a.Size() != tcolSize  ) {
    MSG("Nav",Msg::kError) 
      << "Set sizes are: " << size << "," << itr2.Size() 
      << itr2a.Size() << " should be " << tcolSize << endl;
    ok = kFALSE;
  }

//  Iterator accesses valid objects. Tests: IsValid, Ptr, Obj.

  if ( ! itr.IsValid() ) {
    MSG("Nav",Msg::kError) 
        << "Iterator not initialise to an object" << endl;
    ok = kFALSE;
  }
  else if ( strcmp( itr.Ptr()->GetName(), "Mercury") 
                 || itr.Ptr()->GetOrder() != 1 ) {
    MSG("Nav",Msg::kError) 
        << "Iterator not initialised to first object:-" << endl
        << itr.Ptr()->GetName() << " " << itr.Ptr()->GetOrder() << " "
        << itr.Ptr()->GetMass() << " using Ptr()" << endl;
    ok = kFALSE;
  }
  else if ( strcmp( itr.Ptr()->GetName(), "Mercury") 
                 || itr.Ptr()->GetOrder() != 1 ) {
    MSG("Nav",Msg::kError) 
        << "Iterator not initialised to first object:-" << endl
        << itr.Ptr()->GetName() << " " << itr.Ptr()->GetOrder() << " "
        << itr.Ptr()->GetMass() << " using Obj()" << endl;
    ok = kFALSE;
  }

//  Iterating in both directions. Tests: ResetLast, *, ++, --

  UInt_t nreve = 0;
  itr.ResetLast();
  while ( *itr ) {
    nreve++;
    --itr;
  }

  UInt_t nforw = 0;
//  Iterator should be before first, conveniently to test 
//  combined operations 
  while ( *++itr ) nforw++;

  if ( nreve != tcolSize || nforw != tcolSize ) {
    MSG("Nav",Msg::kError) 
        << "Iterating using ++ and -- give " << nforw 
        << "," << nreve << " but should give " << tcolSize << endl;
    ok = kFALSE;
  }

//  Iterating in both directions. Tests: ResetFirst, ResetLast,
//                                       Next, PrevPtr.

  
  itr.ResetFirst();
  nforw = 1;
  while ( itr.Next() ) nforw++;

  itr.ResetLast();
  nreve = 1;
  while ( itr. PrevPtr() ) nreve++;


  if ( nreve != tcolSize || nforw != tcolSize ) {
    MSG("Nav",Msg::kError) 
        << "Iterating using Next and PrevPtr give " << nforw 
        << "," << nreve << " but should give " << tcolSize << endl;
    ok = kFALSE;
  }

//  Iterating in both directions. Tests: SetDirection, ().

  itr.ResetFirst();
  itr.SetDirection(1);
  nforw = 0;
  while ( itr() ) nforw++;

  itr.ResetLast();
  nreve = 0;
  while ( itr() ) nreve++;

  if ( nreve != tcolSize || nforw != tcolSize ) {
    MSG("Nav",Msg::kError) 
        << "Iterating using operator() give " << nforw 
        << "," << nreve << " but should give " << tcolSize << endl;
    ok = kFALSE;

  }


//  Iterator invalid outside range.  Tests: IsValid (again).

  itr.ResetFirst();
  --itr;
  if ( itr.IsValid() ) {
    MSG("Nav",Msg::kError) 
        << "Iterator valid before first entry" << endl;
    ok = kFALSE;
  }
  itr.ResetLast();
  ++itr;
  if ( itr.IsValid() ) {
    MSG("Nav",Msg::kError) 
        << "Iterator valid after last entry" << endl;
    ok = kFALSE;
  }


//  Cannot instantiate iterator of wrong type.
    
  MSG("Nav",Msg::kInfo) << "This test should fail!"  << endl;

  NavItr bad(tcol,"WrongObject");

  if ( bad.Size() != 0 ) {
    MSG("Nav",Msg::kError) 
        << "NavItr accepted TCollection of wrong objects" << endl;
    ok = kFALSE;
  }
  
// Test of default ctor
  
// Don't use the standard NavTest* objects; we don't want
// any default collections to be built.

  TObject obj1, obj2, obj3;
  TObjArray objArray;
// Yes I know I shouldn't put stack objects in a container,
// but its on the stack too.
  objArray.Add( &obj1);
  objArray.Add( &obj2);
  objArray.Add( &obj3);
  TObjectItr itrObj;
  itrObj.Attach(&objArray);
  if (itrObj.Size() != 3) {
    MSG("Nav",Msg::kError) 
        << "Test of default ctor failed.  Size should be 3 but gave "
        << itrObj.Size() << endl;
    ok = kFALSE;
  }


  
// Tidy up.

  tcol->Delete();
  delete tcol;
  LEA_DTOR_NM("TList",tcol)

  MSG("Nav",Msg::kInfo) 
       << "Test  1: Iterators over simple set              ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

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

Bool_t NavValidate::Test_2() {
//
//
//  Purpose:   Primer and Generators.
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Build TCollections and Lattices from NavTestPlanet and NavTestMoon
//    classes using NavPrimer and its associated generators.
 
  Bool_t ok = kTRUE;


//  Prepare test setup.

  PrepareTestObjects();

  UInt_t numMoons   = fMoons->Capacity();
  UInt_t numPlanets = fPlanets->Capacity();

// Mercury, Venus and Pluto don't have moons so won't be in the Lattice.
  UInt_t numPlanetsWithMoons = numPlanets - 3;

  NavPrimer* primer = NavPrimer::Instance();

//  Ask NavPrimer to create Lattices for both relationships.  This
//  will test both Lattice and TCollection generators.

  VectorID  planetIDs;
  VectorID  moonIDs;

  const Lattice* lat0 = primer->FindLattice("NavTestPlanet",
                                            "NavTestMoon",
                                            0);
  if ( ! lat0 ) {
    MSG("Nav",Msg::kError) 
        << "Lattice 0 was not created "<< endl;
    ok = kFALSE;
  }
  else {
    lat0->GetAllIDs( Lattice::kLeft,  planetIDs);
    lat0->GetAllIDs( Lattice::kRight, moonIDs);

    if (    moonIDs.size()   != numMoons
         || planetIDs.size() != numPlanetsWithMoons ) {
      MSG("Nav",Msg::kError) 
          << "Lattice 0 has planets,moons: " << planetIDs.size() << ","
          << moonIDs.size() << " but should have: " 
          << numPlanetsWithMoons << "," << numMoons << endl;
      ok = kFALSE;
    }
  }

  planetIDs.clear();
  moonIDs.clear();

  const Lattice* lat1 = primer->FindLattice("NavTestPlanet",
                                            "NavTestMoon",
                                            1);
  if ( ! lat1 ) {
    MSG("Nav",Msg::kError) 
        << "Lattice 0 was not created "<< endl;
    ok = kFALSE;
  }
  else {
    lat1->GetAllIDs( Lattice::kLeft,  planetIDs);
    lat1->GetAllIDs( Lattice::kRight, moonIDs);
  
    if (    moonIDs.size()   != numMoons
         || planetIDs.size() != numPlanetsWithMoons ) {
      MSG("Nav",Msg::kError) 
          << "Lattice 1 has planets,moons: " << planetIDs.size() << ","
          << moonIDs.size() << " but should have: " 
          << numPlanetsWithMoons << "," << numMoons << endl;
      ok = kFALSE;
    }
  }


//  Erase test setup.

  EraseTestObjects();

  
  MSG("Nav",Msg::kInfo) 
       << "Test  2: Primer and Generators.                 ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

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

Bool_t NavValidate::Test_3() {
//
//
//  Purpose:   
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Test mapping both ways across a NavPrimer generated Lattice.
 
  Bool_t ok = kTRUE;

//  Prepare test setup.

  PrepareTestObjects();

  UInt_t numMoons   = fMoons->Capacity();
  UInt_t numPlanets = fPlanets->Capacity();

// Mercury, Venus and Pluto don't have moons so won't be in the Lattice.
  UInt_t numPlanetsWithMoons = numPlanets - 3;


//  Use Planet:Moon Lattice relationship 0 prebuilt into NavPrimer to set
//  up iterators.

  NavTestPlanetItr pItr("NavTestMoon",0);
  NavTestMoonItr   mItr("NavTestPlanet",0);

  UInt_t np = 0;
  UInt_t nm = 0;
  NavTestPlanet* p = 0;
  NavTestMoon*   m = 0;

//  Loop over planets, checking and counting their moons.

  p = pItr.Ptr();
  while ( p ) {
    m = mItr.Map(p);
    while ( m ) {
      if ( strcmp( m->GetParent(), p->GetName()) ) {
        MSG("Nav",Msg::kError) 
          << "Planet/Moon name mismatch:" << p->GetName()
          <<   ":" << m->GetParent() << endl;
        ok = kFALSE;
      }
      nm++;
      m = mItr.NextPtr();
    }
    np++;
    p = pItr.NextPtr();
  }

  if ( np != numPlanetsWithMoons || nm != numMoons ) {
    MSG("Nav",Msg::kError) 
        << "Iterating Lattice planet,moon gives planet,moon counts " 
        << np << "," << nm << "but should give " 
        << numPlanetsWithMoons << "," << numMoons << endl;
    ok = kFALSE;
  }

//  Loop over moons, checking and their parent planet.

//  Need to break mapping to last planet if above loop.
//  This will also reset to the first moon.
  mItr.Map(0);

  nm = 0;

  m = mItr.Ptr();
  while ( m ) {
    p = pItr.Map(m);
    if ( strcmp( m->GetParent(), p->GetName()) ) {
      MSG("Nav",Msg::kError) 
        << "Planet/Moon name mismatch:" << p->GetName()
        <<  ":" << m->GetParent() << endl;
      ok = kFALSE;
    }
    nm++;
    m = mItr.NextPtr();
  }

  if ( nm != numMoons ) {
    MSG("Nav",Msg::kError) 
        << "Iterating Lattice moon,planet gives moon counts " 
        << nm << " but should give " << numMoons << endl;
    ok = kFALSE;
  }


//  Test out NavPrimer supplied TCollection iterators.

  NavTestPlanetItr p2Itr;
  NavTestMoonItr   m2Itr;

  np = p2Itr.Size();
  nm = m2Itr.Size();

  if ( np != numPlanets || nm != numMoons ) {
    MSG("Nav",Msg::kError) 
        << "Size of TCollection gives planet.moon counts" 
        << np << "," << nm << " but should give " 
        << numPlanets << "," << numMoons << endl;
    ok = kFALSE;
  }

//  Erase test setup.

  EraseTestObjects();

  
  MSG("Nav",Msg::kInfo) 
       << "Test  3: Lattice mapping.                       ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

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

Bool_t NavValidate::Test_4() {
//
//
//  Purpose:  Copy ctors and assignment.  
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create iterators using copy constructors.
//
//  o Update iterator by assign both with and between sets.
 
  Bool_t ok = kTRUE;

// Create TCollection and iterator.

  TCollection* tcol = MakeTCollection(1);
  NavTestMoonItr itr(tcol);


//  Use a copy constructor and show associated with same set.

  NavTestMoonItr itr2(itr);

  if ( itr.Size() != itr2.Size() || itr.GetSet() != itr2.GetSet() ) {
    MSG("Nav",Msg::kError) 
        << "Copy ctor does not create an identical iterator. " 
        << "Sizes:" << itr.Size() << "," << itr2.Size()
        << " NavSet pointers: " << itr.GetSet() << ","
        << itr2.GetSet() << endl;
    ok = kFALSE;
  }
//  Use a copy constructor and show associated with same set.

  NavItrT<NavTestMoon> itr99(tcol);

  while ( const NavTestMoon* ptr =itr99() ) cout << "Testing ... " << ptr->GetName() << endl;


// Move first iterator on and then reassign second and show that
//  it is in step.

  ++itr;
  ++itr;
  itr2 = itr;

  if ( itr.GetIndex() != itr2.GetIndex() || itr.GetSet() != itr2.GetSet() ) {
    MSG("Nav",Msg::kError) 
        << "Assignment does not create an identical iterator. " 
        << "Index:" << itr.GetIndex() << "," << itr2.GetIndex()
        << " NavSet pointers: " << itr.GetSet() << ","
        << itr2.GetSet() << endl;
    ok = kFALSE;
  }

//  Now create a second set and transfer iterator to it.

  NavTestMoonItr itr3(tcol);
  itr2 = itr3;

  if ( itr3.Size() != itr2.Size() || itr3.GetSet() != itr2.GetSet() ) {
    MSG("Nav",Msg::kError) 
        << "Assignment to diff set  does not create an identical iterator. " 
        << "Sizes:" << itr3.Size() << "," << itr2.Size()
        << " NavSet pointers: " << itr3.GetSet() << ","
        << itr2.GetSet() << endl;
    ok = kFALSE;
  }

 

// Tidy up.

  tcol->Delete();
  delete tcol;
  LEA_DTOR_NM("TList",tcol)
  
  MSG("Nav",Msg::kInfo) 
       << "Test  4: Copy ctors and assignment.             ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

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

Bool_t NavValidate::Test_5() {
//
//
//  Purpose:   Sorting and Slicing
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Sort by character string and by integer.
//
//  o Slice by character string and integer.
//
//  o Cannot pass wrong ordering function.
//
//  o Can unsort and unslice.

 
  Bool_t ok = kTRUE;

// Create Standard test objects, TCollection and iterator.

  PrepareTestObjects();
  NavTestPlanetItr itr(fPlanets);
  UInt_t numUnsliced = itr.Size();

// Test unsliced set size.

  UInt_t numSel = itr.SizeSelect();
  if ( numSel != numUnsliced ){
    MSG("Nav",Msg::kError) 
        << "Unsliced set size != full size " 
        << "Size.SizeSelect :" << numUnsliced  << "," << numSel
        << endl;
    ok = kFALSE;
    }


// Sort by character.

  NavTestPlanetKeyFunc* pFunc = itr.CreateKeyFunc();
  pFunc->SetFun(KeyPlanet_NameSafe);
  itr.GetSet()->AdoptSortKeyFunc(pFunc);
  pFunc = 0;

  itr.ResetFirst();
  NavTestPlanet* p = itr.Ptr();
  const Char_t* oldName = p->GetName();
  ++itr;
  while ( ( p = itr.Ptr()) ) {
    if ( strcmp(oldName,p->GetName()) >= 0 ) {
      MSG("Nav",Msg::kError) 
          << "Character sort out of order. " 
          << "Previous, current :" << oldName  << "," << p->GetName()
          << endl;
      ok = kFALSE;
    }
    oldName = p->GetName();
    ++itr;
  }

//  Slice by character.

  const Char_t* loName = "J";
  const Char_t* hiName = "Mea";
  UInt_t numCharSlice = 2;

  itr.GetSet()->Slice( loName, hiName);
  numSel = 0;
  while ( ( p = itr.Ptr()) ) {
    const Char_t* pName = p->GetName();
    if ( strcmp(pName,loName) < 0 || strcmp(pName,hiName) > 0 ) {
      MSG("Nav",Msg::kError) 
          << "Character slice out of range: lo,current,hi: " 
          << loName  << "," << pName << "," << hiName
          << endl;
      ok = kFALSE;
    }
    ++itr;
    numSel++;
  }

  if ( itr.SizeSelect() != numSel 
       || numSel != numCharSlice) {
     MSG("Nav",Msg::kError) 
         << "Char slice: num selected does not match SizeSelect"
         << " or expected: " 
         << "num sel, SizeSelect(), expected " << numSel << "," 
         << itr.SizeSelect() << ","  << numCharSlice
         << endl;
     ok = kFALSE;
  }

  if ( itr.Size() != numUnsliced ) {
     MSG("Nav",Msg::kError) 
         << "Float slice:unsliced size does not match Size(): " 
         << "num unsliced, Size() " << numUnsliced << "," << itr.Size()
         << endl;
     ok = kFALSE;
  }

  itr.GetSet()->Slice();

  if ( itr.SizeSelect() != numUnsliced ) {
     MSG("Nav",Msg::kError) 
         << "Char cancelled slice:does not match Size(): " 
         << "SizeSelect(), num unsliced " << itr.SizeSelect() << ","
         << numUnsliced << endl;
     ok = kFALSE;
  }

// Sort second iterator  by float.

  NavTestPlanetItr itr2(fPlanets);

  pFunc = itr2.CreateKeyFunc();
  pFunc->SetFun(KeyPlanet_MassSafe);
  itr2.GetSet()->AdoptSortKeyFunc(pFunc);
  pFunc = 0;

  itr2.ResetFirst();
  p = itr2.Ptr();
  Float_t oldMass = p->GetMass();
  ++itr2;
  while ( (p = itr2.Ptr()) ) {
    if ( oldMass >= p->GetMass() ) {
      MSG("Nav",Msg::kError) 
          << "Float sort out of order. " 
          << "Previous, current " << oldMass  << "," << p->GetMass()
          << endl;
      ok = kFALSE;
    }
    oldMass = p->GetMass();
    ++itr2;
  }

//  Slice by float.

  Float_t  loMass = 5.;
  Float_t  hiMass = 10000.;
  UInt_t numFloatSlice = 4;

  itr2.GetSet()->Slice( loMass, hiMass);
  numSel = 0;
  while ( ( p = itr2.Ptr()) ) {
    Float_t pMass = p->GetMass();
    if ( pMass < loMass || pMass > hiMass ) {
      MSG("Nav",Msg::kError) 
          << "Float slice out of range: lo,current,hi: " 
          << loMass  << "," << pMass << "," << hiMass
          << endl;
      ok = kFALSE;
    }
    ++itr2;
    numSel++;
  }

  if (     itr2.SizeSelect() != numSel 
       ||  numSel != numFloatSlice ) {
     MSG("Nav",Msg::kError) 
         << "Float slice: num selected does not match SizeSelect or"
         << " expected: " 
         << "num sel, SizeSelect(), expected " << numSel << ","
         << itr2.SizeSelect() << "," << numFloatSlice
         << endl;
     ok = kFALSE;
  }

  if ( itr2.Size() != numUnsliced ) {
     MSG("Nav",Msg::kError) 
         << "Float slice:unsliced size does not match Size(): " 
         << "num unsliced, Size() " << numUnsliced << ","   
         << itr2.Size() << endl;
     ok = kFALSE;
  }

  itr2.GetSet()->Slice();

  if ( itr2.SizeSelect() != numUnsliced ) {
     MSG("Nav",Msg::kError) 
         << "Float cancelled slice:does not match Size(): " 
         << "SizeSelect(), num unsliced " << itr2.SizeSelect() << ","
         << numUnsliced << endl;
     ok = kFALSE;
  }

// Sort second iterator by integer.


  pFunc = itr2.CreateKeyFunc();
  pFunc->SetFun(KeyPlanet_OrderSafe);
  itr2.GetSet()->AdoptSortKeyFunc(pFunc);
  pFunc = 0;

  itr2.ResetFirst();
  p = itr2.Ptr();
  Int_t oldOrder = p->GetOrder();
  ++itr2;
  while ( (p = itr2.Ptr()) ) {
    if ( oldOrder >= p->GetOrder() ) {
      MSG("Nav",Msg::kError) 
          << "Integer sort out of order. " 
          << "Previous, current " << oldOrder  << "," << p->GetOrder()
          << endl;
      ok = kFALSE;
    }
    oldOrder = p->GetOrder();
    ++itr2;
  }

//  Slice by integer.

  Int_t  loOrder = -1;
  Int_t  hiOrder = 3;
  UInt_t numIntSlice = 3;

  itr2.GetSet()->Slice( loOrder, hiOrder);
  numSel = 0;
  while ( ( p = itr2.Ptr()) ) {
    Int_t pOrder = p->GetOrder();
    if ( pOrder < loOrder || pOrder > hiOrder ) {
      MSG("Nav",Msg::kError) 
          << "Int slice out of range: lo,current,hi: " 
          << loOrder  << "," << pOrder << "," << hiOrder
          << endl;
      ok = kFALSE;
    }
    ++itr2;
    numSel++;
  }

  if (     itr2.SizeSelect() != numSel 
       ||  numSel != numIntSlice ) {
     MSG("Nav",Msg::kError) 
         << "Int slice: num selected does not match SizeSelect or"
         << " expected: " 
         << "num sel, SizeSelect(), expected " << numSel << ","
         << itr2.SizeSelect() << "," << numIntSlice
         << endl;
     ok = kFALSE;
  }

  if ( itr2.Size() != numUnsliced ) {
     MSG("Nav",Msg::kError) 
         << "Int slice:unsliced size does not match Size(): " 
         << "num unsliced, Size() " << numUnsliced << ","   
         << itr2.Size() << endl;
     ok = kFALSE;
  }

  itr2.GetSet()->ClearSlice();

  if ( itr2.SizeSelect() != numUnsliced ) {
     MSG("Nav",Msg::kError) 
         << "Int cancelled slice:does not match Size(): " 
         << "SizeSelect(), num unsliced " << itr2.SizeSelect() << ","
         << numUnsliced << endl;
     ok = kFALSE;
  }


// Test single arg slice.

  itr2.GetSet()->Slice(2);
  if ( itr2.SizeSelect() != 1 ) {
     MSG("Nav",Msg::kError) 
         << "Single arg slice does not give right set size: " 
         << "SizeSelect() should be 1, but is " << itr2.SizeSelect()
         << endl;
     ok = kFALSE;
  }


// Test that sort function reapplied after mapping. The following
// keeps the moons ordered by name while selected by planet.


  NavTestMoonItr   mItr("NavTestPlanet",0);
  UInt_t numMoons = mItr.Size();
  NavTestMoonKeyFunc*  pFuncM = mItr.CreateKeyFunc();
  pFuncM->SetFun(KeyMoon_NameSafe);
  mItr.GetSet()->AdoptSortKeyFunc(pFuncM);
  pFuncM = 0;


  itr2.ResetFirst();
  while ( (p = itr2.Ptr()) ) {
    mItr.Map(p);
    if ( mItr.SizeSelect() > 1 ) {
      NavTestMoon* m = mItr.Ptr();
      const Char_t* mName = m->GetName();
      ++mItr;

      while ( (m = mItr.Ptr()) ) {
        if ( strcmp(mName,m->GetName()) >= 0 ) {
          MSG("Nav",Msg::kError) 
            << "Character sort after mapping  out of order. " 
            << "Previous, current :" << mName  << "," << m->GetName()
            << endl;
          ok = kFALSE;
        }
        mName = m->GetName();
        ++mItr;
      }

    }
    ++itr2;
  }

// Test that the full set size does not change when mapped.

  if ( numMoons != mItr.Size() ) {
    MSG("Nav",Msg::kError) 
        << "Full set size changes after mapping: before,after. " 
        << numMoons << "," << mItr.Size() << endl;
    ok = kFALSE;
  }

// Test that set will not accept wrong KeyFunc.

  pFunc = itr.CreateKeyFunc();
  MSG("Nav",Msg::kInfo) << "This test should fail!"  << endl;
  if ( mItr.GetSet()->AdoptSortKeyFunc(pFunc) ) {
    MSG("Nav",Msg::kError) 
        << "Moon NavSet accepted Planet NavKeyFunc " << endl;
    ok = kFALSE;
  }

// Test of a double sort.

  mItr.Map(0);
  mItr.ResetFirst();
  pFuncM = mItr.CreateKeyFunc();
  pFuncM->SetFun(KeyMoon_ParentSafe);
  mItr.GetSet()->AdoptSortKeyFunc(pFuncM,kTRUE,kFALSE);
  pFuncM = mItr.CreateKeyFunc();
  pFuncM->SetFun(KeyMoon_NameSafe);
  mItr.GetSet()->AdoptSortKeyFunc(pFuncM,kFALSE,kTRUE);
  pFuncM = 0;
  NavTestMoon* oldMoon = 0;
  while ( mItr.IsValid() ) {
    NavTestMoon* moon =  mItr.Ptr();
    if ( oldMoon ) {
      Int_t compParent = strcmp(oldMoon->GetParent(),moon->GetParent());
      if (     compParent > 0
           || (    compParent == 0
                && strcmp(oldMoon->GetName(),moon->GetName()) >= 0 ) ) {
        MSG("Nav",Msg::kError) 
          << "Moon double sort out of order " << endl
          << "     Previous:  " << oldMoon->GetParent()
          << "," << oldMoon->GetName() << endl
          << "     Current:   " << moon->GetParent()
          << "," << moon->GetName() << endl;
        ok = kFALSE;
      }
    }
    oldMoon = moon;
    mItr.Next();
  }


// Tidy up.

  EraseTestObjects();
  
  MSG("Nav",Msg::kInfo) 
       << "Test  5: Sorting and slicing                    ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

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

Bool_t NavValidate::Test_6() {
//
//
//  Purpose:   Selection and Slicing in multiple dimensions
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Check that slice gives the expected number, either with
//    SizeSelected() or by iterating.
//
//  o Check that slicing while selecting gives the expected number
//    and that subsequently removing selection leave the set at
//    the expected slice size.

 
  Bool_t ok = kTRUE;

// Create TCollection and iterator.

  TCollection* tcol = MakeTCollection();
  UInt_t tcolSize = tcol->Capacity();
  NavTestPlanetItr itr(tcol);

  const UInt_t numExpectedSel      = 5;
  const UInt_t numExpectedSelInv   = itr.GetSet()->Size() - numExpectedSel;
  const UInt_t numExpectedSlice    = 4;
  const UInt_t numExpectedSelSlice = 2;

  NavTestPlanetKeyFunc* pFunc = itr.CreateKeyFunc();
  pFunc->SetFun(SelPlanet);

//  Move iterator on - adopting Selection func should reset.
  ++itr;
  ++itr;
  itr.GetSet()->AdoptSelectKeyFunc(pFunc);
  pFunc = 0;

  UInt_t numSelFor = 0;
  for ( ; itr.IsValid(); ++itr ) numSelFor++;
  UInt_t numSelBac = 0;
  itr.ResetLast();
  for ( ; itr.IsValid(); --itr ) numSelBac++;

  if (    numExpectedSel != numSelFor || numSelFor != numSelBac
       || numExpectedSel != itr.SizeSelect() ) {
    MSG("Nav",Msg::kError) 
        << "Selected size not as expected. Expected,sum (for,back),"
        << "SizeSelect(): " << numExpectedSel << "," << numSelFor
        << "," << numSelBac << "," << itr.SizeSelect()
        << endl;
    ok = kFALSE;
  }

// Test selection inversion.

  itr.GetSet()->InvertSelection();
  numSelFor = 0;
  for ( ; itr.IsValid(); ++itr ) numSelFor++;
  numSelBac = 0;
  itr.ResetLast();
  for ( ; itr.IsValid(); --itr ) numSelBac++;

  if (    numExpectedSelInv != numSelFor || numSelFor != numSelBac
       || numExpectedSelInv != itr.SizeSelect() ) {
    MSG("Nav",Msg::kError) 
        << "Inverted selected size not as expected:. Expected,sum (for,back),"
        << "SizeSelect(): " << numExpectedSelInv << "," << numSelFor
        << "," << numSelBac << "," << itr.SizeSelect()
        << endl;
    ok = kFALSE;
  }
  itr.GetSet()->InvertSelection(kFALSE);

//  Sort by mass and slice checking that reduced set size
//  is as expected.

  pFunc = itr.CreateKeyFunc();
  pFunc->SetFun(KeyPlanet_MassSafe);
  itr.GetSet()->AdoptSortKeyFunc(pFunc);

  pFunc = 0;
  itr.GetSet()->Slice( 1.001,10000000.);

  
// Check ordering after slicing (it does not trigger a resort).
  NavKey oldKey = itr.GetNavKey();
  while ( itr.IsValid() ) {
    NavKey key = itr.GetNavKey();
    if ( oldKey.CompareValue(key) > 0 ) {
      MSG("Nav",Msg::kError) 
        << "Set ordering wrong.  Previous key: " << oldKey.GetValue()
        << " currrent key: " << key.GetValue() << endl;
      ok = kFALSE;
    }
    oldKey = key;
    itr.Next();
  }

  if (    numExpectedSelSlice != itr.SizeSelect() ) {
    MSG("Nav",Msg::kError) 
        << "Selected/slice size not as expected: expected,"
        << "SizeSelect(): " << numExpectedSelSlice << "," 
        << itr.SizeSelect() << endl;
    ok = kFALSE;
  }

//  Cancel selection and check size again.

  itr.GetSet()->AdoptSelectKeyFunc(0);
  if (    numExpectedSlice != itr.SizeSelect() ) {
    MSG("Nav",Msg::kError) 
        << "Slice size not as expected: expected,"
        << "SizeSelect(): " << numExpectedSlice << "," 
        << itr.SizeSelect() << endl;
    ok = kFALSE;
  }

// Perform a second level slice by name and check size.
  itr.Reset();
  pFunc = itr.CreateKeyFunc();
  pFunc->SetFun(KeyPlanet_NameSafe);
  itr.GetSet()->AdoptSortKeyFunc(pFunc,kFALSE,kTRUE);
  itr.GetSet()->Slice( "N","T" );
  pFunc = 0;
  if ( itr.SizeSelect() != 2 ) {
    MSG("Nav",Msg::kError) 
       << "Double slice should give 2 but gave " << itr.SizeSelect() << endl;
    ok = kFALSE;
  }
  
// Check ordering after cancel slicing (this should trigger a resort).
  oldKey = itr.GetNavKey();
  while ( itr.IsValid() ) {
    NavKey key = itr.GetNavKey();
    if ( oldKey.CompareValue(key) > 0 ) {
      MSG("Nav",Msg::kError) 
        << "Set ordering wrong.  Previous key: " << oldKey.GetValue()
        << " currrent key: " << key.GetValue() << endl;
      ok = kFALSE;
    }
    oldKey = key;
    itr.Next();
  }


//  Finally cancel slice and check that full set size is restored.

  itr.GetSet()->Slice();
  if (    tcolSize != itr.SizeSelect() ) {
    MSG("Nav",Msg::kError) 
        << "Full size not as expected: expected,"
        << "SizeSelect(): " << tcolSize << "," 
        << itr.SizeSelect() << endl;
    ok = kFALSE;
  }



// Tidy up.

  tcol->Delete();
  delete tcol;
  LEA_DTOR_NM("TList",tcol)
 

  MSG("Nav",Msg::kInfo) 
       << "Test  6: Selection and multi-dim slicing        ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

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

Bool_t NavValidate::Test_7() {
//
//
//  Purpose:   Random access.
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Test random access jump.
 
  Bool_t ok = kTRUE;

// Create TCollection and iterator.

  TCollection* tcol = MakeTCollection();
  Int_t tcolSize = tcol->Capacity();
  NavTestPlanetItr itr(tcol);

// Check that jumps within limits are O.K. but are invalid outside.

  Bool_t t_low   = itr.Jump(-1);
  Bool_t t_first = itr.Jump(0);
  Bool_t t_last  = itr.Jump(tcolSize-1);
  Bool_t t_hi    = itr.Jump(tcolSize);
  if ( t_low || t_hi || ! t_first || ! t_last ) {
    // Print Bool_t values 0,1 as Int_t as Bool_t is unsigned char 
    // and these values won't print.
    MSG("Nav",Msg::kError) 
      << "Jump before first or after last should fail but give "
      << Int_t(t_low) << "," << Int_t(t_hi) << endl
      << "Jump to first or last should suceed but give "
      << Int_t(t_first) << "," << Int_t(t_last) << endl;
    ok = kFALSE;
  }

// Jump to known entry and check it is right.
  if ( strcmp( itr.JumpPtr(2)->GetName(), "Earth") ) {
    MSG("Nav",Msg::kError) 
      << "Jump to position 2 should be Earth, but is "
      <<  itr.JumpPtr(2)->GetName() << endl;
    ok = kFALSE;
  }

// Tidy up.

  tcol->Delete();
  delete tcol;
  LEA_DTOR_NM("TList",tcol)
 
  MSG("Nav",Msg::kInfo) 
       << "Test  7: Random Access                          ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

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

Bool_t NavValidate::Test_8() {
//
//
//  Purpose:   Selection by functor.
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o 
 
  Bool_t ok = kTRUE;

// Create Standard test objects, TCollection and iterator.

  PrepareTestObjects();
  NavTestMoonItr itr(fMoons);

  NavTestMoonKeyFunc*  pFuncM = itr.CreateKeyFunc();
  string lo("G");
  string hi("M");
  MoonKeyFunctor ftor(lo,hi);
  pFuncM->SetFun(ftor); 
// Check for leaks by adding functors more than once.
  MoonKeyFunctor ftor2(lo,hi);
  pFuncM->SetFun(ftor2); 
  itr.GetSet()->AdoptSelectKeyFunc(pFuncM);
  while ( itr.IsValid() ) {
    string name = itr.Ptr()->GetName();
    if ( lo > name || hi < name ) {
      MSG("Nav",Msg::kError) 
        << " Found name: " << name << ", which is outside range: "
        << lo << "..." << hi << endl;
    ok = kFALSE;
    }
    itr.Next();
  }

//  Erase test setup.

  EraseTestObjects();
  
  MSG("Nav",Msg::kInfo) 
       << "Test  8: Selection by functor                   ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

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

Bool_t NavValidate::Test_9() {
//
//
//  Purpose:   Multi-dimensional sorting and iteration..
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o 
 
  Bool_t ok = kTRUE;

// Create Standard test objects, TCollection and iterator.

  PrepareTestObjects();
  NavTestMoonItr itr(fMoons);
  
// Test double sort and stepping by key.
//   NavTestMoonKeyFunc* pFuncM = itr.CreateKeyFunc();
//   pFuncM->SetFun(KeyMoon_ParentSafe);
//   itr.GetSet()->AdoptSortKeyFunc(pFuncM,kTRUE,kFALSE);
//   pFuncM = itr.CreateKeyFunc();
//   pFuncM->SetFun(KeyMoon_NameSafe);
//   itr.GetSet()->AdoptSortKeyFunc(pFuncM,kFALSE,kTRUE);

  itr.SetSort2Fun(KeyMoon_ParentSafe,KeyMoon_NameSafe);

  itr.ResetFirst();
  NavTestMoon* oldMoon = 0;
  Int_t numPlanets = 0;
  while ( itr.IsValid() ) {
    NavTestMoon* moon = itr.Ptr();
    if (    oldMoon 
         && strcmp(oldMoon->GetParent(),moon->GetParent()) == 0) {
      MSG("Nav",Msg::kError) 
        << " NextKey fails: Found name: " << oldMoon->GetParent() 
        << " twice " << endl;
    ok = kFALSE;
    }
    numPlanets++;
    oldMoon = moon;
    itr.NextKey();
  }

  if ( numPlanets != 6 ) {
    MSG("Nav",Msg::kError) 
        << " NextKey fails: Found  " << numPlanets
        << " distinct keys but should be 6 " << endl;
    ok = kFALSE;
  }
  
// Test subslicing

  itr.ResetFirst();
  Int_t numMoons = 0;
  numPlanets = 0;
  while ( itr.IsValid() ) {
    
//  First moon of this planet.
    numPlanets++;

//    Loop over all moons of this planet
      for (  NavTestMoonItr itr2(itr,kTRUE);
             itr2.IsValid(); 
             itr2.Next() ) {
        numMoons++;
      }
    itr.NextKey();
  }
  if ( numPlanets != 6 ||  numMoons != 11) {
    MSG("Nav",Msg::kError) 
        << " Multi-dim itr fails: Found  " << numPlanets
        << " planets and " << numMoons
        << " moons but should be 6, 11 " << endl;
    ok = kFALSE;
  }

//  Erase test setup.

  EraseTestObjects();
  
  MSG("Nav",Msg::kInfo) 
       << "Test  9: Multi-dimensional sorting and iteration...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

  return ok;
  
}

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

Bool_t NavValidate::Test_10() {
//
//
//  Purpose:  Masks.  
//  Arguments: None.
//  Return:    = kTRUE if all tests are O.K., kFALSE otherwise.  
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Set and test masks.

  Bool_t ok = kTRUE;

// Create TCollection and iterator.

  TCollection* tcol = MakeTCollection(1);
  NavTestMoonItr itr(tcol);

  Mask_t reqMask = 0;

  while ( itr.IsValid() ) {
    Mask_t mask = itr.GetSet()->GetMasks().GetMask(itr.Ptr());
    if ( mask != reqMask ) {
      MSG("Nav",Msg::kError) 
          << "Found mask:" << mask
          << " when expecting: " << reqMask << endl;
      ok = kFALSE;
    }
    itr.Next();
  }

  reqMask = 7;
  itr.ResetFirst();
  while ( itr.IsValid() ) {
   itr.GetSet()->GetMasks().SetMask(reqMask,itr.Ptr());
   Mask_t mask = itr.GetSet()->GetMasks().GetMask(itr.Ptr());
    if ( mask != reqMask ) {
      MSG("Nav",Msg::kError) 
          << "Found mask:" << mask
          << " when expecting: " << reqMask << endl;
      ok = kFALSE;
    }
    itr.Next();
  }

  reqMask = 9;
  itr.ResetFirst();
  itr.GetSet()->GetMasks().SetAllMasks(reqMask);
  while ( itr.IsValid() ) {
    Mask_t mask = itr.GetSet()->GetMasks().GetMask(itr.Ptr());
    if ( mask != reqMask ) {
      MSG("Nav",Msg::kError) 
          << "Found mask:" << mask
          << " when expecting: " << reqMask << endl;
      ok = kFALSE;
    }
    itr.Next();
  }

// Tidy up.

  tcol->Delete();
  delete tcol;
  LEA_DTOR_NM("TList",tcol)
  
  MSG("Nav",Msg::kInfo) 
       << "Test 10: Masks                                  ...... ";
  MSG("Nav",Msg::kInfo) << ( ok ? "O.K." : "Failed") ;
  MSG("Nav",Msg::kInfo) << "\n";

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

  return ok;
  
}

---