/*
* Test the performance of the substr() function of our strType
*/
float StropBencher::substr(int numRuns, int strType) {
float startTime = currTime();
std::string longStr("abcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyz");
std::string subStr;
int pos;
switch(strType) {
case MAUTIL_STRING:
for(int i = 0; i < numRuns; ++i){
for(int j = 0; j < ALOT; ++j){
subStr = longStr.substr(pos = rand()%(longStr.length()-1), rand()%(longStr.length()-pos));
}
}
printf("subStr: %s", subStr.c_str()); //force the compiler to actually do the operations because subStr is used!
/*case STD_STRING: TODO Will have to wait until STL is implemented*/
}
return currTime() - startTime;
}
void bench(bool longLog)
{
muduo::Logger::setOutput(asyncOutput);
int cnt = 0;
const int kBatch = 1000;
muduo::string empty = " ";
muduo::string longStr(3000, 'X');
longStr += " ";
for (int t = 0; t < 30; ++t)
{
muduo::Timestamp start = muduo::Timestamp::now();
for (int i = 0; i < kBatch; ++i)
{
LOG_INFO << "Hello 0123456789" << " abcdefghijklmnopqrstuvwxyz "
<< (longLog ? longStr : empty)
<< cnt;
++cnt;
}
muduo::Timestamp end = muduo::Timestamp::now();
printf("%f\n", timeDifference(end, start) * 1000000 / kBatch);
struct timespec ts = { 0, 500 * 1000 * 1000 };
nanosleep(&ts, NULL);
}
}
// -----------------------------------------------------
// --------------- TEST3: num2str2 -------------
// -----------------------------------------------------
bool num2str2Test(){
int intNum = 20;
long longNum = 200000;
double doubleNum = 20.3;
double negNum = -20.3;
int len = 5;
std::string intStr(num2str2<int>(intNum, len));
std::string longStr(num2str2<long>(longNum, len));
std::string doubleStr(num2str2<double>(doubleNum, len));
std::string negStr(num2str2<double>(negNum, len));
if (intStr.compare("00020") != 0 || longStr.compare("200000") != 0 || doubleStr.compare("020.3") != 0 || negStr.compare("-20.3") != 0 )
{
return false;
}
return true;
}
/*
* Test the performance of string comparisons on our strType
*/
float StropBencher::compare(int numRuns, int strType, int cmpType) {
float startTime = currTime();
bool ret;
std::string longStr("abcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyz");
std::string eq("abcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyz");
std::string notEq("abcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghilj#kmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyz");
std::string less("abcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljjkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyz"); //2 j:s in a row makes this string lexiographically less than longStr
std::string more("abcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljmkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyzabcdefghiljkmnopqrstuvwxyz"); //a m after the j makes this string lexiographically more than longStr
int pos;
switch(strType) {
case MAUTIL_STRING:
for(int i = 0; i < numRuns; ++i){
for(int j = 0; j < ALOT; ++j){
if(cmpType == 0)
ret = longStr == eq;
else if(cmpType == 1)
ret = longStr != notEq;
else if(cmpType == 2)
ret = longStr <= more;
else if(cmpType == 3)
ret = longStr >= less;
else if(cmpType == 4)
ret = longStr < less;
else
ret = longStr > less;
}
}
// printf("ret: %d", ret); //force the compiler to actually do the operations because subStr is used!
/*case STD_STRING: TODO Will have to wait until STL is implemented*/
}
return currTime() - startTime;
}
void graficotorta(int n, long cantidad[], int estado[]) {
gdImagePtr imagen;
FILE *archivo;
char titulo[513];
char etiqueta[512];
int blanco, negro, color;
gdFontPtr fuente = gdFontGetSmall();
imagen = gdImageCreateTrueColor(IMG_WIDTH, IMG_HEIGHT);
int i;
int angEtiqueta, xEtiqueta, yEtiqueta;
float eqgrados;
int iniciotrozo, fintrozo;
long suma = 0;
int aprox;
for (i=0; i<n; i++) {
suma = suma + cantidad[i];
}
eqgrados = 360.0/suma;
if (imagen) {
blanco = gdImageColorAllocate(imagen, 255, 255, 255);
negro = gdImageColorAllocate(imagen, 0, 0, 0);
// Pintamos el fondo Blanco
gdImageFill(imagen, 0, 0, blanco);
iniciotrozo = 0;
for (i=0; i<n; i++) {
fintrozo = (int) iniciotrozo+cantidad[i]*eqgrados;
angEtiqueta = (iniciotrozo + fintrozo) / 2;
xEtiqueta = cos(angEtiqueta*PI/180) * 220 + 400;
yEtiqueta = sin(angEtiqueta*PI/180) * 220 + 290;
// Color
color = gdImageColorAllocate(imagen, color_aleatoreo(), color_aleatoreo(), color_aleatoreo());
//Pintamos fondo el trozo
gdImageFilledArc(imagen, 400, 300, 400, 400, iniciotrozo, fintrozo, color, gdArc);
//Etiqueta de peticion
memset(etiqueta, 0, 513);
snprintf(etiqueta, 512, "peticion %s",intStr(estado[i]));
gdImageString(imagen, fuente, xEtiqueta-25, yEtiqueta, (unsigned char *) etiqueta, negro);
//Correccion de aproximacion para el porcentaje
aprox = cantidad[i] * 1000 / suma;
aprox = aprox%10;
if (aprox>=5)
aprox = 1;
else
aprox = 0;
//Etiqueta de porcentaje
memset(etiqueta, 0, 513);
snprintf(etiqueta, 512, "%s%%",longStr(cantidad[i]*100/suma+aprox));
if (cantidad[i]*100/suma<3){ //Para que la etiqueta sea legible
xEtiqueta = xEtiqueta + 52;
yEtiqueta = yEtiqueta - 15;
}
gdImageString(imagen, fuente, xEtiqueta, yEtiqueta+15, (unsigned char *) etiqueta, negro);
iniciotrozo = (int) iniciotrozo+cantidad[i]*eqgrados;
}
//Pintamos borde del circulo
gdImageArc(imagen, 400, 300, 400, 400, 0, 360, negro);
// Coloco el título
memset(titulo, 0, 513);
snprintf(titulo, 512, "Peticiones Por Estado");
gdImageString(imagen, fuente, (int) IMG_WIDTH * 0.4, 25, (unsigned char *) titulo, negro);
// Pintamos Borde
gdImageLine(imagen, BORDE_ANCHO, BORDE_ALTO, (IMG_WIDTH - BORDE_ANCHO), BORDE_ALTO, negro); //linea horiz superior
gdImageLine(imagen, BORDE_ANCHO, (IMG_HEIGHT - BORDE_ALTO), (IMG_WIDTH - BORDE_ANCHO), (IMG_HEIGHT - BORDE_ALTO), negro); //linea horiz inferior
gdImageLine(imagen, BORDE_ANCHO, BORDE_ALTO, BORDE_ANCHO, (IMG_HEIGHT - BORDE_ALTO), negro); //linea vertical izquierda
gdImageLine(imagen, (IMG_WIDTH - BORDE_ANCHO), BORDE_ALTO, (IMG_WIDTH - BORDE_ANCHO), (IMG_HEIGHT - BORDE_ALTO), negro); //linea horiz derecha
// Guardar imagen
archivo = fopen("graficot.jpg", "wb");
if (archivo != NULL) {
gdImageJpeg(imagen, archivo, 100);
fclose(archivo);
}
gdImageDestroy(imagen);
}
}
/** Utility to test striping of space characters. By altering the parameters
* you can test the different strip flavours:
* The first parameter controls whether you want to 'strip' leading characters,
* trailing characters or both charactersr. The other two parameters are used to
* test variants of testing spaces - viz. a) test when the type
* of 'stripping' has been explicitly specified as trailing / nothing has specified.
* and b) test when the character to be specified has been explicitly specifed as ' ' or
* nothing has been specified.
*/
void utlTestStripSpaces(UtlString::StripType sType, \
bool specifyStripType, bool specifyChar)
{
// We need a string which has both leading and
// trailing spaces.
string longStr(" ") ;
longStr.append(longAlphaString) ;
longStr.append(" ") ;
// To evaluate the expected string resulting out of a strip(trail),
// construct a string with only the longAlphaString and leading) spaces
string tmpStringForTrailing(" ") ;
tmpStringForTrailing.append(longAlphaString) ;
// To evaluate the expected string resulting out of a strip(leading),
// construct a string with only the longAlphaString and trailing spaces
string tmpStringForLeading(longAlphaString) ;
tmpStringForLeading.append(" ") ;
const char* expectedForLeading = tmpStringForLeading.data() ;
const char* expectedForTrailing = tmpStringForTrailing.data() ;
// If both sides are striped then the expected
// string would just be longAlphaString
const char* expectedForBoth = longAlphaString ;
const TestStripDataStructure testData[] = { \
{ "empty char*", "", ' ', \
"", "", "" }, \
{ "regular char* w/o spaces", "A String", ' ', \
"A String", "A String", "A String" }, \
{ "regular char* w trailing spaces", "A String ", ' ', \
"A String", "A String ", "A String" }, \
{ "regular char* w leading spaces", " A String", ' ', \
" A String", "A String", "A String" }, \
{ "alpha-num char* w/o spaces", "String12#2A", ' ',\
"String12#2A", "String12#2A", "String12#2A" }, \
{ "alpha-num char* w trailing spaces", "String12#2A ", ' ', \
"String12#2A", "String12#2A ", "String12#2A" }, \
{ "alpha-num char* w both spaces", " String12#2A ", ' ', \
" String12#2A", "String12#2A ", "String12#2A" }, \
{ "space only char*", " ", ' ', \
"", "", ""} , \
{ "Very long char*", longStr.data(), ' ', \
expectedForTrailing, expectedForLeading, expectedForBoth } \
} ;
// create the first part of the message based on the type of striping to be done!
string prefix("Test the strip(") ;
if (specifyStripType)
{
switch(sType)
{
case UtlString::trailing :
prefix.append("trailing") ;
break ;
case UtlString::leading :
prefix.append("leading") ;
break ;
case UtlString::both :
prefix.append("both") ;
break ;
}
}
if (specifyChar)
{
prefix.append(", ' '") ;
}
prefix.append(") for a string made of ") ;
const int testCount = sizeof(testData) / sizeof(testData[0]) ;
for (int i = 0 ; i < testCount; i++)
{
UtlString testString(testData[i].input) ;
UtlString returnString ;
string Message ;
if (specifyStripType)
{
if(specifyChar)
{
returnString = testString.strip(sType, ' ');
}
else
{
returnString = testString.strip(sType) ;
}
}
else
{
KNOWN_EFENCE_BUG("Segmentation fault w/efence", "XPL-9");
returnString = testString.strip() ;
}
const char* expectedValue = "";
switch(sType)
{
case UtlString::trailing:
expectedValue = testData[i].expectedForStripTrailing ;
break ;
case UtlString::leading:
expectedValue = testData[i].expectedForStripLeading;
break ;
case UtlString::both:
expectedValue = testData[i].expectedForStripBoth ;
break ;
}
TestUtilities::createMessage(2, &Message, prefix.data(), \
testData[i].testDescription) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(Message.data(), \
string(expectedValue), \
string(returnString.data())) ;
}
} //utlTestStripSpaces
