/www/proggenOrg/dedupe/export/trunk/test/unittest/testenvironment.cpp

Go to the documentation of this file.

#include <boost/test/unit_test.hpp>

#include "testenvironment.h"

Dedupe::Test::TestEnvironment::
TestEnvironment( Dedupe::FilePath RootDirectory ) :
RootDir( boost::filesystem::absolute( RootDirectory,
                                    boost::filesystem::current_path() ) )

{
  //init srand only one time
  std::srand( time( NULL ) );
}

size_t Dedupe::Test::TestEnvironment::
CreateRandomInt( size_t Min, size_t Max )
{
  if( Max < Min ) return 1;
  return  Min + rand() % ( Max - Min + 1 );
}

Dedupe::FilePath  Dedupe::Test::TestEnvironment::CreateRandomPathPart(
                                                      size_t MinLength,
                                                      size_t MaxLength )
{
  std::string Builder = "";

  if( MaxLength < MinLength ) return "ERROR";

  //make a random size between the constants
  size_t length =  CreateRandomInt( MinLength, MaxLength );
  do
  {
    /*select a sign from SignSource per random
    SignSource.size() -1 is important, otherwise the
    termination sign of the string is used, too*/
    Builder += Dedupe::Test::SignSource[
                CreateRandomInt( 0, Dedupe::Test::SignSource.size() -1 ) ];
  }while( Builder.size() < length );
  Dedupe::FilePath returning( Builder );
  return returning;
}

Dedupe::FilePath Dedupe::Test::TestEnvironment::CreateRandomPathstring()
{
  Dedupe::FilePath Path = "";

  size_t Pathparts = CreateRandomInt( MinParts, MaxParts );
  size_t i = 0;

  do
  {
    Path /=  CreateRandomPathPart( MinSize, MaxSize );
    i++;
  }while( i < Pathparts );

  return Path;
}

Dedupe::FilePath Dedupe::Test::TestEnvironment::
CreateDirectory( Dedupe::FilePath IncomingPath )
{
  //RootDir is const so assign to a new Path Object
   Dedupe::FilePath Path( RootDir );
   //add the relative path to the root path, now Path is a absolute path
   Path /= IncomingPath;

  //normalise path for used plattform
  Path.string();

  //create a directory or directories from the given path
  //if it fails a error message is written to cerr
  try
  {
    if( boost::filesystem::exists( Path ) ) return Path;

    boost::filesystem::create_directories( Path );
  }
  catch( boost::filesystem::filesystem_error &e )
  {
    std::cerr << e.what() << std::endl;
    return "";
  }
  if( boost::filesystem::exists( Path ) ) return Path;
  else return "";
}

Dedupe::FilePath Dedupe::Test::TestEnvironment::
CreateFile( Dedupe::FilePath IncomingPath,
                    Dedupe::FilePath IncomingFilename,
                    unsigned int FileSize)
{
   //RootDir is const so assign to a new Path Object
   Dedupe::FilePath Path = RootDir;

   try
   {
    //test if there is diskspace for the file
    boost::filesystem::space_info s =
    boost::filesystem::space( Path.parent_path() );
    if( s.available < FileSize )
    {
      std::cerr << "Not enought Diskspace" << std::endl;
      return "";
    }

    if( CreateDirectory( IncomingPath ) == "" )
    {
      std::cerr << "Could not create directory " << std::endl;
      return "";
    }

    Path /= IncomingPath;
    Path /= IncomingFilename;
    boost::filesystem::ofstream File;

    //open the outputstream to write the file on harddisc
    File.open( Path, std::ios_base::out );
    if( File == NULL )
    {
      std::cerr << "Could not open file: " << Path << std::endl;
      File.close();
      return "";
    }

    //add chars to the file until whished size is there
    for( size_t i = 0; i != FileSize; ++i )
    {
      File << Dedupe::Test::SignSource[
                CreateRandomInt( 0, Dedupe::Test::SignSource.size() -1 ) ];
    };

    //Close File, if the work is done
    File.close();
  }
  catch( boost::filesystem::filesystem_error &e )
  {
    std::cerr << e.what() << std::endl;
    return "";
  }
  return Path;
}

Dedupe::FilePath Dedupe::Test::TestEnvironment::CreateRandomFilename()
{
  std::string ReturningPath( "" );
  ReturningPath = CreateRandomPathPart( MinSize, MaxSize ).string() ;
  ReturningPath += ".";
  ReturningPath += CreateRandomPathPart( 1, 5 ).string() ;

  return ReturningPath;
}

void Dedupe::Test::TestEnvironment::DeleteCreated()
{
  boost::system::error_code ec;
  boost::filesystem::remove_all( RootDir, ec );
  if( ec != 0 )
  {
    std::cerr << ec.message() << std::endl;
  }
 }


BOOST_FIXTURE_TEST_SUITE( Selftest_TestEnvironment,
                          Dedupe::Test::TestEnvironmentSelftestFixture )
  //Check if a byte is 8 bits on the system
  BOOST_AUTO_TEST_CASE( TestIfByteIsEightBitsLong )
  {
     BOOST_CHECK( sizeof( char ) == 1 );
     BOOST_CHECK( CHAR_BIT == 8 );
  }

  BOOST_AUTO_TEST_CASE( TestCreateDirectory )
  {
    //check if the directory is created
    Dedupe::FilePath Path = Env.RootDir;
    Path /= "Does/I/Exist/for/sure";
    Env.CreateDirectory( "Does/I/Exist/for/sure" );
    BOOST_CHECK( boost::filesystem::exists( Path ) );
  }

  BOOST_AUTO_TEST_CASE( TestCreateFile )
  {
    //check if the file is created
    Dedupe::FilePath Path = Env.RootDir;
    Path /= "Does/I/Exist/for/sure/as/file";
    Env.CreateFile( "Does/I/Exist/for/sure/as/file" , "Testfile.file", 6883 );
    BOOST_CHECK( boost::filesystem::exists( Path ) );
    Path /= "Testfile.file";
    BOOST_CHECK_EQUAL( boost::filesystem::file_size( Path ), 6883u );
  }
 BOOST_AUTO_TEST_SUITE_END()