TestUUID.cpp

/* This file is part of the BIAS library (Basic ImageAlgorithmS).
   
   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS 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 Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/


/**
   @file TestUUID.cpp
   @brief Tests class UUID
   @relates UUID
   @ingroup g_tests
   @author woelk / evers
   @date 2010
*/



#include <Base/Image/UUID.hh>

#include <vector>

using namespace BIAS;
using namespace std;

void Check(const std::vector<BIAS::UUID> &uuids);
void ResetFromString(std::vector<BIAS::UUID> &uuids);
void ResetFromLong(std::vector<BIAS::UUID> &uuids);
void ResetFromRaw(std::vector<BIAS::UUID> &uuids);

int main(int argc, char *argv[])
{
  std::vector<BIAS::UUID> uuids_consecutive, uuids_global;
  const unsigned num = 100;
  // generate the uuids
  for (unsigned i=0; i<num; i++){
    uuids_consecutive.push_back(BIAS::UUID::GenerateUUID(true));
    if (!uuids_consecutive.back().IsConsecutive()){
      BIASABORT;
    }
    // false means: not consecutive , so checking for consective order is 
    // not recommended.
    uuids_global.push_back(BIAS::UUID::GenerateUUID(false));
    /*if (uuids_global.back().IsConsecutive()){
      BIASABORT;
    }*/
  }
  Check(uuids_consecutive);
  Check(uuids_global);

  ResetFromString(uuids_consecutive);
  ResetFromString(uuids_global);

  Check(uuids_consecutive);
  Check(uuids_global);

  // ResetFromLong is only valid for consecutive uuids
  ResetFromLong(uuids_consecutive);
  Check(uuids_consecutive);

  ResetFromRaw(uuids_consecutive);
  ResetFromRaw(uuids_global);

  Check(uuids_consecutive);
  Check(uuids_global);

  for (unsigned i=0; i<num; i++){
    uuids_consecutive[i].clear();
    if ( !uuids_consecutive[i].IsNil() || uuids_consecutive[i].IsValid() ){
      BIASABORT;
    }
    uuids_global[i].Invalidate();
    if ( !uuids_global[i].IsNil() || uuids_global[i].IsValid() ){
      BIASABORT;
    }
  }

  // empyt constructor must return invalid uid
  BIAS::UUID uid;
  if ( !uid.IsNil() || uid.IsValid() ){
    BIASABORT;
  }

  return 0;
}


void Check(const std::vector<BIAS::UUID> &uuids)
{
  // check if they are unique and non null
  const unsigned num = uuids.size();
  for (unsigned i=0; i<num; i++){
    if (uuids[i].IsNil()){
      cerr << "uuid is nil: "<<uuids[i]<<endl;
      BIASABORT;
    }
    if (!uuids[i].IsValid()){
      cerr << "uuid is not valid: "<<uuids[i]<<endl;
      BIASABORT;
    }
    for (unsigned k=0; k<num; k++){
      if (i==k) continue;
      if (uuids[i]==uuids[k]){
        cerr << "uids are not unique: \n  "<<uuids[i]<<"\n  "<<uuids[k]<<endl;
        BIASABORT;
      }
    }
  }
}


void ResetFromString(std::vector<BIAS::UUID> &uuids)
{
  BIAS::UUID tmpuid;
  string tmp;
  const unsigned num = uuids.size();
  for (unsigned i=0; i<num; i++){
    tmp = uuids[i].GetString();
    if (!tmpuid.SetFromString(tmp)){
      BIASABORT;
    }
    if (tmpuid!=uuids[i]){
      BIASABORT;
    }
    uuids[i] = tmpuid;
  }
}

void ResetFromLong(std::vector<BIAS::UUID> &uuids)
{
  BIAS::UUID tmpuid;
  unsigned long tmp;
  const unsigned num = uuids.size();
  for (unsigned i=0; i<num; i++){
    tmp = uuids[i].GetLong();
    if (!tmpuid.SetFromLong(tmp)){
      BIASABORT;
    }
    if (tmpuid!=uuids[i]){
      cerr << "re-setting uuis from long does not work: "<<tmp
           << "\n  "<<uuids[i]<<"\n  "<<tmpuid<<endl;
      BIASABORT;
    }
    uuids[i] = tmpuid;
  }
}


void ResetFromRaw(std::vector<BIAS::UUID> &uuids)
{
  BIAS::UUID tmpuid;
  const unsigned num = uuids.size();
#ifndef WIN32
  for (unsigned i=0; i<num; i++){
    const unsigned char *tmp = uuids[i].GetUUIDRaw();
    tmpuid.SetUUIDRaw(tmp);
    if (tmpuid!=uuids[i]){
      BIASABORT;
    }
    uuids[i] = tmpuid;
  }
#endif
}