CloverBootloader/rEFIt_UEFI/cpp_unit_test/strncmp_test.cpp
2020-08-17 22:40:52 +03:00

214 lines
5.3 KiB
C++
Executable File

#include <Platform.h> // Only use angled for Platform, else, xcode project won't compile
#include "../cpp_foundation/XString.h"
#include "../cpp_foundation/unicode_conversions.h"
#include "global_test.h"
static float rndf() //expected 0..1
{
static UINT32 seed = 12345;
// UINT16 Rand = 0;
// AsmRdRand16(&Rand); //it's a pity panic
// return (float)Rand / 65536.f;
seed = seed * 214013 + 2531011;
float x = (float)seed / 4294967296.0f;
return x;
}
static int sign(int ret) {
if ( ret < 0 ) return -1;
if ( ret > 0 ) return 1;
return 0;
}
static size_t strlen_reference(const char *str)
{
const char *s;
for (s = str; *s; ++s)
;
return (size_t)(s - str);
}
static int strncmp_reference( const char * s1, const char * s2, size_t n )
{
while ( n && *s1 && ( *s1 == *s2 ) )
{
++s1;
++s2;
--n;
}
if ( n == 0 )
{
return 0;
}
else
{
return ( *(unsigned char *)s1 - *(unsigned char *)s2 );
}
}
static int nb_compare = 0;
static int compare(const char*s1, const char*s2, size_t count)
{
nb_compare ++;
//printf("Comparing '%s' and '%s' with count %d\n", s1, s2, count);
int ret1 = strncmp(s1, s2, count);
int ret2 = strncmp_reference(s1, s2, count);
if ( sign(ret1) != sign(ret2) ) {
printf("Comparing '%s' and '%s' with count %zu gives %d and should have given %d\n", s1, s2, count, ret1, ret2);
int ret3 = strncmp(s1, s2, count); // for live debugging
(void)ret3;
return 1; // whatever if not 0
}
return 0;
}
static int symetric_compare(const char*s1, const char*s2, size_t count, int code)
{
int ret;
ret = compare(s1, s1, count);
if ( ret != 0 ) return code;
ret = compare(s2, s2, count);
if ( ret != 0 ) return code;
ret = compare(s1, s2, count);
if ( ret != 0 ) return code;
ret = compare(s2, s1, count);
if ( ret != 0 ) return code;
ret = compare(s1, "", count);
if ( ret != 0 ) return code;
ret = compare("", s1, count);
if ( ret != 0 ) return code;
ret = compare(s2, "", count);
if ( ret != 0 ) return code;
ret = compare("", s2, count);
if ( ret != 0 ) return code;
return 0;
}
// ATENTION : s must count+1 in size
static void fillRandom(char* s, size_t count)
{
size_t i;
for ( i = 0 ; i<count ; i++ ) { // not using strcpy to not depend of another test.
((unsigned char *)s)[i] = (unsigned char)(rndf()*255.0);
}
s[i] = 0;
}
static int compare_s1_s2_with_variable_count(const char* s1, size_t s1count, const char* s2, size_t s2count, int code)
{
size_t test_count = s1count;
if ( s2count > s1count ) test_count = s2count;
for ( size_t count=0 ; count < test_count ; count++ ) {
int ret = 0;
ret = symetric_compare((const char*)s2, s1, count, code);
if ( ret != 0 ) return code;
}
return 0;
}
static int compare_s1_s2_with_variable_count(const char* s1, const char* s2, int code)
{
return compare_s1_s2_with_variable_count(s1, strlen_reference(s1), s2, strlen_reference(s2), code);
}
#ifdef CLOVER_BUILD
#define NB_ITERATIONS 37
#else
#define NB_ITERATIONS 189
#endif
static int compare_s1_with_variable_sizes(const char* s1, size_t s1count, int code)
{
#ifdef CLOVER_BUILD
char s2[514];
#else
char s2[49];
#endif
for ( size_t i=0 ; i < NB_ITERATIONS ; i++ )
{
size_t s2count = (size_t)(rndf()*sizeof(s2)-1);
if ( s2count >= sizeof(s2) ) {
printf("compare_s1_with_variable_sizes, BUG : sizeof=%zu, count=%zu\n", sizeof(s2), s2count);
continue;
}
fillRandom(s2, s2count);
int ret = 0;
ret = compare_s1_s2_with_variable_count(s1, s1count, s2, s2count, code+(int)i);
// for ( size_t k=0 ; k < sizeof(s2) ; k++ ) {
// }
if ( ret != 0 ) return code;
}
return 0;
}
static int compare_with_variable_sizes(int code)
{
char s1[67];
size_t s1count;
for ( s1count=0 ; s1count < sizeof(s1)-1 ; s1count++ ) {
fillRandom(s1, s1count);
int ret = compare_s1_with_variable_sizes((const char*)s1, s1count, code);
if ( ret != 0 ) return code;
}
return 0;
}
/*
* ATTENTION : strlen and str(n)cmp seems to be optimized out if called with litteral.
* like strlen("sdfsdf") is computed at compiled time.
* so far, using a temporary var seems to be enough to not be optmized.
*/
int strncmp_tests()
{
const char* s;
int ret;
// Efficient version of strcmp may do with blocks
// So there maybe a bug when some string has some specific length
s = "aaaaaaaaj";
ret = strncmp(s, "", 8);
s = "";
ret = strncmp(s, "", 2);
ret = symetric_compare("#1D1D1B", "#1D1D1B", 4, 1);
if ( ret != 0 ) return ret;
ret = symetric_compare("#FFFFFF", "#FFFFFF", 4, 1);
if ( ret != 0 ) return ret;
ret = compare_s1_s2_with_variable_count("", "z", 1);
if ( ret != 0 ) return ret;
ret = compare_s1_s2_with_variable_count("a", "b", 10);
if ( ret != 0 ) return ret;
ret = compare_s1_s2_with_variable_count("aaaaaaa", "aaaaaaai", 80);
if ( ret != 0 ) return ret;
ret = compare_s1_s2_with_variable_count("aaaaaaaa", "aaaaaaaaj", 90);
if ( ret != 0 ) return ret;
ret = compare_s1_s2_with_variable_count("aaaaaaaaa", "aaaaaaaaak", 100);
if ( ret != 0 ) return ret;
ret = compare_s1_s2_with_variable_count("aaaaaaaaaa", "aaaaaaaaaal", 110);
if ( ret != 0 ) return ret;
ret = compare_s1_s2_with_variable_count("aaaabbbbccccddddeeeeffffA", "aaaabbbbccccddddeeeeffffM", 120);
if ( ret != 0 ) return ret;
ret = compare_with_variable_sizes(1000000);
if ( ret != 0 ) return ret;
return 0;
}