test_utils.h

Go to the documentation of this file.

#ifndef __TEST_UTILS_H__
#define __TEST_UTILS_H__

#include "gpudb/GPUdb.hpp"

#include <string>

#include <log4cplus/logger.h>
#include <log4cplus/loggingmacros.h>

// =================================================================
// Logging Helpers

// Global logger (can't define it here; it's defined in the .cpp file)
extern log4cplus::Logger logger;


// Create an inline std::stringstream stream object and return the
// std::string from it.
// E.g. std::string msg( KINETICA_STREAM_TO_STRING( "Hello " << user_name << ", how are you?" ) );
// Note: Extra cast needed for gcc 4.8.7 (at least).
#define KINETICA_STREAM_TO_STRING(...) ( static_cast<const std::ostringstream&> (std::ostringstream() << __VA_ARGS__).str() )

// Create an inline std::stringstream stream object and return the
// char array from it.
// E.g. std::string msg( KINETICA_STREAM_TO_STRING( "Hello " << user_name << ", how are you?" ) );
#define KINETICA_STREAM_TO_CSTRING(...) ( KINETICA_STREAM_TO_STRING(__VA_ARGS__).c_str() )

// Log a informational message
#define LOG_KINETICA_INFO(logger, logEvent) do { LOG4CPLUS_INFO(logger, logEvent); } while(0)

// Log a debug message
#define LOG_KINETICA_DEBUG(logger, logEvent) do { LOG4CPLUS_DEBUG(logger, logEvent); } while(0)

// Log a warning 
#define LOG_KINETICA_WARN(logger, logEvent) do { LOG4CPLUS_WARN(logger, logEvent); } while(0)

// Log an error
#define LOG_KINETICA_ERROR(logger, logEvent) do { LOG4CPLUS_ERROR(logger, logEvent); } while(0)



    
// =================================================================
// Data Generator Utility Functions

#define NORMALIZER 100
#define USE_NULL_VALUE(null_percentage) \
    ((std::rand() % NORMALIZER) < null_percentage)

#define PERFORM_ACTION( percentage ) \
    ((std::rand() % NORMALIZER) < percentage)

#define GENERATE_INT8() \
    ( (std::rand() % 256) - 128)

#define GENERATE_INT16() \
    ( (std::rand() % 65536) - 32768)

#define GENERATE_FLOAT() \
    ( ((float)std::rand()) / std::rand() * std::pow(-1, (std::rand() % 2)) )

#define GENERATE_DOUBLE() \
    ( ((double)std::rand()) / std::rand() * std::pow(-1, (std::rand() % 2)) )

#define GENERATE_UNSIGNED_INT16() \
    ( std::rand() % 65536 )

// This macro generates mostly very large numbers
#define GENERATE_UNSIGNED_LONG_LONG() \
    ( ( (unsigned long long)GENERATE_UNSIGNED_INT16() << 48 ) |   \
      ( (unsigned long long)GENERATE_UNSIGNED_INT16() << 32 ) |   \
      ( (unsigned long long)GENERATE_UNSIGNED_INT16() << 16 ) |   \
      ( (unsigned long long)GENERATE_UNSIGNED_INT16() ) ) 

// This macro generates very large values, no small values, but can achieve
// the actual max of ull.  For more varied values--to have smaller numbers--
// try generate_unsigned_long_long_str() (but look at its caveat).
#define GENERATE_UNSIGNED_LONG_LONG_STRING() \
    ( std::to_string( GENERATE_UNSIGNED_LONG_LONG() ) )


#define GENERATE_TIMESTAMP() \
    ( std::rand() - std::rand() )  // Range is actually [-30610239758979, 29379542399999]


// For generating strings and charNs
static const char alphanum[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static const char numeric[]  = "0123456789";
static const int alphabet_size = 62; // [0-9] ten, [A-Z] 26, [a-z] 26

/*
 * Generate a random string made of the characters in [A-Za-z0-9], up to
 * 256 characters in length.
 */
std::string generate_random_string();


/*
 * Generate a random string made of the characters in [A-Za-z0-9], up to
 * 256 characters in length. The prefix is prepended to the randomly generated
 * string.
 */
std::string generate_random_string( const std::string& prefix );


/*
 * Generate a random string made of the characters in [A-Za-z0-9], up to
 * N characters in length.
 */
std::string generate_charN( size_t N );


/*
 * Generate a random string containing an unsigned long long (small or large).
 * The maximum value reached here is 9,999,999,999,999,999,999, which is
 * significantly less than the actual maximum value of 8,446,744,073,709,551,615.
 * However, we can get small values, too, unlike the macro
 * GENERATE_UNSIGNED_LONG_LONG_STRING() (which gets mostly very large values
 * upto, and including, the unsigned long long maximum).
 */
std::string generate_unsigned_long_long_str();


/*
 * Generate a random string containing an unsigned long long (small or large).
 * The maximum value reached here is 9,999,999,999,999,999,999, which is
 * significantly less than the actual maximum value of 8,446,744,073,709,551,615.
 * However, we can get small values, too, unlike the macro
 * GENERATE_UNSIGNED_LONG_LONG_STRING() (which gets mostly very large values
 * upto, and including, the unsigned long long maximum).
 *
 * The generated value is guaranteed to not have any leading zero.
 */
std::string generate_unsigned_long_long_str_no_leading_zero();


#define GENERATE_IPV4() \
    ( std::to_string(std::rand() % 256) + "." \
      + std::to_string(std::rand() % 256) + "." \
      + std::to_string(std::rand() % 256) + "." \
      + std::to_string(std::rand() % 256) )


/*
 * Generate a random date within the year range [1000, 2900]
 */
std::string generate_date();



/*
 * Generate a random datetime with optional milliseconds
 */
std::string generate_datetime( int chance_percentage_has_time, int chance_percentage_has_ms );


/*
 * Generate a random time with optional milliseconds
 */
std::string generate_time( int chance_percentage_has_ms );



/*
 * Generate a random decimal value with optional fractions and signs.
 */
std::string generate_decimal( int frac_only_percentage, int has_frac_percentage, int negative_percentage, int positive_percentage );


// ============================================================================

std::string generate_table_name( const std::string& prefix );

void create_table( const gpudb::GPUdb& db, const std::string table_name,
                   const gpudb::Type& type);

void create_table( const gpudb::GPUdb& db, const std::string table_name,
                   const std::vector<gpudb::Type::Column>& columns);

void clear_table( const gpudb::GPUdb& db, const std::string table_name );

size_t get_table_size( const gpudb::GPUdb& db, const std::string table_name );

// ====================================================================


#endif //  __TEST_UTILS_H__