Loadrunner Code Samples

For string replace below is the code

replace2(char *strSource, char *strFrom, char *strTo, char *strParam)
{
    char strTemp[1024];
    char *s = (char*)strSource;
    int i=0;
    int iLenFrom = strlen (strFrom);
    int iLenTo   = strlen (strTo  );
 
    while (*s)
    {
        if (strncmp (s, strFrom, iLenFrom) == 0)
        {
            strncpy (&(strTemp[i]), strTo, iLenTo);
            i += iLenTo;
            s += iLenFrom;
        }
        else
        {
            strTemp[i++] = *s;
            s++;
        }
    }
    strTemp[i] = 0;
 
    lr_save_string (strTemp, strParam);
}

 ex: 

     lr_save_string (lr_eval_string("{brokerDetailList}"), "pNewValue0");

     replace2(lr_eval_string("{pNewValue0}"),"\\","","pNewValue1"); //remove /
    
    lr_save_string (lr_eval_string("{pNewValue1}"), "pNewValue2");
     replace2(lr_eval_string("{pNewValue2}"),"{","","pNewValue3");//remove {
    
    lr_save_string (lr_eval_string("{pNewValue3}"), "pNewValue4");
     replace2(lr_eval_string("{pNewValue4}"),"}","", "pNewValue5");

To Tokenize and Parametrize String, use below code :

//Here we split the string and do the parameterization with saving the string
    lr_split_string(lr_eval_string("{pNewValue9}"),":","brokerDetails");

    for (k=1;k<22;k++)
    {
        lr_log_message("=========== %s", lr_eval_string(lr_paramarr_idx("brokerDetails", k)));
    }

char *lr_memalloc(int size)
{
    char *buff;
    int mem = size * sizeof(char);
    
    if(mem <= 0)
    {
        lr_error_message("Requested non positive amounts (%d) of memory! Bailing out ..", mem);
        return NULL;
    }    
    if ((buff = (char *)malloc(mem)) == NULL) 
    {
        lr_error_message("Insufficient memory available, requested %d", mem);
        lr_abort();
    }
    return buff;
}


char* lr_get_parameter(const char* paramName)
{
   char *parameter;
   char *tmp = lr_memalloc( strlen(paramName) +3 ); 
   sprintf(tmp, "%s", paramName);
   parameter = lr_eval_string(tmp);
   free(tmp);
   
   return parameter;
}

void lr_array_save(const char* value, const char* pArray, const int pIndex)
{
    int len = strlen(pArray) +3;
    char *result;
    int power = pIndex;

    while(power = (power / 10))
    {
        len++;
    }

    result = lr_memalloc(len);
    sprintf(result, "%s_%d", pArray, pIndex);
    lr_save_string(value, result);
    free(result);
}

void lr_array_save_count(const int count, const char *pArray)
{
    int len = strlen(pArray) +7; // 7 = strlen("_count") +1, where +1 would be the '\0' byte at the end.
    char *result = lr_memalloc(len);
    sprintf(result, "%s_count", pArray);
    lr_save_int(count, result);
    free(result);
}

lr_split_string( const char *originalParameter, const char *search, const char *destArrayParam)
{
    char *result = lr_get_parameter(originalParameter);
    char *posPtr;
    char *leftResultset;
    int i =0;

    if( search == NULL || strlen(search) == 0 )
    {
        return;
    }

    do 
    {
        posPtr = (char *)strstr(result, search);
        if( posPtr == NULL )
        {
            break;
        }
        lr_getleft_string(result, search, "leftResult");
        result = posPtr + strlen(search);
        i++;
        lr_array_save(lr_eval_string("{leftResult}"), destArrayParam, i);
    } 
    while(1);

    lr_getleft_string(result, search, "rightResult");
    i++;
    lr_array_save(lr_eval_string("{rightResult}"), destArrayParam, i);
    lr_array_save_count(i, destArrayParam);
}

lr_getleft_string(const char *originalParameter, const char *search, const char *resultParameter)
{
       char *buffer;
       char *original = lr_get_parameter(originalParameter);
       char *posPtr = (char *)strstr(original, search);
       int pos = (int)(posPtr - original);
    
       if( posPtr == NULL )
       {
          lr_save_string(original, resultParameter);
          return;
       }
       buffer = lr_memalloc(strlen(original)+1);
       strcpy(buffer, original);
       buffer[pos] = '\0'; 
       lr_save_string(buffer, resultParameter); 
       free(buffer);
}

lr_getright_string( const char *originalParameter, const char *search, const char *resultParameter)
{
    char *original = lr_get_parameter(originalParameter);

    char *posPtr = (char *)strstr(original, search);
    int pos = (int)(posPtr - original);

    if( posPtr == NULL )
    {
        lr_save_string(original, resultParameter);
        return;
    }

    posPtr = posPtr + strlen(search);
    lr_save_string(posPtr, resultParameter);
}