y_param_array.c

Go to the documentation of this file.

/*
 * Ylib Loadrunner function library.
 * Copyright (C) 2005-2014 Floris Kraak <randakar@gmail.com> | <fkraak@ymor.nl>
 * Copyright (C) 2009 Raymond de Jongh <ferretproof@gmail.com> | <rdjongh@ymor.nl>
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
#ifndef _Y_PARAM_ARRAY_C_
#define _Y_PARAM_ARRAY_C_

#include "vugen.h"
#include "y_string.c"
#include "y_loadrunner_utils.c"

int _y_random_array_index = 0;


#ifdef Y_COMPAT_LR_8
int y_array_count( const char *param_array )
{
    int result;
    size_t size = strlen(param_array) +9; // 9 = strlen("{}_count") +1 -- the +1 is '\0'
    char *tmp = y_mem_alloc(size);

    snprintf(tmp , size, "{%s_count}" , param_array );
    result = atoi(lr_eval_string(tmp));
    free(tmp);
    return result;
}
#else
#define y_array_count( param_array ) lr_paramarr_len(param_array) 
#endif // Y_COMPAT_LR_8


#ifdef Y_COMPAT_LR_8
char *y_array_get( const char *source_param_array, const int param_array_index )
{
    int size = y_array_count( source_param_array );
    char *tmp;
    char *result;

    //lr_log_message("y_array_get(%s,%d)", source_param_array, param_array_index ); 
    if ( (param_array_index > size) || (param_array_index < 1) )
    {
        lr_error_message("Index out of bounds");
        lr_abort();
        return NULL;
    }

    // Calculate space requirements
    {
        size_t bufsize = strlen(source_param_array)+y_int_strlen(param_array_index)+4; // strlen() + size of index + {}_\0
        tmp = y_mem_alloc(bufsize); 
        snprintf( tmp , bufsize, "{%s_%d}" , source_param_array , param_array_index );
    }

    result = lr_eval_string(tmp);
    free (tmp);
    return result;
}
#else
#define y_array_get( source_param_array, param_array_index ) lr_paramarr_idx(source_param_array, param_array_index)
#endif // Y_COMPAT_LR_8


char* y_array_get_no_zeroes( const char *source_param_array, const int param_array_index )
{
    if ( (param_array_index > y_array_count(source_param_array)) || (param_array_index < 1) )
    {
        lr_error_message("Parameter array %s does not exist or index %d out of bounds.", source_param_array, param_array_index);
        lr_abort();
        return NULL;
    }
    else
    {
        // Calculate space requirements
        size_t bufsize = strlen(source_param_array) + y_int_strlen(param_array_index) +2; // strlen() + _\0
        char* tmp = y_mem_alloc(bufsize);
        snprintf(tmp, bufsize, "%s_%d", source_param_array, param_array_index );
        return y_get_cleansed_parameter(tmp, ' '); // <-- Might want to make that configurable..
    }
}

void y_array_save(const char* value, const char* source_param_array, const int param_array_index)
{
    if(source_param_array == NULL)
    {
        // In some cases calling this without a parameter name is entirely valid.
        // eg. y_split() on an array where you only need one half of the results.
        return;
    }
    else
    {
        int len = strlen(source_param_array) + y_int_strlen(param_array_index) +2; // +2 = _\0
        char *result = y_mem_alloc(len);
        snprintf(result, len, "%s_%d", source_param_array, param_array_index);
        lr_save_string(value, result);
        free(result);
    }
}

void y_array_save_count(const int count, const char *source_param_array)
{
    if( source_param_array == NULL )
    {
        // In some cases calling this without a parameter name is entirely valid.
        // eg. y_split() on an array where you only need one half of the results.
        return;
    }
    else 
    {
        int len = strlen(source_param_array) +7; // 7 = strlen("_count") +1, where +1 would be the '\0' byte at the end.
        char* result = y_mem_alloc(len);

        snprintf(result, len, "%s_count", source_param_array);
        lr_save_int(count, result);
        free(result);
    }
}

void y_array_add( const char* source_param_array, const char* value )
{
    int size = y_array_count(source_param_array) +1;
    y_array_save(value, source_param_array, size);
    y_array_save_count(size, source_param_array);
}

void y_array_concat(const char *source_param_array_first, const char *source_param_array_second, const char *result_array)
{
    int size_first = y_array_count(source_param_array_first);
    int size_second = y_array_count(source_param_array_second);
    int size_total = size_first + size_second;
    int i = 1;
    int j = 1;

    //lr_log_message("y_array_concat(%s, %s, %s)", source_param_array_first, source_param_array_second, result_array);
    //lr_log_message("size_total = %d, i = %d", size_total, i);

    for(i=1; i <= size_total; i++)
    {
        char *value;
        //lr_log_message("Iteration %i, j=%d", i, j);

        if( i <= size_first )
        {
            value = y_array_get_no_zeroes(source_param_array_first,i);
        }
        else
        {
            value = y_array_get_no_zeroes(source_param_array_second,j);
            j++;
        }

        y_array_save(value, result_array, i);
        lr_eval_string_ext_free(&value);
    }
    y_array_save_count(size_total, result_array);
}


char *y_array_get_random( const char *source_param_array )
{
    int count = y_array_count( source_param_array );
    if( count < 1 )
    {
        lr_log_message("No elements found in parameter array!");
        return NULL;
    }

    _y_random_array_index= (y_rand() % count) +1;
    return y_array_get(source_param_array, _y_random_array_index);
}


char *y_array_get_random_no_zeroes( const char *source_param_array )
{
    int count = y_array_count( source_param_array );
    if( count < 1 )
    {
        lr_log_message("No elements found in parameter array!");
        return NULL;
    }

    _y_random_array_index = (y_rand() % count) +1;
    return y_array_get_no_zeroes(source_param_array, _y_random_array_index);
}


int y_array_pick_random( const char *source_param_array )
{
    if(y_array_count(source_param_array))
    {
        char *result = y_array_get_random_no_zeroes(source_param_array);
        lr_save_string(result, source_param_array);
        lr_eval_string_ext_free(&result);
        return _y_random_array_index;
    }
    else
    {
        lr_save_string("", source_param_array);
        //lr_output_message("y_array_pick_random(): Unknown parameter list");
        return 0;
    }
}

void y_array_dump( const char *source_param_array )
{
    int i;
    int count;

    for ( i=1 ; i <= y_array_count(source_param_array); i++ )
    {
        char *msg = y_array_get_no_zeroes(source_param_array, i);
        lr_output_message("{%s_%d} = %s" , source_param_array, i, msg);
        lr_eval_string_ext_free(&msg);
    }
}


void y_array_save_param_list(const char *sourceParam, const char *LB, const char *RB, const char *result_array)
{
    int i = 0;
    char *source = y_get_parameter(sourceParam);
    int buflen = strlen(source)+1;
    char *buffer = y_mem_alloc(buflen);
    char *next = buffer;
    memcpy(buffer, source, buflen);

    while( next = (char *)strstr(next, LB) )
    {
        char* end = strstr(next, RB);
        if(!end) 
            break;
        buffer[end - buffer] = '\0';

        i++;
        y_array_save(next+strlen(LB), result_array, i);
        next = end + strlen(RB);
    }
    free(buffer);
    y_array_save_count(i, result_array);
}

void y_array_grep( const char *source_param_array, const char *search, const char *result_array)
{
    int i, j = 1;
    char *item;
    int size = y_array_count(source_param_array);

    for( i=1; i <= size; i++)
    {
        item = y_array_get_no_zeroes(source_param_array, i);
        if( strstr(item, search) )
        {
            y_array_save(item, result_array, j++);
        }
        lr_eval_string_ext_free(&item);
    }
    y_array_save_count(j-1, result_array);
}

void y_array_filter( const char *source_param_array, const char *search, const char *result_array)
{
    int i, j = 1;
    char *item;
    int size = y_array_count(source_param_array);

    for( i=1; i <= size; i++)
    {
        item = y_array_get_no_zeroes(source_param_array, i); // Some pages contain a null byte - \x00 in the input. Ugh.
        if( strstr(item, search) == NULL )
        {
            y_array_save(item, result_array, j++);
        }
        lr_eval_string_ext_free(&item);
    }
    y_array_save_count(j-1, result_array);
}


int y_array_merge(const char *param_array_left, const char *param_array_right, const char *separator, const char *result_array)
{
    int i = 1;
    char *param;
    int length = y_array_count(param_array_left);
    int seperator_size = strlen(separator);

    if( length != y_array_count(param_array_right) )
    {
        // If the sizes aren't the same there's a good chance numbers won't line up on both sides.
        // We definitely don't want to end up with records merged that don't actually correspond to each other!
        lr_error_message("Unable to merge arrays %s and %s - sizes unequal!", param_array_left, param_array_right);
        lr_abort();
        return 0;
    }

    for( i=1; i <= length; i++)
    {
        char *left = y_array_get_no_zeroes(param_array_left, i);
        char *right = y_array_get_no_zeroes(param_array_right, i);
        size_t size = strlen(left)+seperator_size+strlen(right)+1;
        char *result = y_mem_alloc(size);

        snprintf(result, size, "%s%s%s", left, separator, right);
        lr_eval_string_ext_free(&left);
        lr_eval_string_ext_free(&right);
        y_array_save(result, result_array, i);
        free(result);
    }
    y_array_save_count(i-1, result_array);
    return 1;
}




void y_array_split(const char *source_param_array, const char *separator, const char *param_array_left, const char *param_array_right)
{
    int i = 1;
    int size = y_array_count(source_param_array);

    //lr_log_message("y_array_split(%s, %s, %s, %s)", source_param_array, separator,param_array_left, param_array_right);

    for( i=1; i <= size; i++)
    {
        char *item = y_array_get_no_zeroes(source_param_array, i);
        int len = strlen(item);
        char *left = y_mem_alloc(len);
        char *right = y_mem_alloc(len);

        left[0] = '\0';
        right[0] = '\0';

        y_split_str(item, separator, left, right);
        lr_eval_string_ext_free(&item);

        y_array_save(left, param_array_left, i);
        free(left);
        y_array_save(right, param_array_right, i);
        free(right);
    }

    y_array_save_count(i-1,param_array_left);
    y_array_save_count(i-1,param_array_right);
}


void y_array_shuffle(char *source_param_array, char *result_array)
{
    int *shuffle;
    int source_length, i;

    if (strcmp(source_param_array, result_array) == 0)
    {
        lr_error_message("Source and Destination parameter name can not be equal!");
        lr_abort();
        return;
    }

    source_length = y_array_count(source_param_array);
    if(source_length < 1)
    {
        lr_error_message("Cannot shuffle empty parameter arrays!");
        lr_abort();
        return;
    }
    else if(source_length == 1)
    {
        lr_log_message("Warning: Cannot shuffle a list with just 1 entry.");
        y_array_save( y_array_get(source_param_array, 1), result_array, 1);
        y_array_save_count(1, result_array);
        return;
    }

    // Now the cases where we can actually shuffle something: 
    shuffle=(int *)y_array_alloc(source_length+1, sizeof(int)); // Allocate room for an array of ints.
    for (i=1; i<=source_length; i++) // Fill it with the numbers 1 .. source length, denoting indexes into the source array, unshuffled.
    {
        //lr_message("i: %d", i);    
        shuffle[i]=i;
    }

    // For each item in that list of ints, have it swap places with a randomly chosen item from that same list. (Switching with yourself is legal.)
    for(i=1; i<=source_length; i++)
    {
        int temp, r;
        r=(y_rand() % (source_length))+1;
        lr_log_message("shuffle r %d into i %d", r, i);
        lr_log_message("swapping %d with %d", shuffle[i], shuffle[r]);
        temp = shuffle[i];
        shuffle[i] = shuffle[r];
        shuffle[r] = temp;
    }

    // Now that we have a list of shuffled numbers, use those numbers to store the elements in the source parameter array into the corresponding slots of the destination.
    for(i=1; i<=source_length; i++)
    {
        y_array_save(
           y_array_get(source_param_array, shuffle[i]),
           result_array, i);
    }
    y_array_save_count(--i, result_array); // We can probably just use the source_length here instead.
    free (shuffle);
}

#endif // _Y_PARAM_ARRAY_C_