Initial open source release of OpenCL 2.0 CTS.

test_conformance/printf/CMakeLists.txt

@@ -0,0 +1,17 @@
+set(MODULE_NAME PRINTF)
+
+set(${MODULE_NAME}_SOURCES
+         test_printf.c
+         util_printf.c
+         ../../test_common/harness/errorHelpers.c
+         ../../test_common/harness/threadTesting.c
+         ../../test_common/harness/kernelHelpers.c
+         ../../test_common/harness/typeWrappers.cpp
+         ../../test_common/harness/conversions.c
+         ../../test_common/harness/mt19937.c
+         ../../test_common/harness/msvc9.c
+         ../../test_common/harness/testHarness.c
+         #../../test_common/harness/imageHelpers.cpp
+         )
+
+include(../CMakeCommon.txt)

test_conformance/printf/Jamfile

@@ -0,0 +1,5 @@
+project
+    : requirements
+      <target-os>windows,<toolset>gcc:<cflags>-xc++
+      <toolset>msvc:<cflags>"/TP" 
+    ;

test_conformance/printf/Makefile

@@ -0,0 +1,44 @@
+ifdef BUILD_WITH_ATF
+ATF = -framework ATF
+USE_ATF = -DUSE_ATF
+endif
+
+SRCS = test_printf.c \
+	util_printf.c \
+	../../test_common/harness/mt19937.c \
+	../../test_common/harness/kernelHelpers.c \
+	../../test_common/harness/errorHelpers.c \
+	../../test_common/harness/msvc9.c
+
+DEFINES = 
+
+SOURCES = $(abspath $(SRCS))
+LIBPATH += -L/System/Library/Frameworks/OpenCL.framework/Libraries
+LIBPATH += -L.
+FRAMEWORK = $(SOURCES)
+HEADERS = 
+TARGET = test_printf
+INCLUDE = 
+COMPILERFLAGS = -c -Wall -g -O0 -Wshorten-64-to-32
+CC = c++
+CFLAGS = $(COMPILERFLAGS) ${RC_CFLAGS} ${USE_ATF} $(DEFINES:%=-D%) $(INCLUDE)
+CXXFLAGS = $(COMPILERFLAGS) ${RC_CFLAGS} ${USE_ATF} $(DEFINES:%=-D%) $(INCLUDE)
+LIBRARIES = -framework OpenCL -framework OpenGL -framework GLUT -framework AppKit ${ATF}
+
+OBJECTS := ${SOURCES:.c=.o}
+OBJECTS := ${OBJECTS:.cpp=.o}
+
+TARGETOBJECT =
+all: $(TARGET)
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(RC_CFLAGS) $(OBJECTS) -o $@ $(LIBPATH) $(LIBRARIES)
+
+clean:
+	rm -f $(TARGET) $(OBJECTS)
+
+.DEFAULT:
+	@echo The target \"$@\" does not exist in Makefile.
+
+
+

test_conformance/printf/test_printf.h

@@ -0,0 +1,133 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef TESTPRINTF_INCLUDED_H
+#define TESTPRINTF_INCLUDED_H
+
+#include "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#include <OpenCL/cl_platform.h>
+#else
+#include <CL/opencl.h>
+#include <CL/cl_platform.h>
+#endif
+
+// Enable the test to be used with ATF
+#if USE_ATF
+// export BUILD_WITH_ATF=1
+#include <ATF/ATF.h>
+#define test_start() ATFTestStart()
+#define log_info ATFLogInfo
+#define log_error ATFLogError
+#define test_finish() ATFTestFinish()
+#else
+#define test_start()
+#define log_info printf
+#define log_error printf
+#define test_finish()
+#endif // USE_ATF
+
+#define ANALYSIS_BUFFER_SIZE 256
+
+//-----------------------------------------
+// Definitions and initializations
+//-----------------------------------------
+
+//-----------------------------------------
+// Types
+//-----------------------------------------
+enum Type
+ {
+     TYPE_INT,
+     TYPE_FLOAT,
+     TYPE_OCTAL,
+     TYPE_UNSIGNED,
+     TYPE_HEXADEC,
+     TYPE_CHAR,
+     TYPE_STRING,
+     TYPE_VECTOR,
+     TYPE_ADDRESS_SPACE,
+     TYPE_COUNT
+};
+
+struct printDataGenParameters
+{
+    const char* genericFormat;
+    const char* dataRepresentation;
+    const char* vectorFormatFlag;
+    const char* vectorFormatSpecifier;
+    const char* dataType;
+    const char* vectorSize;
+    const char* addrSpaceArgumentTypeQualifier;
+    const char* addrSpaceVariableTypeQualifier;
+    const char* addrSpaceParameter;
+    const char* addrSpacePAdd;
+};
+
+//-----------------------------------------
+//Test Case
+//-----------------------------------------
+
+struct testCase
+{
+    unsigned int _testNum;                           //test number
+    enum Type _type;                                 //(data)type for test
+    //const char** _strPrint;                          //auxiliary data to build the code for kernel source
+    const char** _correctBuffer;                     //look-up table for correct results for printf
+    struct printDataGenParameters* _genParameters;   //auxiliary data to build the code for kernel source
+};
+
+
+extern const char* strType[];
+extern testCase* allTestCase[];
+
+size_t verifyOutputBuffer(char *analysisBuffer,testCase* pTestCase,size_t testId,cl_ulong pAddr = 0);
+
+// Helpful macros
+
+// The next three functions check on different return values.  Returns -1
+// if the check failed
+#define checkErr(err, msg)                \
+    if (err != CL_SUCCESS) {                \
+    log_error("%s failed errcode:%d\n", msg, err);    \
+    return -1;                    \
+    }
+
+#define checkZero(val, msg)                \
+    if (val == 0) {                    \
+    log_error("%s failed errcode:%d\n", msg, err);    \
+    return -1;                    \
+    }
+
+#define checkNull(ptr, msg)            \
+    if (!ptr) {                    \
+    log_error("%s failed\n", msg);        \
+    return -1;                \
+    }
+
+// When a helper returns a negative one, we want to return from main
+// with negative one. This helper prevents me from having to write
+// this multiple time
+#define checkHelperErr(err)            \
+    if (err == -1) {                \
+    return err;                \
+    }
+
+#endif // TESTSPRINTF_INCLUDED_H

test_conformance/printf/util_printf.c

@@ -0,0 +1,894 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "../../test_common/harness/compat.h"
+
+#include "test_printf.h"
+
+
+#if defined (_WIN32)
+#define strtoull _strtoi64
+#endif
+
+const char* strType[] = {"int","float","octal","unsigned","hexadecimal","char","string","vector","address space"};
+
+
+
+//==================================
+
+// int
+
+//==================================
+
+//------------------------------------------------------
+
+// [string] format  | [string] int-data representation |
+
+//------------------------------------------------------
+
+struct printDataGenParameters printIntGenParameters[] = {
+
+    //(Minimum)Five-wide,default(right)-justified
+
+    {"%5d","10"},
+
+        //(Minimum)Five-wide,left-justified
+
+    {"%-5d","10"},
+
+        //(Minimum)Five-wide,default(right)-justified,zero-filled
+
+    {"%05d","10"},
+
+        //(Minimum)Five-wide,default(right)-justified,with sign
+
+    {"%+5d","10"},
+
+         //(Minimum)Five-wide ,left-justified,with sign
+
+    {"%-+5d","10"},
+
+        //(Minimum)Five-digit(zero-filled in absent digits),default(right)-justified
+
+    {"%.5i","100"},
+
+        //(Minimum)Six-wide,Five-digit(zero-filled in absent digits),default(right)-justified
+
+    {"%6.5i","100"},
+
+        //0 and - flag both apper ==>0 is ignored,left-justified,capital I
+
+    {"%-06i","100"},
+
+        //(Minimum)Six-wide,Five-digit(zero-filled in absent digits),default(right)-justified
+
+    {"%06.5i","100"}
+
+};
+
+//------------------------------------------------
+
+// Lookup table - [string]int-correct buffer     |
+
+//------------------------------------------------
+
+const char *correctBufferInt[] = {
+
+    "   10",
+
+    "10   ",
+
+    "00010",
+
+    "  +10",
+
+    "+10  ",
+
+    "00100",
+
+    " 00100",
+
+    "100   ",
+
+    " 00100"
+
+};
+
+
+
+
+
+//-----------------------------------------------
+
+//test case for int                             |
+
+//-----------------------------------------------
+
+testCase testCaseInt = {
+
+    sizeof(correctBufferInt)/sizeof(char*),
+
+    TYPE_INT,
+
+    correctBufferInt,
+
+    printIntGenParameters
+
+};
+
+
+
+
+
+//==============================================
+
+// float
+
+//==============================================
+
+
+
+//--------------------------------------------------------
+
+// [string] format |  [string] float-data representation |
+
+//--------------------------------------------------------
+
+struct printDataGenParameters printFloatGenParameters[] = {
+
+    //Default(right)-justified
+
+    {"%f","10.3456"},
+
+    //One position after the decimal,default(right)-justified
+
+    {"%.1f","10.3456"},
+
+    //Two positions after the decimal,default(right)-justified
+
+    {"%.2f","10.3456"},
+
+    //(Minimum)Eight-wide,three positions after the decimal,default(right)-justified
+
+    {"%8.3f","10.3456"},
+
+    //(Minimum)Eight-wide,two positions after the decimal,zero-filled,default(right)-justified
+
+    {"%08.2f","10.3456"},
+
+    //(Minimum)Eight-wide,two positions after the decimal,left-justified
+
+    {"%-8.2f","10.3456"},
+
+    //(Minimum)Eight-wide,two positions after the decimal,with sign,default(right)-justified
+
+    {"%+8.2f","-10.3456"},
+
+    //Zero positions after the decimal([floor]rounding),default(right)-justified
+
+    {"%.0f","0.1"},
+
+    //Zero positions after the decimal([ceil]rounding),default(right)-justified
+
+    {"%.0f","0.6"},
+
+    //Zero-filled,default positions number after the decimal,default(right)-justified
+
+    {"%0f","0.6"},
+
+    //Double argument representing floating-point,used by f style,default(right)-justified
+
+    {"%4g","12345.6789"},
+
+    //Double argument representing floating-point,used by e style,default(right)-justified
+
+    {"%4.2g","12345.6789"},
+
+    //Double argument representing floating-point,used by f style,default(right)-justified
+
+    {"%4G","0.0000023"},
+
+    //Double argument representing floating-point,used by e style,default(right)-justified
+
+    {"%4G","0.023"},
+
+    //Double argument representing floating-point,with exponent,left-justified,default(right)-justified
+
+    {"%-#20.15e","789456123.0"},
+
+    //Double argument representing floating-point,with exponent,left-justified,with sign,capital E,default(right)-justified
+
+    {"%+#21.15E","789456123.0"},
+
+#if ! defined( __ANDROID__ )
+
+    //Double argument representing floating-point,in [-]xh.hhhhpAd style
+
+    {"%.6a","0.1"},
+
+    //(Minimum)Ten-wide,Double argument representing floating-point,in xh.hhhhpAd style,default(right)-justified
+
+    {"%10.2a","9990.235"},
+
+#endif
+
+    //Infinity (1.0/0.0)
+
+    {"%f","1.0f/0.0f"},
+
+    //NaN
+
+    {"%f","sqrt(-1.0f)"},
+
+    //NaN
+    {"%f","acospi(2.0f)"}
+    };
+//--------------------------------------------------------
+
+//  Lookup table - [string]float-correct buffer             |
+
+//--------------------------------------------------------
+
+const char* correctBufferFloat[] = {
+
+    "10.345600",
+
+    "10.3",
+
+    "10.35",
+
+    "  10.346",
+
+    "00010.35",
+
+    "10.35   ",
+
+    "  -10.35",
+
+    "0",
+
+    "1",
+
+    "0.600000",
+
+    "12345.7",
+
+    "1.2e+4",
+
+    "2.3E-6",
+
+    "0.023",
+
+    "7.894561230000000e+8",
+
+    "+7.894561230000000E+8",
+
+#if ! defined( __ANDROID__ )
+
+    "0x1.99999ap-4",
+
+    "0x1.38p+13",
+
+#endif
+
+    "inf",
+
+    "-nan",
+
+    "nan"
+};
+
+//---------------------------------------------------------
+
+//Test case for float                                     |
+
+//---------------------------------------------------------
+
+testCase testCaseFloat = {
+
+    sizeof(correctBufferFloat)/sizeof(char*),
+
+    TYPE_FLOAT,
+
+    correctBufferFloat,
+
+    printFloatGenParameters
+
+};
+
+
+
+//=========================================================
+
+// octal
+
+//=========================================================
+
+
+
+//---------------------------------------------------------
+
+// [string] format  | [string] octal-data representation  |
+
+//---------------------------------------------------------
+
+struct printDataGenParameters printOctalGenParameters[] = {
+
+    //Default(right)-justified
+
+    {"%o","10"},
+
+    //Five-digit,default(right)-justified
+
+    {"%.5o","10"},
+
+    //Default(right)-justified,increase precision
+
+    {"%#o","100000000"},
+
+    //(Minimum)Four-wide,Five-digit,0-flag ignored(because of precision),default(right)-justified
+
+    {"%04.5o","10"}
+
+};
+
+//-------------------------------------------------------
+
+// Lookup table - [string] octal-correct buffer            |
+
+//-------------------------------------------------------
+
+
+
+const char* correctBufferOctal[] = {
+
+    "12",
+
+    "00012",
+
+    "0575360400",
+
+    "00012"
+
+};
+
+//-------------------------------------------------------
+
+//Test case for octal                                   |
+
+//-------------------------------------------------------
+
+testCase testCaseOctal = {
+
+    sizeof(correctBufferOctal)/sizeof(char*),
+
+    TYPE_OCTAL,
+
+    correctBufferOctal,
+
+    printOctalGenParameters
+
+};
+
+
+
+//=========================================================
+
+// unsigned
+
+//=========================================================
+
+
+
+//---------------------------------------------------------
+
+// [string] format  | [string] unsined-data representation  |
+
+//---------------------------------------------------------
+
+struct printDataGenParameters printUnsignedGenParameters[] = {
+
+    //Default(right)-justified
+
+    {"%u","10"},
+
+    //Zero precision for zero,default(right)-justified
+
+    {"%.0u","0"},
+
+};
+
+//-------------------------------------------------------
+
+// Lookup table - [string] octal-correct buffer            |
+
+//-------------------------------------------------------
+
+
+
+const char* correctBufferUnsigned[] = {
+
+    "10",
+
+    ""
+
+};
+
+//-------------------------------------------------------
+
+//Test case for octal                                   |
+
+//-------------------------------------------------------
+
+testCase testCaseUnsigned = {
+
+    sizeof(correctBufferUnsigned)/sizeof(char*),
+
+    TYPE_UNSIGNED,
+
+    correctBufferUnsigned,
+
+    printUnsignedGenParameters
+
+};
+
+
+
+//=======================================================
+
+// hexadecimal
+
+//=======================================================
+
+
+
+//--------------------------------------------------------------
+
+// [string] format  | [string] hexadecimal-data representation |
+
+//--------------------------------------------------------------
+
+struct printDataGenParameters printHexadecimalGenParameters[] = {
+
+    //Add 0x,low x,default(right)-justified
+
+    {"%#x","0xABCDEF"},
+
+    //Add 0x,capital X,default(right)-justified
+
+    {"%#X","0xABCDEF"},
+
+    //Not add 0x,if zero,default(right)-justified
+
+    {"%#X","0"},
+
+    //(Minimum)Eight-wide,default(right)-justified
+
+    {"%8x","399"},
+
+    //(Minimum)Four-wide,zero-filled,default(right)-justified
+
+    {"%04x","399"}
+
+};
+
+//--------------------------------------------------------------
+
+// Lookup table - [string]hexadecimal-correct buffer           |
+
+//--------------------------------------------------------------
+
+
+
+const char* correctBufferHexadecimal[] = {
+
+    "0xabcdef",
+
+    "0XABCDEF",
+
+    "0",
+
+    "     18f",
+
+    "018f"
+
+};
+
+//--------------------------------------------------------------
+
+//Test case for hexadecimal                                    |
+
+//--------------------------------------------------------------
+
+testCase testCaseHexadecimal = {
+
+    sizeof(correctBufferHexadecimal)/sizeof(char*),
+
+    TYPE_HEXADEC,
+
+    correctBufferHexadecimal,
+
+    printHexadecimalGenParameters
+
+};
+
+
+
+//=============================================================
+
+// char
+
+//=============================================================
+
+
+
+//-----------------------------------------------------------
+
+// [string] format  | [string] string-data representation   |
+
+//-----------------------------------------------------------
+
+struct printDataGenParameters printCharGenParameters[] = {
+
+    //Four-wide,zero-filled,default(right)-justified
+
+    {"%4c","\'1\'"},
+
+        //Four-wide,left-justified
+
+    {"%-4c","\'1\'"},
+
+        //(unsigned) int argument,default(right)-justified
+
+    {"%c","66"}
+
+};
+
+//---------------------------------------------------------
+
+// Lookup table -[string] char-correct buffer             |
+
+//---------------------------------------------------------
+
+const char * correctBufferChar[] = {
+
+    "   1",
+
+    "1   ",
+
+    "B",
+
+};
+
+
+
+//----------------------------------------------------------
+
+//Test case for char                                       |
+
+//----------------------------------------------------------
+
+testCase testCaseChar = {
+
+    sizeof(correctBufferChar)/sizeof(char*),
+
+    TYPE_CHAR,
+
+    correctBufferChar,
+
+    printCharGenParameters
+
+};
+
+
+
+//==========================================================
+
+// string
+
+//==========================================================
+
+
+
+//--------------------------------------------------------
+
+// [string]format | [string] string-data representation  |
+
+//--------------------------------------------------------
+
+struct printDataGenParameters printStringGenParameters[] = {
+
+    //(Minimum)Four-wide,zero-filled,default(right)-justified
+
+    {"%4s","\"foo\""},
+
+    //One-digit(precision ignored),left-justified
+
+    {"%.1s","\"foo\""},
+
+    //%% specification
+
+    {"%s","\"%%\""},
+
+    //null string
+
+    {"%s","(void*)0"}
+
+};
+
+//---------------------------------------------------------
+
+// Lookup table -[string] string-correct buffer           |
+
+//---------------------------------------------------------
+
+const char * correctBufferString[] = {
+
+    " foo",
+
+    "f",
+
+    "%%",
+
+    "(null)"
+
+};
+
+//---------------------------------------------------------
+
+//Test case for string                                    |
+
+//---------------------------------------------------------
+
+testCase testCaseString = {
+
+    sizeof(correctBufferString)/sizeof(char*),
+
+    TYPE_STRING,
+
+    correctBufferString,
+
+    printStringGenParameters
+
+};
+
+
+
+//=========================================================
+
+// vector
+
+//=========================================================
+
+
+
+//-------------------------------------------------------------------------------------------------------------------
+
+//[string] flag | [string] specifier | [string] type | [string] vector-data representation | [string] vector size   |
+
+//-------------------------------------------------------------------------------------------------------------------
+
+struct printDataGenParameters printVectorGenParameters[]={
+
+    //(Minimum)Two-wide,two positions after decimal
+
+    {NULL,"(1.0f,2.0f,3.0f,4.0f)","%2.2","hlf","float","4"},
+
+    //Alternative form,uchar argument
+
+    {NULL,"(0xFA,0xFB)","%#","hhx","uchar","2"},
+
+    //Alternative form,ushort argument
+
+    {NULL,"(0x1234,0x8765)","%#","hx","ushort","2"},
+
+  //Alternative form,uint argument
+
+    {NULL,"(0x12345678,0x87654321)","%#","hlx","uint","2"},
+
+    //Alternative form,long argument
+
+    {NULL,"(12345678,98765432)","%","ld","long","2"}
+
+};
+
+//------------------------------------------------------------
+
+// Lookup table -[string] vector-correct buffer              |
+
+//------------------------------------------------------------
+
+const char * correctBufferVector[] = {
+
+    "1.00,2.00,3.00,4.00",
+
+    "0xfa,0xfb",
+
+    "0x1234,0x8765",
+
+  "0x12345678,0x87654321",
+
+    "12345678,98765432"
+
+};
+
+//-----------------------------------------------------------
+
+//Test case for vector                                      |
+
+//-----------------------------------------------------------
+
+testCase testCaseVector = {
+
+    sizeof(correctBufferVector)/(sizeof(char *)),
+
+    TYPE_VECTOR,
+
+    correctBufferVector,
+
+    printVectorGenParameters
+
+};
+
+
+
+//==================================================================
+
+// address space
+
+//==================================================================
+
+
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+// [string] argument type qualifier |[string] variable type qualifier + initialization | [string] format | [string] parameter |[string]%p indicator/additional code |
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+
+struct printDataGenParameters printAddrSpaceGenParameters[]={
+
+    //Global memory region
+
+    {"\"%d\\n\"",NULL,NULL,NULL,NULL,NULL,"__global int* x","","*x",""},
+
+    //Global,constant, memory region
+
+    {"\"%d\\n\"",NULL,NULL,NULL,NULL,NULL,"constant int* x","","*x",""},
+
+    //Local memory region
+
+    {"\"%+d\\n\"",NULL,NULL,NULL,NULL,NULL,"","local int x;\n x= (int)3;\n","x",""},
+
+    //Private memory region
+
+    {"\"%i\\n\"",NULL,NULL,NULL,NULL,NULL,"","private int x;\n x = (int)-1;\n","x",""},
+
+    //Address of void * from global memory region
+
+    {"\"%p\\n\"",NULL,NULL,NULL,NULL,NULL,"__global void* x,__global intptr_t*  xAddr","","x","*xAddr = (intptr_t)x;\n"}
+
+};
+
+//-------------------------------------------------------------------------------
+
+//  Lookup table -[string] address space -correct buffer                        |
+
+//-------------------------------------------------------------------------------
+
+const char * correctAddrSpace[] = {
+
+    "2","2","+3","-1",""
+
+};
+
+//-------------------------------------------------------------------------------
+
+//Test case for address space                                                   |
+
+//-------------------------------------------------------------------------------
+
+testCase testCaseAddrSpace = {
+
+    sizeof(correctAddrSpace)/(sizeof(char *)),
+
+    TYPE_ADDRESS_SPACE,
+
+    correctAddrSpace,
+
+    printAddrSpaceGenParameters
+
+};
+
+
+
+//-------------------------------------------------------------------------------
+
+//All Test cases                                                                |
+
+//-------------------------------------------------------------------------------
+
+testCase* allTestCase[] = {&testCaseInt,&testCaseFloat,&testCaseOctal,&testCaseUnsigned,&testCaseHexadecimal,&testCaseChar,&testCaseString,&testCaseVector,&testCaseAddrSpace};
+
+
+//-----------------------------------------
+
+// Check functions
+
+//-----------------------------------------
+
+size_t verifyOutputBuffer(char *analysisBuffer,testCase* pTestCase,size_t testId,cl_ulong pAddr)
+{
+    int terminatePos = strlen(analysisBuffer);
+        if(terminatePos > 0)
+    {
+        analysisBuffer[terminatePos - 1] = '\0';
+    }
+
+    //Convert analysis buffer to long for address space
+    if(pTestCase->_type == TYPE_ADDRESS_SPACE && strcmp(pTestCase->_genParameters[testId].addrSpacePAdd,""))
+
+    {
+        char analysisBufferTmp[ANALYSIS_BUFFER_SIZE];
+
+        if(strstr(analysisBuffer,"0x") == NULL)
+        // Need to prepend 0x to ASCII number before calling strtol.
+        strcpy(analysisBufferTmp,"0x");
+
+        else analysisBufferTmp[0]='\0';
+        strcat(analysisBufferTmp,analysisBuffer);
+        if (sizeof(long) == 8) {
+            if(strtoul(analysisBufferTmp,NULL,0) == pAddr) return 0;
+        }
+        else {
+            if(strtoull(analysisBufferTmp,NULL,0) == pAddr) return 0;
+        }
+        return 1;
+
+    }
+
+    char* exp;
+    //Exponenent representation
+    if((exp = strstr(analysisBuffer,"E+")) != NULL || (exp = strstr(analysisBuffer,"e+")) != NULL || (exp = strstr(analysisBuffer,"E-")) != NULL || (exp = strstr(analysisBuffer,"e-")) != NULL)
+    {
+        char correctExp[3]={0};
+        strncpy(correctExp,exp,2);
+
+
+        char* eCorrectBuffer = strstr((char*)pTestCase->_correctBuffer[testId],correctExp);
+        if(eCorrectBuffer == NULL)
+            return false;
+
+        eCorrectBuffer+=2;
+        exp += 2;
+
+        //Exponent always contains at least two digits
+        if(strlen(exp) < 2)
+            return false;
+        //Scip leading zeros in the exponent
+        while(*exp == '0')
+            ++exp;
+        return strcmp(eCorrectBuffer,exp);
+    }
+    if(!strcmp(pTestCase->_correctBuffer[testId],"inf"))
+    return strcmp(analysisBuffer,"inf")&&strcmp(analysisBuffer,"infinity")&&strcmp(analysisBuffer,"1.#INF00")&&strcmp(analysisBuffer,"Inf");
+    if(!strcmp(pTestCase->_correctBuffer[testId],"nan") || !strcmp(pTestCase->_correctBuffer[testId],"-nan")) {
+      return strcmp(analysisBuffer,"nan")&&strcmp(analysisBuffer,"-nan")&&strcmp(analysisBuffer,"1.#IND00")&&strcmp(analysisBuffer,"-1.#IND00")&&strcmp(analysisBuffer,"NaN")&&strcmp(analysisBuffer,"nan(ind)")&&strcmp(analysisBuffer,"nan(snan)");
+    }
+    return strcmp(analysisBuffer,pTestCase->_correctBuffer[testId]);
+}
+