generate.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2009  Cyril Soldani
 * 
 * This file is part of QuickCheck++.
 * 
 * QuickCheck++ is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 * 
 * QuickCheck++ 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 General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * QuickCheck++. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef QUICKCHECK_GENERATE_H
#define QUICKCHECK_GENERATE_H

#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <limits>
#include <vector>

namespace quickcheck {

template<class A>
A generateInRange(A low, A high)
{
   assert(low <= high);
   A offset = static_cast<A>(double(rand()) / RAND_MAX
                             * (double(high) - double(low) + 1));
   return static_cast<A>(low + offset);
}

template<class A, class Iter>
A oneOf(Iter first, Iter last)
{
   assert(std::distance(first, last) > 0);
   size_t len = size_t(std::distance(first, last));
   assert(len > 0);
   size_t index = generateInRange(size_t(0), len - 1);
   Iter i;
   for (i = first; index != 0; ++i)
      --index;
   return *i;
}

template<class A>
A generateInteger(size_t n)
{
   // not appropriate for floats as it chooses only integers
   assert(std::numeric_limits<A>::is_integer);
   // clips [-n, n] interval if necessary
   A max = std::numeric_limits<A>::max();
   A min = std::numeric_limits<A>::min();
   A high = (n > size_t(max)) ? max : A(n);
   A low = (n > size_t(-min)) ? min : A(-n);
   // generates integer in clipped interval
   return generateInRange(low, high);
}

static inline void generate(size_t, bool& out)
{
   static const bool booleans[] = { true, false };
   out = oneOf<bool>(&booleans[0], &booleans[2]);
}

static inline void generate(size_t n, char& out)
{
   static const char *basicChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
      "abcdefghijklmnopqrstuvwxyz";
   if (n < sizeof (basicChars) - 1)
      out = oneOf<char>(&basicChars[0], &basicChars[n]);
   else if (n < 95)
      out = generateInRange(' ', '~'); // any printable ASCII
   else
      out = generateInRange(char(0x00), char(0xff));
}

static inline void generate(size_t n, unsigned char& out)
{
   char c;
   generate(n, c);
   out = static_cast<unsigned char>(c);
}

static inline void generate(size_t n, short& out)
{
   out = generateInteger<short>(n);
}

static inline void generate(size_t n, unsigned short& out)
{
   out = generateInteger<unsigned short>(n);
}

static inline void generate(size_t n, int& out)
{
   out = generateInteger<int>(n);
}

static inline void generate(size_t n, unsigned int& out)
{
   out = generateInteger<unsigned int>(n);
}

static inline void generate(size_t n, long& out)
{
   out = generateInteger<long>(n);
}

static inline void generate(size_t n, unsigned long& out)
{
   out = generateInteger<unsigned long>(n);
}

static inline void generate(size_t n, float& out)
{
   out = float(rand()) / float(RAND_MAX) * 2 * float(n) - float(n);
}

static inline void generate(size_t n, double& out)
{
   out = double(rand()) / RAND_MAX * 2 * double(n) - double(n);
}

static inline void generate(size_t n, long double& out)
{
   out = static_cast<long double>(rand()) / RAND_MAX * 2 * n - n;
}

template<class A>
void generate(size_t n, std::vector<A>& out)
{
   unsigned len;
   generate(n, len);
   for (size_t i = 0; i < len; ++i) {
      A a;
      generate(n - 1, a);
      out.push_back(a);
   }
}

}

#endif // !QUICKCHECK_GENERATE_H