} END_TEST
START_TEST(test_read_str) {
// It should be ok
char normal[] = "ab";
wzfile file;
create_file(&file, normal, strlen(normal));
wzstr buffer;
wz_init_str(&buffer);
ck_assert_int_eq(wz_read_str(&buffer, strlen(normal), &file), 0);
ck_assert_int_eq(memcmp(buffer.bytes, normal, strlen(normal)), 0);
ck_assert(buffer.len == strlen(normal));
ck_assert(memused() == sizeof(normal));
// It should not change data if position + len > size
wzstr copy = buffer;
ck_assert_int_eq(wz_read_str(&buffer, strlen(normal), &file), 1);
ck_assert(buffer.bytes == copy.bytes);
ck_assert(buffer.len == copy.len);
// It should not allocate memory if position + len > size
ck_assert(memused() == sizeof(normal));
wz_free_str(&buffer);
delete_file(&file);
} END_TEST
} END_TEST
START_TEST(test_free_str) {
// It should be ok
char normal[] = "ab";
wzfile file;
create_file(&file, normal, strlen(normal));
wzstr buffer;
wz_init_str(&buffer);
ck_assert_int_eq(wz_read_str(&buffer, strlen(normal), &file), 0);
ck_assert(memused() == sizeof(normal));
wz_free_str(&buffer);
ck_assert(memused() == 0);
delete_file(&file);
} END_TEST
int main(void)
{
unsigned short preffered_stack_size;
unsigned short input = 10000;
unsigned int value;
printf("========== STATIC ARRAY STACK IMPLEMENTATION ==========\n");
printf("=== Input your prefered stack size (< %d): ", MAX_STACK);
scanf("%d", &preffered_stack_size);
stack_t *stack = stack_create(preffered_stack_size);
render_menu();
while(input != 0)
{
printf("=== Choose an option: ");
scanf("%d", &input);
switch(input) {
case 1:
printf("=== Value to be pushed: ");
scanf("%d", &value);
push(stack, value);
break;
case 2:
printf("=== Value: %d\n", pop(stack));
break;
case 3:
printf("=== Value %d\n", peek(stack));
break;
case 4:
printf("=== Stack usage: %d\n", memused(stack));
break;
case 5:
printf("=== Stack size: %d\n", stack_size(stack));
break;
case 9:
render_menu();
break;
case 0:
break;
default:
printf("Wrong choice!\n");
break;
}
}
free(stack);
return 0;
}
int C2F(stcreate)(int *lw, int *nz, int *sz, int *nf, char *fnames[], int *retval)
{
int next,k,lr,nels;
static int l;
static int l0, n1, il;
*retval = 0;
l0 = *Lstk(*lw);
C2F(intersci).ntypes[*lw -Top + Rhs - 1] = '$';
C2F(intersci).iwhere[*lw -Top + Rhs - 1] = *Lstk(*lw);
if (*lw > intersiz)
{
Scierror(998,_("Too many arguments in the stack, edit stack.h and enlarge intersiz.\n"));
return 1;
}
sttyp(&n1, "size", nf, fnames);
*retval = 1;
/* create the mlist header */
il = iadr(l0);
Err = sadr(il+6) + n1 - *Lstk(Bot);
if (Err > 0)
{
SciError(17);
return 1;
}
*istk(il) = 17;
*istk(il+1) = 2+*nf;
*istk(il + 2) = 1;
/* set mlist type ["st","dims","field1",...,"fieldnf"] */
l = sadr(il+5+*nf);
sttyp(istk(iadr(l)), "set", nf, fnames);
*istk(il + 3) = *istk(il + 2) + n1;
l += n1;
/* set dims entry (int32 matrix) */
/* if (!C2F(creimati)("stcreate", &l, &c4, nz, &c1, &lr, &c1, 12L)) return 1; FD comment*/
if (!C2F(creimati)("stcreate", &l, &c4, &c1, nz, &lr, &c1, 12L)) return 1;
C2F(icopy)(nz,sz,&c1,istk(lr),&c1);
n1 = sadr(iadr(l)+4) + memused(c4,*nz) - l;
*istk(il + 4) = *istk(il + 3) + n1;
l += n1;
/* set struct fields */
nels=1;
for (k=0; k< *nz;k++) nels=nels*sz[k];
if (nels==1) {
for (k=0; k< *nf;k++)
{
creonevoid(&l,&next);
n1 = next - l;
l += n1;
*istk(il + 5 + k) = *istk(il + 4 + k) + n1;
}
}
else {
for (k=0; k< *nf;k++)
{
crelistofvoids(&l,&next,&nels);
n1 = next - l;
l += n1;
*istk(il + 5 + k) = *istk(il + 4 + k) + n1;
}
}
*Lstk(*lw+1)=l;
return 1;
}
} END_TEST
START_TEST(test_decode_chars) {
// It should decode ascii
char ascii[] = "\x01\x23";
wzkey key = {.bytes = (uint8_t *) "\x89\xab\xcd\xef", .len = 4};
wzfile file = {.key = &key};
wzstr buffer;
buffer.bytes = (uint8_t *) ascii;
buffer.len = strlen(ascii);
ck_assert_int_eq(wz_decode_chars(&buffer, 1, file.key), 0);
ck_assert_int_eq(memcmp(buffer.bytes, "\x22\x23", 2), 0);
ck_assert(buffer.len == 2 && memused() == 0);
// It should decode utf16le
char utf16le[] = "\x45\x67"; // decode => \x66\x66 utf8 => \xe6\x99\xa6
buffer.bytes = (uint8_t *) utf16le;
buffer.len = strlen(utf16le);
ck_assert_int_eq(wz_decode_chars(&buffer, 0, file.key), 0);
ck_assert_int_eq(memcmp(buffer.bytes, "\xe6\x99\xa6", 3), 0);
ck_assert(buffer.len == 3 && memused() == 3 + 1);
wz_free_chars(&buffer);
ck_assert(memused() == 0);
// It should not decode if key == NULL
wzstr copy = buffer;
ck_assert_int_eq(wz_decode_chars(&buffer, 1, NULL), 0);
ck_assert(buffer.bytes == copy.bytes);
ck_assert(buffer.len == copy.len);
// It should not decode if string key is too short
file.key->bytes = (uint8_t *) "\xcd";
file.key->len = 1;
ck_assert_int_eq(wz_decode_chars(&buffer, 1, file.key), 1);
ck_assert(buffer.bytes == copy.bytes);
ck_assert(buffer.len == copy.len);
} END_TEST
START_TEST(test_read_chars) {
// It should be ok
char normal[] =
"\xfe""\x01\x23"
"\x80""\x02\x00\x00\x00""\x45\x67"
"\x01""\x89\xab"
"\x7f""\x03\x00\x00\x00""\xcd\xef\x01\x23\x45\x67";
wzfile file;
create_file(&file, normal, sizeof(normal) - 1);
wzstr buffer;
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
ck_assert_int_eq(memcmp(buffer.bytes, "\x01\x23", 2), 0);
ck_assert(buffer.len == 2 && memused() == 2 + 1);
wz_free_chars(&buffer);
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
ck_assert_int_eq(memcmp(buffer.bytes, "\x45\x67", 2), 0);
ck_assert(buffer.len == 2 && memused() == 2 + 1);
wz_free_chars(&buffer);
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
ck_assert_int_eq(memcmp(buffer.bytes, "\x89\xab", 2), 0);
ck_assert(buffer.len == 2 && memused() == 2 + 1);
wz_free_chars(&buffer);
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
char * expected = "\xcd\xef\x01\x23\x45\x67";
ck_assert_int_eq(memcmp(buffer.bytes, expected, 6), 0);
ck_assert(buffer.len == 6 && memused() == 6 + 1);
wz_free_chars(&buffer);
delete_file(&file);
// It should decode if string key is set
create_file(&file, normal, sizeof(normal) - 1);
wzctx ctx;
create_ctx(&ctx);
file.key = &ctx.keys[0];
file.key->bytes = (uint8_t *) "\x01\x23\x45\x67\x89\xab";
file.key->len = 6;
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
ck_assert_int_eq(memcmp(buffer.bytes, "\xaa\xab", 2), 0);
ck_assert(buffer.len == 2 && memused() == 2 + 1);
wz_free_chars(&buffer);
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
ck_assert_int_eq(memcmp(buffer.bytes, "\xee\xef", 2), 0);
ck_assert(buffer.len == 2 && memused() == 2 + 1);
wz_free_chars(&buffer);
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
ck_assert_int_eq(memcmp(buffer.bytes, "\xe2\x88\xa2", 2), 0);
ck_assert(buffer.len == 3 && memused() == 3 + 1);
wz_free_chars(&buffer);
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
expected = "\xe6\x99\xa6\xee\xbb\xaf\xe6\x99\xa0";
ck_assert_int_eq(memcmp(buffer.bytes, expected, 9), 0);
ck_assert(buffer.len == 9 && memused() == 9 + 1);
wz_free_chars(&buffer);
delete_ctx(&ctx);
delete_file(&file);
} END_TEST
START_TEST(test_free_chars) {
// It should be ok
char normal[] = "\xfe\x01\x23";
wzfile file;
create_file(&file, normal, sizeof(normal) - 1);
wzstr buffer;
ck_assert_int_eq(wz_read_chars(&buffer, file.key, &file), 0);
ck_assert(memused() == 2 + 1);
wz_free_chars(&buffer);
ck_assert(memused() == 0);
delete_file(&file);
} END_TEST
START_TEST(test_rotl32) {
// It should be ok
ck_assert(wz_rotl32(0xf2345678, 3) == 0x91a2b3c7);
} END_TEST
void
wz_encode_addr(wzaddr * addr, wzfile * file) {
uint32_t key = 0x581c3f6d;
uint32_t decoded = ~(addr->pos - file->head.start);
decoded = decoded * file->ver.hash - key;
decoded = wz_rotl32(decoded, decoded & 0x1f);
addr->val = decoded ^ (addr->val - file->head.start * 2);
}
