my_tests.c

gistfile1.txt

#ifndef MY_TESTS
#define MY_TESTS

#include "my_str_str.c"
//#include "my_str_strv16.h"

void AllTests();
void TestMyStrStr();
void TestGood();
void HTest();

void ok_test(char *test_name);
void fail_test(char *test_name);
void fail_test_str_str(char*test_name, char *s, char *p,char *ret);
void test_error(char *mes);

//переменные с количественными результатами теста
int ok;
int fail;
int error;
int show_ok_test = 0;

#define STR_STR_NAME my_strstr
//true full
#define TFull(func,str,pat,sl,pl,REZ,test_name) \
    {char *f_rez = func((str),(pat),(sl),(pl));\
    if((f_rez)==REZ){ok_test(test_name);}\
    else{fail_test_str_str((test_name), (str), (pat),(f_rez));}}

//
#define T(p, mess) if(p){ fail_test(mess);}else{ ok_test(mess);}


//
#define COPY_STR(src,dst,ind_begin, len) if((src)!=NULL && (dst)!=NULL)\
{if((len) == 0){(dst)[0]=0;}\
    else{memcpy( (dst), &(src)[(ind_begin)], sizeof(char)*(len));(dst)[(len)]=0;}}\
else{fail_test("Ошибка в тестах COPY_STR(), dst или src равен NULL\n");}



void ok_test(char *test_name){
    ok++;
    if(show_ok_test!=0){
        char str_null[] = "NULL";
        char *in_t = test_name != NULL ? test_name : str_null;
        printf(" Ok test: %s\n",in_t);
    }
}

void fail_test(char *test_name)
{
    fail++;
    char str_null[] = "NULL";
    char *in_t = test_name != NULL ? test_name : str_null;
    printf(" Fail test: %s\n",in_t);
}
void fail_test_str_str(char*test_name, char *s, char *p,char *ret)
{

    fail++;

    char str_null[] = "NULL";
    char str_cutted[] = " ... CUTTED";
    const size_t max_len = 70;

    char *in_t = test_name != NULL ? test_name : str_null;
    char *in_s = s != NULL ? s : str_null;
    char *in_p = p != NULL ? p : str_null;
    char *in_r = ret!=NULL ? ret : str_null;


    char s_buf[max_len];
    char p_buf[max_len];
    char r_buf[max_len];
    size_t s_len = strlen(in_s);
    size_t p_len = strlen(in_p);
    size_t r_len = strlen(in_r);

    if(s_len>max_len){
        size_t pos = max_len-strlen(str_cutted)-1;
        COPY_STR(in_s,s_buf,0, pos);
        COPY_STR(str_cutted,(s_buf+pos),0,strlen(str_cutted));
        s_buf[max_len-1] = 0;
        in_s = s_buf;
    }
    if(p_len>max_len){
        size_t pos = max_len-strlen(str_cutted)-1;
        COPY_STR(in_p,p_buf,0, pos);
        COPY_STR(str_cutted,(p_buf+pos),0,strlen(str_cutted));
        p_buf[max_len-1] = 0;
        in_p = p_buf;
    }
    if(r_len>max_len){
        size_t pos = max_len-strlen(str_cutted)-1;
        COPY_STR(in_r,r_buf,0, pos);
        COPY_STR(str_cutted,(r_buf+pos),0,strlen(str_cutted));
        r_buf[max_len-1] = 0;
        in_r = r_buf;
    }

    printf(" Fail ind test: %s\n s=%s\n p=%s\n return=%s\n",in_t, in_s,in_p,in_r);
}

void test_error(char *mes){
    error++;
    printf(" TEST ERROR: %s",mes);
}

void TestMyStrStr(){
    //test_strstr_self
    //Сама на себя
    char s[20] = "Testovaya strochka!\0";
    char p[20] = "Testovaya strochka!\0";
    size_t s_len = strlen(s);
    size_t p_len = strlen(p);

    TFull(STR_STR_NAME,s,p,s_len,p_len,s,"test_strstr_self");

    //test_strstr_s_null
    //s=null
    char *s_null = NULL;
    TFull(STR_STR_NAME,s_null,p,0,p_len,NULL,"test_strstr_s_null");

    //test_strstr_p_null
    //p = NULL
    char *p_null = NULL;
    TFull(STR_STR_NAME,s,p_null,s_len,0,NULL,"test_strstr_p_null");

    //test_strstr_s_larger_p
    //str_len < pat_len
    char s_len_test[] = "short";
    char p_len_test[] = "dlinnayaaaaaf";
    s_len = strlen(s_len_test);
    p_len = strlen(p_len_test);
    if(s_len>=p_len){
        test_error("Ошибка в тесте (str_len < pat_len)");
    };
    TFull(STR_STR_NAME,s_len_test,p_len_test,s_len,p_len,NULL,"test_strstr_s_larger_p");


    //test_strstr_s_len_zero
    //str_len == 0
    s_len = 0;
    p_len = strlen(p);
    TFull(STR_STR_NAME,s,p,s_len,p_len,NULL,"test_strstr_s_len_zero");


    //test_strstr_p_len_zero
    //pat_len == 0
    s_len = strlen(s);
    p_len = 0;
    TFull(STR_STR_NAME,s,p,s_len,p_len,NULL,"test_strstr_p_len_zero");

    //когда написаны одни цифры, а пришли другие
    //str = ""
    //char empty_str[] = "";
    //fail_test("char empty_str[]");


    //pat = ""
    //когда написаны одни цифры, а пришли строкой другие
    //char pat[] = "";
    //fail_test("char empty_str[]");


    //test_strstr_allocator_fail
    //pat>max, Allocator fail
    p_len = 1024*1024*1024*8;
    TFull(STR_STR_NAME,s,p,s_len,p_len,NULL,"test_strstr_allocator_fail");


    //Перебор
    //test_strstr_perebor
    char a_str[32] = "strOka dly_pEReBoPA;.-ZN";
    char a_pat[32];
    size_t i,j;
    size_t len = strlen(a_str);
    for(i=1;i<len; i++)
    {
        for(j=0; j<len-i;j++){
            //copy_str
            if(a_str!=NULL && a_pat!=NULL)\
            {
                if(i == 0)
                {
                    a_pat[0]=0;
                }\
                else
                {
                    memcpy( a_pat, &a_str[j], sizeof(char)*i);
                    a_pat[i]=0;
                }
            }\
            else
            {
                fail_test("Ошибка в тестах COPY_STR(), dst или src равен NULL\n");
            }
            //test_strstr_perebor
            TFull(STR_STR_NAME,a_str,a_pat,len,i,(a_str+j),"test_strstr_perebor");

            /*int ind_z = i!=1 ? rand() % i : 0;
            //test_strstr_perebor_is_NULL
            //a_pat[ind_z] = 255;
            TFull(STR_STR_NAME,a_str,a_pat,len,i,NULL,"test_strstr_perebor_is_NULL");*/
        }
    }



    //test_big_str
    len = 1024*1024;
    unsigned char* big_str = malloc(len *sizeof(char));
    char* big_pat = big_str + 1024*128;
    if(big_str == NULL){
        test_error("memory allocation fail..");
        return;
    }
    unsigned char base = 'a';
    unsigned char amp = 20;
    for(i=0;i<len;i++){
        big_str[i] = rand()%amp+base;
    }

    TFull(STR_STR_NAME, big_str, big_pat, len, strlen(big_pat), big_pat, "test_big_str");

    if(big_str!=NULL)
        free(big_str);
}


void TestGood()
{
    size_t i,j,k;
    //
    char p[] = "aaaaaaaaabbbbbbbbb";
    void *buf=NULL;
    size_t g_len = GetBufferSizeForGood(strlen(p));
    buf = malloc(g_len);
    if(buf == NULL){
        test_error("memory allocation fail..");
        return;
    }
    memset(buf, 0, g_len);
    struct good* g = CreateGood(buf, strlen(p));
    for(i =0; i<strlen(p);i++){
        AddElementToGood(g,p[i],i);
    }
    //test_good_g_creategood g==NULL
    T(g== NULL, "test_good_g_creategood  g==NULL");

    //test_good_g_creategood_1
    T(g->last_not_used_el != 19, "test_good_g_creategood_1");

    //test_good_g_creategood_2
    T(g->headers['a'].count != 9,"test_good_g_creategood_2");

    //test_good_g_creategood_3
    T(g->headers['b'].count != 9,"test_good_g_creategood_3");

    if(buf == NULL)
        free(buf);

    //empty
    char empty_p[] = "";
    g_len = GetBufferSizeForGood(strlen(empty_p));
    buf = malloc(g_len);
    if(buf == NULL){
        test_error("memory allocation fail..");
        return;
    }
    memset(buf, 0, g_len);
    g = CreateGood(buf,0);

    //test_create_empty_good
    T(g== NULL, "test_create_empty_good");

    if(buf == NULL)
        free(buf);


    //add tests
    buf=NULL;
    size_t elements_length = 512;
    g_len = sizeof(struct good)
            + sizeof(struct element)*(elements_length+1);
    buf = malloc(g_len);
    if(buf == NULL){
        test_error("memory allocation fail..");
        return;
    }
    memset(buf, 0, g_len);
    g = CreateGood(buf, 18);
    //test_good_g_creategood 3 g==NULL
    T(g== NULL, "test_good_g_creategood 3 g==NULL");


    //add first_element test
    for(i=0; i<256;i++){
        AddElementToGood(g, i, i+1);
    }
    //проверка правильности заполенния элементами
    //test_add_element_to_good_size
    T(g->last_not_used_el!=257,"test_add_element_to_good_size");

    for(i=0;i<256; i++)
    {
        //поля заголовка
        struct header *h = &(g->headers[i]);
        //test_add_element_to_good_field_count
        T(h->count != 1, "test_add_element_to_good_field_count");
        //test_add_element_to_good_field_first_el
        T(h->first_el != i+1, "test_add_element_to_good_field_first_el");
        //test_add_element_to_good_field_end_el
        T(h->end_el != i+1, "test_add_element_to_good_field_end_el");

        //поля первого эелмента
        struct element *el = &(g->elements[h->first_el]);
        //test_add_element_to_good_field Field first_element next_el
        T(el->next_el != 0, "test_add_element_to_good_field Field first_element_next_el");

        //test_add_element_to_good_field Field first_element index
        T(el->index != i+1, "test_add_element_to_good_field Field index");
    }

    //add second element test
    i = 0;
    for(i=0; i<256;i++){
        AddElementToGood(g, i, i+1);
    }
    //
    for( i=0; i<256; i++){
        //поля заголовка
        struct header *h = &(g->headers[i]);

        //поля второго элемента
        struct element *first_el = &(g->elements[h->first_el]);
        //test_add_element_to_good_field in second_element
        T((h->first_el == 0||h->first_el > 512), "test_add_element_to_good_field in second_element");

        struct element *el = &(g->elements[first_el->next_el]);
        //test_add_element_to_good_field Field second_element
        T(el->next_el != 0, "test_add_element_to_good_field Field second_element next_el");

        //test_add_element_to_good_field Field second_element index
        T(el->index != i+1, "test_add_element_to_good_field Field index");
    }

    if(buf == NULL)
        free(buf);
}

void HTest(){
    char s[] ="strOka dly_pEReBoPA;.-ZN";
    char p[] = "O";
    STR_STR_NAME(s,p,strlen(s),strlen(p));
}

void AllTests(){

    show_ok_test=0;

    ok = 0;
    fail =0;
    error = 0;
    printf("---------\nTests begin:\n");
    HTest();
    TestMyStrStr();
    TestGood();
    printf("\n---------\nTests end:\nResult:\n Ok: -%d\n Fail: - %d\n TestError: - %d\n-------",
           ok,fail,error);

}

#endif // MY_TESTS