C PROGRAMS and functions in LOAD RUNNER

/********************************************************************/
/* Function Name: cg_random
/* Purpose      : Generate random alphabets/numbers/symbols
/* Input        : No.of letters, Capital or small(0 -for capital letters, 1 -for small letters, 
/*                2 - mixed case, 3 -numbers, 4 -symbols)
/* Output       : Random alphabets/numbers/symbols (param_name)
/* Created by   : G.Raviteja
/******************************************************************/

cg_random(char* param_name,int length,int alpha_num)
{
char buff[42] = "";
int i,r;
char c;
srand((unsigned int) time(0)); //Before invoking rand, call srand to seed the pseudo-random number generator 

if(alpha_num == 0)
{
for(i=0;i<length;i++)
{
r=rand() % 25 + 65; // A-Z = 65-90 = rand() % 25 + 65 [for values within specific range using the mod (%) operator]
c= (char) r;
buff[i]=c;
printf("%c",c);
}
}

else if(alpha_num == 1)
{
for(i=0;i<length;i++)
{
r=rand() % 25 + 97; // a-z = 97-122 = rand() % 25 + 97 [for values within specific range using the mod (%) operator]
c= (char) r;
buff[i]=c;
printf("%c",c);
}

}

else if(alpha_num == 2)
{
for(i=0;i<length;i++)
{
r=rand() % 57 + 65; // a-z = 65-122 = rand() % 57 + 65 [for values within specific range using the mod (%) operator]
if(r>90 && r<97)
{
                r=r+10;
c= (char) r;
               
}

else
{
c= (char) r;

}

buff[i]=c;
printf("%c",c);
        }

}

else if(alpha_num == 3)
{
for(i=0;i<length;i++)
{
r=rand() % 9 + 48; // 0-9 = 48-57 = rand() % 9 + 48 [for values within specific range using the mod (%) operator]
c= (char) r;
buff[i]=c;
printf("%c",c);
}

}

else if(alpha_num == 4)
{
for(i=0;i<length;i++)
{
r=rand() % 14 + 33; // !-/ = 33-47 = rand() % 14 + 33 [for values within specific range using the mod (%) operator]
c= (char) r;
buff[i]=c;
printf("%c",c);
}

}

else 
{
        lr_output_message("==>Enter value between 0-4 for argument 3<==");
}


lr_save_string(buff,param_name);

return 0;
}

/********************************************************************/
/* Function Name: cg_file_write
/* Purpose      : File write
/* Input        : Buffer and file name
/* Output       : Data written to file
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

int cg_file_write(char* buffer,char* filename)
{
int fp;
    
fp = fopen (filename,"w");
if(fp == NULL)
{
lr_error_message("ERROR: Unable to open file");
}

fprintf(fp,"%s",buffer);
fclose(fp);

}
/********************************************************************/
/* Function Name: cg_file_read
/* Purpose      : File read
/* Input        : file name
/* Output       : Reads content from file
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

int cg_file_read(char* filename)
{
int fp;

char data[1000];
char* buff;

int i=1;
int total, count =0;

//char* filename = "test1.txt";

fp = fopen(filename,"r");

if(fp == NULL)
{
lr_error_message("Cannot open %s", filename); 
return -1;
}

else
{
while(! feof(fp))
{
// Read 1000 bytes while maintaining a running count 

              //count = fread(data, sizeof(char), 1000, fp); 

 count = fgets(data, 1000, fp);

              if (ferror(fp)) { 

                     lr_output_message ("Error reading file %s", filename); 

                     break;

 }

 lr_output_message( "The line %d is ==> \"%s\"",i, data);

 i++;

              /*// Get the first line from the file 

if (fgets(data, 100, fp) == NULL) 

            lr_output_message("fgets error"); 

            else 

            lr_output_message( "The line %d is ==> \"%s\"",i, data); 

i++;*/

}
}

    fclose(fp);

   if (ferror(fp)) 
{
lr_error_message("Error closing file %s", filename); 
}

}


/********************************************************************/
/* Function Name: cg_PlainToURL
/* Purpose      : converts a plain text string into URL format string
/* Input        : StrIn - Input String, 
/* Output       : URL format string (StrOut - Output buffer)
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_PlainToURL(char* strIn, char* strOut)
{
int i;
char curChar;
char curStr[4] = {0};

strOut[0] = '\0';

for (i=0;curChar=strIn[i];i++)
{
if(isdigit(curChar) || isalpha(curChar)) // Verify whether the character is digit or alphabet
{
sprintf(curStr,"%c",curChar); // If yes, then print as such
}

else
{
sprintf(curStr,"%%%X",curChar); // else convert it into hex string
}

strcat(strOut,curStr); // Concatenate the output

}

return strOut;
}

/********************************************************************/
/* Function Name: cg_PlainToURL_lr
/* Purpose      : converts a plain text string into URL format string
/* Input        : sIn - String which needs to be converted to URL format
/* Output       : URL formatted string
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/
cg_PlainToURL_lr(char* sIn)
{
//char sIn[] = "t es%d$ + eprst_";

lr_save_string(sIn, "InputParam");

web_convert_param("InputParam", 
 "SourceEncoding=PLAIN",
 "TargetEncoding=URL", 
 LAST);

lr_output_message("%s", lr_eval_string("{InputParam}"));
}



/********************************************************************/
/* Function Name: cg_HTMLToPlain_lr
/* Purpose      : converts a URL format string into plain text string
/* Input        : sIn1 - HTML string which needs to be converted to Plain format
/* Output       : Plain formatted string
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/
cg_HTMLToPlain_lr(char* sIn1)
{
//char sIn1[] = "v%20mg%25d%24%20%2B%20vmguruprasath%5F";

lr_save_string(sIn1, "InputParam");

web_convert_param("InputParam", 
 "SourceEncoding=HTML",
 "TargetEncoding=PLAIN",
 LAST);

lr_output_message("%s", lr_eval_string("{InputParam}"));

}

/********************************************************************/
/* Function Name: cg_LTrim
/* Purpose      : Trims spaces on the left of the string
/* Input        : source string and the string to be trimmed
/* Output       : left trimmed string
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_ltrim(char *string, char junk)
{    
char* original = string;
char *p = original;
int trimmed = 0;
do 
{       
 if (*original != junk || trimmed) 
 {           
    trimmed = 1; 
*p++ = *original;
 } 
   }

   while (*original++ != '\0');

return string;
}

/********************************************************************/
/* Function Name: cg_rtrim
/* Purpose      : Trims spaces on the right of the string
/* Input        : source string and the string to be trimmed
/* Output       : right trimmed string
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_rtrim(char* string, char junk)
{    
char* original = string + strlen(string);
while(*--original == junk);
*(original + 1) = '\0';
return string;
}

/********************************************************************/
/* Function Name: cg_find_replace
/* Purpose      : Finds a string/character from the source and replaces with
/*                the specified replace string/character. 
/* Input        : source string, search string, replace string
/* Output       : 
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_replace(const char* src,const char* search,const char* replace)
{
    /* We need to find the length of the source string, seach and replace string*/

size_t size       = strlen(src) + 1;
size_t searchlen  = strlen(search);
size_t replacelen = strlen(replace);

/* Allocate memory to values */

char* value = (char*)malloc(size);

    /* defining return value */

char* ret = value;

ret = value;

/* Verify Malloc */

if (value != NULL)
    {
/* loop untill no match is found */
for(;;)
{
/* Find the search string */

const char* match = (char*)strstr(src,search);

if(match != NULL)
{
/* Found search text at location match,
* Find how many characters to copy in match */

size_t count = match - src;

/* Re-allocate memory, use a temp variable for pointer */

char* temp;

/* Calculating the total length of the string after allocation */

size += replacelen - searchlen;

/* realloc memory*/

temp = (char*)realloc(value,size);

if(temp == NULL)
{
/* Re allocation of memory failed so free the malloc'd memory*/

free(value);

return NULL;
}

/* Re-allocation successful. Now point the pointer to value */

ret = temp + (ret - value);

value = temp;

/* copy from the source to where we matched.
* Then move the source pointer to this point and move the 
* destination pointer ahead by same amount */

memmove(ret,src,count);

src += count;
ret += count;

/* Now copy the replacement text 'replace' at the position of match.
* Adjust the source pointer by the text we replaced 
* Adjust the destination pointer with the amount of replacement */

memmove(ret,replace,replacelen);

src += searchlen;
ret += replacelen;

}

else /* No Match found */
{
/* Copy the remaining part of the string */

strcpy(ret,src);

break;
}


}
}

return value;
}

void cg_find_replace(const char* source,const char* str,const char* repl)
{
char* after;

after = cg_replace(source,str,repl);

lr_output_message("The find string is: '%s' and replace string is '%s'",str,repl);

if(after != NULL)
{
lr_output_message("The string after replacement::> %s",after);
free(after);
}
}

/********************************************************************/
/* Function Name: cg_substr_index
/* Purpose      : Extracts a string between the start index and end index. 
/* Input        : Source string, Stat index and end index
/* Output       : Extracted sting between the start and end index
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_substr_index(char* source,int begin, int end)
{
int length = end-begin;

char* newstring;
char* tmpstring;

int i;

if(length<0)
{
return("-1");

}

newstring = (char*)malloc(length+1);

memset(newstring,'\0',length+1);

tmpstring = (char*)strdup(source);

for(i=1;i<begin;i++)
{
tmpstring++;
}

strncpy(newstring,tmpstring,length);

lr_output_message("Substring is ::>%s",newstring);

return newstring;

}


/********************************************************************/
/* Function Name: cg_substr_lb_index
/* Purpose      : Extracts a string between the start index and end of string. 
/* Input        : Source string and start index
/* Output       : Extracted string from start index to last.
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_substr_lb_index(char* src,int startIndex)
{
    char* buffer;
char* temp;

int cnt;

int length = strlen(src);

if(length<0)
{
return("-1");

}

buffer = (char*)malloc(length+1);

memset(buffer,'\0',length+1);

temp = (char*)strdup(src);

for(cnt=1;cnt<startIndex;cnt++)
{
temp++;
}

strncpy(buffer,temp,length);

lr_output_message("Substring from left boundary is ::>%s",buffer);

return buffer;

}

/********************************************************************/
/* Function Name: cg_substr
/* Purpose      : Extract a string between left boundary and right boundary. 
/* Input        : 
/* Output       : 
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_substr(char* source,char* lbound, char* rbound)
{

char* lposition;
char* rposition;
int begin,end;

    

int length;

char* newstring;
char* tmpstring;

    char* tmp;

int i;

int lblength = strlen(lbound);

lposition = (char *)strstr(source, lbound); 

    // strstr has returned the address. Now calculate * the offset from the beginning of str 

    begin = (int)(lposition - source + 1); 

lr_output_message ("The lbound \"%s\" was found at position %d", lbound, begin);

begin = begin + lblength;

rposition = (char *)strstr(source, rbound); 
    // strstr has returned the address. Now calculate * the offset from the beginning of str 
    end = (int)(rposition - source + 1); 

     
    lr_output_message ("The rbound \"%s\" was found at position %d", rbound, end); 

length= end-begin;

if(length<0)
{
        tmp = (char*)malloc(length + 1);

tmp = (char*)strdup(source);

for(i=1;i<begin;i++)
{
tmp++;
}

rposition = (char *)strstr(tmp, rbound);

end = (int)(rposition - tmp + 1);

lr_output_message ("The new rbound \"%s\" was found at position %d", rbound, end);

        length= end - 1;

if(length<0)
{
lr_output_message("ERROR: Right boundary value is found before left boundary value");

return("-1");
}

        
}

    
newstring = (char*)malloc(length+1);

memset(newstring,'\0',length+1);

tmpstring = (char*)strdup(source);

for(i=1;i<begin;i++)
{
tmpstring++;
}

strncpy(newstring,tmpstring,length);

lr_output_message("Substring is ::>%s",newstring);

        return newstring;
        
}

/********************************************************************/
/* Function Name: cg_substr_lb
/* Purpose      : Extract a string between left boundary and end of string. 
/* Input        : 
/* Output       : 
/* Created by   : G.Raviteja
/*www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_substr_lb(char* src,char* lbound)
{

char* lpos;
    char* newstring;
char* tmpstring;

int start,end,length,i;

    int lblength = strlen(lbound);

lpos = (char *)strstr(src, lbound); 

    // strstr has returned the address. Now calculate * the offset from the beginning of str 

    start = (int)(lpos - src + 1); 

lr_output_message ("The lbound \"%s\" was found at position %d", lbound, start);

start = start + lblength;

    length= strlen(src);

if(length<0)
{
lr_output_message("-->Enter string with some characters<--");

        return("-1");
        
}

    
newstring = (char*)malloc(length+1);

memset(newstring,'\0',length+1);

tmpstring = (char*)strdup(src);

for(i=1;i<start;i++)
{
tmpstring++;
}

strncpy(newstring,tmpstring,length);

lr_output_message("Substring is ::>%s",newstring);

        return newstring;

        
}

/********************************************************************/
/* Function Name: cg_substr_lb_cnt
/* Purpose      : Extract a string between left boundary and end of string
/*                for the given occurence.. 
/* Input        : 
/* Output       : 
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/******************************************************************/

char* cg_substr_lb_cnt(char* src,char* lbound, int cnt)
{

char* lpos;
    char* newstring;
char* tmpstring;

int start,end,length,i,j;

    int lblength = strlen(lbound);

lpos = (char *)strstr(src, lbound); 

    // strstr has returned the address. Now calculate * the offset from the beginning of str 

    start = (int)(lpos - src + 1); 

if(start<0)
{

lr_output_message("-->ERROR:The left boundary value'%s' - Not found in source <--",lbound);

return("-1");

    }

//lr_output_message ("The lbound \"%s\" was found at position %d", lbound, start);

start = start + lblength; // calculate the start position

    length= strlen(src);

if(length<0)
{
lr_output_message("-->ERROR:Enter string with some characters<--");

        return("-1");
        
}

    
newstring = (char*)malloc(length+1);

memset(newstring,'\0',length+1);

tmpstring = (char*)strdup(src);

/* Msg: move pointer for the number of occcurence */

for (j=0;j<cnt;j++) 
{
for(i=1;i<start;i++)
{
tmpstring++;
}

strncpy(newstring,tmpstring,length);

lpos = (char *)strstr(newstring, lbound); 

start = (int)(lpos - newstring + 1); 

if(start<0)
{

                lr_output_message("-->Last occurence of '%s' found for occurance count %d ;the occurence value entered is %d<--",lbound,j+1,cnt);

break;
        }

else
{
lr_output_message ("The lbound \"%s\" was found at position %d", lbound, start);

/* Calculate new start position */

start = start + lblength;

length= strlen(newstring);

if(length<0)
{
lr_output_message("-->ERROR:Enter string with some characters<--");

return("-1");
        
}
}


}

lr_output_message("Substring with occurence count %d is ::>%s",j+1,newstring);

        return newstring;

        
}

/***************************************************************************/
/* Function Name: cg_substr_cnt
/* Purpose      : Extract a string between left boundary and right boundary. 
/*                for the given occurrence
/* Input        : 
/* Output       : 
/* Created by   : G.Raviteja
/* www.easyloadrunner.blogspot.in
/************************************************************************/

char* cg_substr_cnt(char* source,char* lbound, char* rbound, int cnt)
{

char* lposition;
    char* rposition;
int begin,end,i,j,length;

    char* newstring;
char* tmpstring;

char* newstring1;
char* tmp;
char* temp;

    int lblength = strlen(lbound);

lposition = (char *)strstr(source, lbound); 

    // strstr has returned the address. Now calculate * the offset from the beginning of str 

    begin = (int)(lposition - source + 1); 

length= strlen(source);

if(length<0)
{
lr_output_message("Enter string with some characters");
}

newstring = (char*)malloc(length+1);

memset(newstring,'\0',length+1);

strncpy(newstring,source,length);


/* Verifying count values */

if(cnt == 0)
{
lr_output_message("Enter occurrence value as 1 or >1");

return("-1");
}

/* Moving begin index for the number of occurence */

if(cnt>1)
{
        temp = (char*)malloc(length+1);
temp = (char*)strdup(source);

for(j=0;j<cnt;j++)
{
for(i=1;i<begin;i++)
{
temp++;
}

lposition = (char *)strstr(temp, lbound);

begin = (int)(lposition - temp + 1);

begin = begin + lblength;

length= strlen(newstring);

            strncpy(newstring,temp,length);

//lr_output_message("The newstring value is :%s",newstring);

        }

/* Noting down the new begin position */

lposition = (char *)strstr(newstring, lbound);

begin = (int)(lposition - newstring + 1); 

if(begin<0)
{
lr_output_message("The argument occurence count exceeds the left boundary occurrence count");

return("-1");


}

    }

        newstring1 = (char*)malloc(length+1);

memset(newstring1,'\0',length+1);

tmpstring = (char*)strdup(newstring);

begin = begin + lblength;

/* Extracting string from the new begin value */

for(i=1;i<begin;i++)
{
tmpstring++;
}

/* Finding right boundary in the new string */

rposition = (char *)strstr(tmpstring, rbound);

end = (int)(rposition - tmpstring + 1);

/* Calculating length upto the begining of right boundary*/

length = end - 1;

if(length < 0)
{
lr_output_message("last occurrence of left boundary reached");

length = strlen(newstring);


}

/* Copying the extracted string to newstring 1*/
        
        strncpy(newstring1,tmpstring,length);

lr_output_message("Substring is ::>%s",newstring1);

        return newstring1;
}