Module base64 [Version: ]

[Main Page] [Details]

Status:

Static Methods:

Testing encode (version _str1):
char *base64::encode(const char *in_str) [Documentation]

test1
Encode/Decode-Test.

∀ in_str ∈ {x|x=ANY_STRING}:
Parameter: (in_str´ = in_str_copy)
Return value: retv = in_str

Additional followup processing:
```
    void *temp=base64::decode(retv);
    if(temp)
    {
        free(retv);
        retv=(char *)temp;
    }
```

Testing encode (version _str2):
char *base64::encode(const char *in_str,bool padding) [Documentation]

test1
Encode/Decode-Test.

∀ in_str ∈ {x|x=ANY_STRING}:
∀ padding ∈ {x|x=ANY_BOOL}:
Parameter: (in_str´ = in_str_copy) ∧ (padding´ = padding_copy)
Return value: retv = in_str

Additional followup processing:
```
    void *temp=base64::decode(retv);
    if(temp)
    {
        free(retv);
        retv=(char *)temp;
    }
```

Testing encode (version _str3):
char *base64::encode(const char *in_str,bool padding,const char *sym,char pad) [Documentation]

test1
Encode/Decode-Test.

∀ in_str ∈ {x|x=ANY_STRING}:
∀ padding ∈ {x|x=ANY_BOOL}:
∀ sym ∈ {x|x=STRING('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/') ∨ x=NOREP_STRING(min=64,max=64,sym='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')}:
∀ pad ∈ {x|x=CHAR(61) ∨ x=CHAR(64)}:
Parameter: (in_str´ = in_str_copy) ∧ (padding´ = padding_copy) ∧ (sym´ = sym_copy) ∧ (pad´ = pad_copy)
Return value: retv = in_str

Additional followup processing:
```
    void *temp=base64::decode(retv,sym,pad);
    if(temp)
    {
        free(retv);
        retv=(char *)temp;
    }
```

Testing encode (version _wcs1):
char *base64::encode(const wchar_t *in_str) [Documentation]

test1
Encode/Decode-Test.

∀ in_str ∈ {x|x=ANY_WSTRING}:
Parameter: (in_str´ = in_str_copy)

Additional testig code:

    wchar_t *temp=(wchar_t *)base64::decode(retv);
    if(temp)
    {
        if(str::cmp(temp,in_str)!=0)
        {
            test_successful=TEST_FAIL;
        }
        free(temp);
    }
    else
    {
        test_successful=TEST_FAIL;
    }

Testing encode (version _wcs2):
char *base64::encode(const wchar_t *in_str,bool padding) [Documentation]

test1
Encode/Decode-Test.

∀ in_str ∈ {x|x=ANY_WSTRING}:
∀ padding ∈ {x|x=ANY_BOOL}:
Parameter: (in_str´ = in_str_copy) ∧ (padding´ = padding_copy)

Additional testig code:

    wchar_t *temp=(wchar_t *)base64::decode(retv);
    if(temp)
    {
        if(str::cmp(temp,in_str)!=0)
        {
            test_successful=TEST_FAIL;
        }
        free(temp);
    }
    else
    {
        test_successful=TEST_FAIL;
    }

Testing encode (version _wcs3):
char *base64::encode(const wchar_t *in_str,bool padding,const char *sym,char pad) [Documentation]

test1
Encode/Decode-Test.

∀ in_str ∈ {x|x=ANY_WSTRING}:
∀ padding ∈ {x|x=ANY_BOOL}:
∀ sym ∈ {x|x=STRING('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/') ∨ x=NOREP_STRING(min=64,max=64,sym='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')}:
∀ pad ∈ {x|x=CHAR(61) ∨ x=CHAR(64)}:
Parameter: (in_str´ = in_str_copy) ∧ (padding´ = padding_copy) ∧ (sym´ = sym_copy) ∧ (pad´ = pad_copy)

Additional testig code:
```
    wchar_t *temp=(wchar_t *)base64::decode(retv,sym,pad);
    if(temp)
    {
        if(str::cmp(temp,in_str)!=0)
        {
            test_successful=TEST_FAIL;
        }
        free(temp);
    }
    else
    {
        test_successful=TEST_FAIL;
    }
```

Testing encode (version _alloc1):
char *base64::encode(void *data,unsigned int length) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy)

Additional testig code:

    void *temp=base64::decode(retv);
    if(temp)
    {
        if(test::datacmp(temp,data,length)!=0)
        {
            test_successful=TEST_FAIL;
            printf("[ERROR] Decode-Test failed.\nretv=%s\n",retv);
            printf("data-length=%d\n",length);
            //for(unsigned int k=0;k< length;k++){printf("data: Byte %d: %d=%d\n",k,((char *)data)[k],((char *)temp)[k]);}
        }
        free(temp);
    }
    else
    {
        test_successful=TEST_FAIL;
        printf("[ERROR] base64::decode returned 0.\\n");
    }

Testing encode (version _alloc2):
char *base64::encode(void *data,unsigned int length,bool padding) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
∀ padding ∈ {x|x=ANY_BOOL}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy) ∧ (padding´ = padding_copy)

Additional testig code:

    void *temp=base64::decode(retv);
    if(temp)
    {
        if(test::datacmp(temp,data,length)!=0)
        {
            test_successful=TEST_FAIL;
            printf("[ERROR] Decode-Test failed.\nretv=%s\n",retv);
            printf("data-length=%d\n",length);
            //for(unsigned int k=0;k< length;k++){printf("data: Byte %d: %d=%d\n",k,((char *)data)[k],((char *)temp)[k]);}
        }
        free(temp);
    }
    else
    {
        test_successful=TEST_FAIL;
        printf("[ERROR] base64::decode returned 0.\\n");
    }

Testing encode (version _alloc3):
char *base64::encode(void *data,unsigned int length,bool padding,const char *sym,char pad) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
∀ padding ∈ {x|x=ANY_BOOL}:
∀ sym ∈ {x|x=STRING('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/') ∨ x=NOREP_STRING(min=64,max=64,sym='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')}:
∀ pad ∈ {x|x=CHAR(61) ∨ x=CHAR(64)}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy) ∧ (padding´ = padding_copy) ∧ (sym´ = sym_copy) ∧ (pad´ = pad_copy)

Additional testig code:
```
    void *temp=base64::decode(retv,sym,pad);
    if(temp)
    {
        if(test::datacmp(temp,data,length)!=0)
        {
            test_successful=TEST_FAIL;
            printf("[ERROR] Decode-Test failed.\nretv=%s\n",retv);
            printf("data-length=%d\n",length);
            //for(unsigned int k=0;k< length;k++){printf("data: Byte %d: %d=%d\n",k,((char *)data)[k],((char *)temp)[k]);}
        }
        free(temp);
    }
    else
    {
        test_successful=TEST_FAIL;
        printf("[ERROR] base64::decode returned 0.\\n");
    }
```

Testing encode (version 1):
int base64::encode(void *data,unsigned int length,char *bstr) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
∀ bstr ∈ {x|x=STRING(2048)}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy) ∧ (bstr´ = bstr)
Return value: retv = 0

Additional testig code:

    void *temp_decoded=base64::decode(bstr);
    if(temp_decoded)
    {
        if(!(test::datacmp(data_copy,temp_decoded,gen.getInteger("$DATA_LEN"))==0))
        {
            test_successful=TEST_FAIL;
        }
        free(temp_decoded);
    }
    else
    {
        test_successful=TEST_FAIL;
    }

Testing encode (version 2):
int base64::encode(void *data,unsigned int length,char *bstr,bool padding) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
∀ bstr ∈ {x|x=STRING(2048)}:
∀ padding ∈ {x|x=ANY_BOOL}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy) ∧ (bstr´ = bstr) ∧ (padding´ = padding_copy)
Return value: retv = 0

Additional testig code:
```
    void *temp_decoded=base64::decode(bstr);
    if(temp_decoded)
    {
        if(!(test::datacmp(data_copy,temp_decoded,gen.getInteger("$DATA_LEN"))==0))
        {
            test_successful=TEST_FAIL;
        }
        free(temp_decoded);
    }
    else
    {
        test_successful=TEST_FAIL;
    }
```

Testing encode (version 3):
int base64::encode(void *data,unsigned int length,char *bstr,bool padding,const char *sym,char pad) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
∀ bstr ∈ {x|x=STRING(2048)}:
∀ padding ∈ {x|x=ANY_BOOL}:
∀ sym ∈ {x|x=STRING('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/') ∨ x=NOREP_STRING(min=64,max=64,sym='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')}:
∀ pad ∈ {x|x=CHAR(61) ∨ x=CHAR(64)}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy) ∧ (bstr´ = bstr) ∧ (padding´ = padding_copy) ∧ (sym´ = sym_copy) ∧ (pad´ = pad_copy)
Return value: retv = 0

Additional testig code:
```
    void *temp_decoded=base64::decode(bstr,sym,pad);
    if(temp_decoded)
    {
        if(!(test::datacmp(data_copy,temp_decoded,gen.getInteger("$DATA_LEN"))==0))
        {
            test_successful=TEST_FAIL;
        }
        free(temp_decoded);
    }
    else
    {
        test_successful=TEST_FAIL;
    }
```

Testing encode (version _s1):
int base64::encode(void *data,unsigned int length,char *bstr,unsigned int bln) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
∀ bstr ∈ {x|x=STRING(2048)}:
∀ bln ∈ {x|x=INTEGER(2048)}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy) ∧ (bstr´ = bstr) ∧ (bln´ = bln_copy)
Return value: retv = 0

Additional testig code:
```
    void *temp_decoded=base64::decode(bstr);
    if(temp_decoded)
    {
        if(!(test::datacmp(data_copy,temp_decoded,gen.getInteger("$DATA_LEN"))==0))
        {
            test_successful=TEST_FAIL;
        }
        free(temp_decoded);
    }
    else
    {
        test_successful=TEST_FAIL;
    }
```

Testing encode (version _s2):
int base64::encode(void *data,unsigned int length,char *bstr,unsigned int bln,bool padding) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
∀ bstr ∈ {x|x=STRING(2048)}:
∀ bln ∈ {x|x=INTEGER(2048)}:
∀ padding ∈ {x|x=ANY_BOOL}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy) ∧ (bstr´ = bstr) ∧ (bln´ = bln_copy) ∧ (padding´ = padding_copy)
Return value: retv = 0

Additional testig code:
```
    void *temp_decoded=base64::decode(bstr);
    if(temp_decoded)
    {
        if(!(test::datacmp(data_copy,temp_decoded,gen.getInteger("$DATA_LEN"))==0))
        {
            test_successful=TEST_FAIL;
        }
        free(temp_decoded);
    }
    else
    {
        test_successful=TEST_FAIL;
    }
```

Testing encode (version _s3):
int base64::encode(void *data,unsigned int length,char *bstr,unsigned int bln,bool padding,const char *sym,char pad) [Documentation]

test1
Encode/Decode-Test.

let $DATA_LEN=INTEGER(min=1,max=1024)
∀ data ∈ {x|x=STRING(len=$DATA_LEN)}:
∀ length ∈ {x|x=INTEGER($DATA_LEN)}:
∀ bstr ∈ {x|x=STRING(2048)}:
∀ bln ∈ {x|x=INTEGER(2048)}:
∀ padding ∈ {x|x=ANY_BOOL}:
∀ sym ∈ {x|x=STRING('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/') ∨ x=NOREP_STRING(min=64,max=64,sym='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')}:
∀ pad ∈ {x|x=CHAR(61) ∨ x=CHAR(64)}:
Parameter: (data´ = data_copy) ∧ (length´ = length_copy) ∧ (bstr´ = bstr) ∧ (bln´ = bln_copy) ∧ (padding´ = padding_copy) ∧ (sym´ = sym_copy) ∧ (pad´ = pad_copy)
Return value: retv = 0

Additional testig code:
```
    void *temp_decoded=base64::decode(bstr,sym,pad);
    if(temp_decoded)
    {
        if(!(test::datacmp(data_copy,temp_decoded,gen.getInteger("$DATA_LEN"))==0))
        {
            test_successful=TEST_FAIL;
        }
        free(temp_decoded);
    }
    else
    {
        test_successful=TEST_FAIL;
    }
```