void test_verybasic()
{
qio_file_t *f = NULL;
qio_channel_t *writing = NULL;
qio_channel_t *reading = NULL;
err_t err;
char buf[4] = {0};
//open the tmp file, create a write channel, write our data, and release the channel
err = qio_file_open_tmp(&f, 0, NULL);
assert(!err);
err = qio_channel_create(&writing, f, QIO_CH_BUFFERED, 0, 1, 0, INT64_MAX, NULL);
assert(!err);
err = qio_channel_write_amt(true, writing, "\xDE\xAD\xBE\xEF", 4);
assert(!err);
qio_channel_release(writing);
//open a read channel to the tmp file, and read back the data.
err = qio_channel_create(&reading, f, QIO_CH_BUFFERED, 1, 0, 0, INT64_MAX, NULL);
assert(!err);
err = qio_channel_read_amt(true, reading, buf, 4);
assert(!err);
qio_channel_release(reading);
///check that what we wrote is what we read back
if(memcmp(buf, "\xDE\xAD\xBE\xEF", 4) != 0){ assert(0);}
//close the file
qio_file_release(f);
f = NULL;
printf("PASS: test_verybasic\n");
}
void check_bits(int offset, int padding)
{
qio_file_t* f;
qio_channel_t* writing;
qio_channel_t* reading;
// bitpats is in pairs of data, num bits
uint64_t bitpats[] = {1,1, 0,1, 1,1, 1,1, // 1011 -> b
0,1, 0,1, 1,1, 0,1, // 0010 -> 2
2,2, 3,2, // 1011 -> b
2,2, 0,2, // 1000 -> 8
0xffffffffffffffffull,64, // ffff ffff ffff ffff
0,6, 0x3f,6, // 0000 0011 1111 -> 03f
0,1, 0xff,8, 0,1, 0x7f,7, 3,3,// 0111 1111 1011 1111 1011 ->7fbfb
0,3, 1,2, 0,3, // 0000 1000 -> 08
1,1, 0x8100ff00ff20ff81ull,64, 0,7, // 1100 0000 1000 0000 0111 1111 1000 0000 0111 1111 1001 0000 0111 1111 1100 0000 1000 0000 -> c0807f807f907fc080
1,2
};
uint8_t expect[] = {0xb2, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xf7, 0xfb, 0xfb, 0x08, 0xc0, 0x80, 0x7f, 0x80, 0x7f, 0x90, 0x7f, 0xc0, 0x80, 0x40, 0xff, 0x40, 0xff, 0x40};
qioerr err;
int i;
if( verbose ) printf("\nBIT IO TEST AT OFFSET %i PADDING %i\n\n", offset, padding);
err = qio_file_open_tmp(&f, 0, NULL);
assert(!err);
err = qio_channel_create(&writing, f, 0, 0, 1, 0, INT64_MAX, NULL);
assert(!err);
for( i = 0; i < offset; i++ ) {
err = qio_channel_write_byte(true, writing, 0xc1);
assert(!err);
}
// Write stuff to the file.
for( i = 0; i < sizeof(bitpats)/(2*sizeof(uint64_t)); i++ ) {
if( verbose ) printf("Writing %i bits of %llx\n", (int) bitpats[2*i + 1], (long long int) bitpats[2*i]);
err = qio_channel_write_bits(true, writing, bitpats[2*i], bitpats[2*i + 1]);
assert(!err);
}
if( verbose ) printf("Writing byte 0xff at the end\n");
err = qio_channel_write_byte(true, writing, 0xff);
assert(!err);
if( verbose ) printf("Writing bits 010 at the end\n");
err = qio_channel_write_bits(true, writing, 2, 3);
assert(!err);
if( verbose ) printf("Writing byte 0xff at the end\n");
err = qio_channel_write_byte(true, writing, 0xff);
assert(!err);
if( verbose ) printf("Writing bits 010 at the end\n");
err = qio_channel_write_bits(true, writing, 2, 3);
assert(!err);
for( i = 0; i < padding; i++ ) {
err = qio_channel_write_byte(true, writing, 0xc1);
assert(!err);
}
qio_channel_release(writing);
// Read the data a byte at a time.
err = qio_channel_create(&reading, f, 0, 1, 0, 0, INT64_MAX, NULL);
assert(!err);
for( i = 0; i < offset; i++ ) {
uint8_t got = 0;
err = qio_channel_read_amt(true, reading, &got, 1);
assert(!err);
assert(got == 0xc1);
}
// Read stuff from the file.
for( i = 0; i < sizeof(expect); i++ ) {
uint8_t got = 0;
err = qio_channel_read_amt(true, reading, &got, 1);
assert(!err);
if( verbose ) printf("Reading byte expecting %x got %x\n", (int) expect[i], (int) got);
assert( got == expect[i] );
}
for( i = 0; i < padding; i++ ) {
uint8_t got = 0;
err = qio_channel_read_amt(true, reading, &got, 1);
assert(!err);
assert(got == 0xc1);
}
qio_channel_release(reading);
// Read the data with the binary reader.
err = qio_channel_create(&reading, f, 0, 1, 0, 0, INT64_MAX, NULL);
assert(!err);
for( i = 0; i < offset; i++ ) {
uint8_t got = 0;
err = qio_channel_read_amt(true, reading, &got, 1);
assert(!err);
assert(got == 0xc1);
}
// Read stuff from the file.
for( i = 0; i < sizeof(bitpats)/(2*sizeof(uint64_t)); i++ ) {
uint64_t got = 0;
err = qio_channel_read_bits(true, reading, &got, bitpats[2*i + 1]);
assert(!err);
if( verbose ) printf("Reading %i bits expecting %llx got %llx\n", (int) bitpats[2*i + 1], (long long int) bitpats[2*i], (long long int) got);
assert( got == bitpats[2*i] );
}
{
uint8_t got = 0;
uint64_t b = 0;
got = 0;
err = qio_channel_read_amt(true, reading, &got, 1);
assert(!err);
assert( got == 0xff );
b = 0;
err = qio_channel_read_bits(true, reading, &b, 3);
assert(!err);
assert( b == 2 );
got = 0;
err = qio_channel_read_amt(true, reading, &got, 1);
assert(!err);
assert( got == 0xff );
b = 0;
err = qio_channel_read_bits(true, reading, &b, 3);
assert(!err);
assert( b == 2 );
}
for( i = 0; i < padding; i++ ) {
uint8_t got = 0;
err = qio_channel_read_amt(true, reading, &got, 1);
assert(!err);
assert(got == 0xc1);
}
qio_channel_release(reading);
// Close the file.
qio_file_release(f);
}
void string_escape_tests()
{
qio_style_t style = qio_style_default();
qio_channel_t *reading;
qio_channel_t *writing;
qio_file_t *f = NULL;
err_t err;
const char* inputs[2][4] = { {"a \"\\b\x01", // original string
"\"a \\\"\\\\b\x01\"", // simple encoding
"\"a \\\"\\\\b\\x01\"", // chapel encoding
"\"a \\\"\\\\b\\u0001\"", // JSON encoding
},
{ NULL, NULL, NULL, NULL }
};
char buf[50] = {0};
int i,j;
style.binary=0;
style.string_start = '"';
style.string_end = '"';
err = qio_file_open_tmp(&f, 0, NULL);
assert(!err);
for( i = 0; inputs[i][0]; i++ ) {
const char* input = inputs[i][0];
ssize_t input_len = strlen(input);
for( j = 1; j < 4; j++ ) {
const char* expect = inputs[i][j];
ssize_t expect_len = strlen(expect);
style.string_format = j;
err = qio_channel_create(&writing, f, QIO_CH_BUFFERED, 0, 1, 0, INT64_MAX, &style);
assert(!err);
err = qio_channel_print_string(true, writing, input, input_len);
assert(!err);
qio_channel_release(writing);
err = qio_channel_create(&reading, f, QIO_CH_BUFFERED, 1, 0, 0, INT64_MAX, &style);
assert(!err);
err = qio_channel_read_amt(true, reading, buf, expect_len);
assert(!err);
qio_channel_release(reading);
//printf("Got %s expect %s\n", buf, expect);
assert( memcmp(buf, expect, expect_len) == 0 );
// Check that we can read it in again.
err = qio_channel_create(&reading, f, QIO_CH_BUFFERED, 1, 0, 0, INT64_MAX, &style);
assert(!err);
{
const char* got = NULL;
ssize_t got_len = 0;
err = qio_channel_scan_string(true, reading, &got, &got_len, -1);
assert(!err);
//printf("Read back %s expect %s\n", got, input);
assert( got_len == input_len );
assert( memcmp(got, input, got_len) == 0 );
free((void*) got);
}
qio_channel_release(reading);
}
}
qio_file_release(f);
printf("PASS: simple escape\n");
}
void test_endian(void)
{
// We write (hex) 00 0102 03040506 0708091011121314
// as big endian and little endian, and then we check
// that the data is what we expected.
err_t err;
qio_file_t* f;
qio_channel_t* writing;
qio_channel_t* reading;
int64_t offset;
int len = 15;
uint8_t n0 = 0;
uint16_t n1 = 0x0102;
uint32_t n2 = 0x03040506;
uint64_t n3 = 0x0708091011121314LL;
const char* expect_le = "\x00\x02\x01\x06\x05\x04\x03"
"\x14\x13\x12\x11\x10\x09\x08\x07";
const char* expect_be = "\x00\x01\x02\x03\x04\x05\x06"
"\x07\x08\x09\x10\x11\x12\x13\x14";
char got[16];
int i;
int b_order;
const char* expect;
printf("Testing endian functions\n");
err = qio_file_open_tmp(&f, 0, NULL);
assert(!err);
for( i = 0; i < 2; i++ ) {
if( i == 0 ) {
b_order = QIO_BIG;
expect = expect_be;
} else {
b_order = QIO_LITTLE;
expect = expect_le;
}
// Create a "write to file" channel.
err = qio_channel_create(&writing, f, QIO_CH_BUFFERED, 0, 1, 0, INT64_MAX, NULL);
assert(!err);
err = qio_channel_write_uint8(true, writing, n0);
assert(!err);
err = qio_channel_write_uint16(true, b_order, writing, n1);
assert(!err);
err = qio_channel_write_uint32(true, b_order, writing, n2);
assert(!err);
err = qio_channel_write_uint64(true, b_order, writing, n3);
assert(!err);
err = qio_channel_offset(true, writing, &offset);
assert(!err);
assert( offset == len );
qio_channel_release(writing);
writing = NULL;
// Create a "read from file" channel.
err = qio_channel_create(&reading, f, QIO_CH_BUFFERED, 1, 0, 0, INT64_MAX, NULL);
assert(!err);
err = qio_channel_read_amt(true, reading, got, len);
assert(!err);
// Check that we read back what we wrote.
assert( 0 == memcmp(got, expect, len) );
qio_channel_release(reading);
reading = NULL;
}
// Close the file.
qio_file_release(f);
f = NULL;
}
void test_quoted_string_maxlength(void)
{
qio_style_t style = qio_style_default();
qio_channel_t *reading;
qio_channel_t *writing;
qio_file_t *f = NULL;
err_t err;
const char* inputs[8][16] = {
{ "", // original string
"\"\"", // maxlen = 1
"\"\"", // maxlen = 2
"\"\"", // maxlen = 3
"\"\"", // maxlen = 4
"\"\"", // maxlen = 5
"\"\"", // maxlen = 6
"\"\"", // maxlen = 7
"\"\"", // maxlen = 8
"\"\"", // maxlen = 9
"\"\"", // maxlen = 10
"\"\"", // maxlen = 11
"\"\"", // maxlen = 12
"\"\"", // maxlen = 13
"\"\"", // maxlen = 14
NULL
},
{ "a", // original string
"\"a\"", // maxlen = 1
"\"a\"", // maxlen = 2
"\"a\"", // maxlen = 3
"\"a\"", // maxlen = 4
"\"a\"", // maxlen = 5
"\"a\"", // maxlen = 6
"\"a\"", // maxlen = 7
"\"a\"", // maxlen = 8
"\"a\"", // maxlen = 9
"\"a\"", // maxlen = 10
"\"a\"", // maxlen = 11
"\"a\"", // maxlen = 12
"\"a\"", // maxlen = 13
"\"a\"", // maxlen = 14
NULL
},
{ "ab", // original string
"\"ab\"", // maxlen = 1
"\"ab\"", // maxlen = 2
"\"ab\"", // maxlen = 3
"\"ab\"", // maxlen = 4
"\"ab\"", // maxlen = 5
"\"ab\"", // maxlen = 6
"\"ab\"", // maxlen = 7
"\"ab\"", // maxlen = 8
"\"ab\"", // maxlen = 9
"\"ab\"", // maxlen = 10
"\"ab\"", // maxlen = 11
"\"ab\"", // maxlen = 12
"\"ab\"", // maxlen = 13
"\"ab\"", // maxlen = 14
NULL
},
{ "abc", // original string
"\"abc\"", // maxlen = 1
"\"abc\"", // maxlen = 2
"\"abc\"", // maxlen = 3
"\"abc\"", // maxlen = 4
"\"abc\"", // maxlen = 5
"\"abc\"", // maxlen = 6
"\"abc\"", // maxlen = 7
"\"abc\"", // maxlen = 8
"\"abc\"", // maxlen = 9
"\"abc\"", // maxlen = 10
"\"abc\"", // maxlen = 11
"\"abc\"", // maxlen = 12
"\"abc\"", // maxlen = 13
"\"abc\"", // maxlen = 14
NULL
},
{ "abcd", // original string
"\"\"...", // maxlen = 1
"\"\"...", // maxlen = 2
"\"\"...", // maxlen = 3
"\"\"...", // maxlen = 4
"\"\"...", // maxlen = 5
"\"abcd\"", // maxlen = 6
"\"abcd\"", // maxlen = 7
"\"abcd\"", // maxlen = 8
"\"abcd\"", // maxlen = 9
"\"abcd\"", // maxlen = 10
"\"abcd\"", // maxlen = 11
"\"abcd\"", // maxlen = 12
"\"abcd\"", // maxlen = 13
"\"abcd\"", // maxlen = 14
NULL
},
{ "123456789", // original string
"\"\"...", // maxlen = 1
"\"\"...", // maxlen = 2
"\"\"...", // maxlen = 3
"\"\"...", // maxlen = 4
"\"\"...", // maxlen = 5
"\"1\"...", // maxlen = 6
"\"12\"...", // maxlen = 7
"\"123\"...", // maxlen = 8
"\"1234\"...", // maxlen = 9
"\"12345\"...", // maxlen = 10
"\"123456789\"", // maxlen = 11
"\"123456789\"", // maxlen = 12
"\"123456789\"", // maxlen = 13
"\"123456789\"", // maxlen = 14
NULL
},
{ "\x01X\x01Y", // original string
"\"\"...", // maxlen = 1
"\"\"...", // maxlen = 2
"\"\"...", // maxlen = 3
"\"\"...", // maxlen = 4
"\"\"...", // maxlen = 5
"\"\"...", // maxlen = 6
"\"\"...", // maxlen = 7
"\"\"...", // maxlen = 8
"\"\\x01\"...", // maxlen = 9
"\"\\x01X\"...", // maxlen = 10
"\"\\x01X\"...", // maxlen = 11
"\"\\x01X\\x01Y\"", // maxlen = 12
"\"\\x01X\\x01Y\"", // maxlen = 13
"\"\\x01X\\x01Y\"", // maxlen = 14
NULL
},
{ NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
}
};
char buf[50] = {0};
int i,j;
style.binary=0;
style.string_start = '"';
style.string_end = '"';
err = qio_file_open_tmp(&f, 0, NULL);
assert(!err);
for( i = 0; inputs[i][0]; i++ ) {
const char* input = inputs[i][0];
ssize_t input_len = strlen(input);
for( j = 1; inputs[i][j]; j++ ) {
const char* expect = inputs[i][j];
ssize_t expect_len = strlen(expect);
qio_truncate_info_t ti;
const char* got = NULL;
ssize_t truncate_len = (j<input_len)?(j):(input_len);
style.string_format = QIO_STRING_FORMAT_CHPL;
style.max_width_columns = j;
ti.max_columns = style.max_width_columns;
ti.max_chars = SSIZE_MAX;
ti.max_bytes = SSIZE_MAX;
// check that qio_quote_string gives correct string when
// used in a no-quote mode
if( i != 6 ) {
// but not for test 6 since the control characters are weird.
err = qio_quote_string(0, 0, QIO_STRING_FORMAT_WORD, input, input_len, &got, &ti);
assert(!err);
assert(ti.ret_columns == truncate_len);
assert(ti.ret_chars == truncate_len);
assert(truncate_len == strlen(got));
assert( 0 == memcmp(got, input, truncate_len) );
free((void*) got);
}
// Now, check that qio_quote_string returns the correct string.
err = qio_quote_string(style.string_start, style.string_end, style.string_format, input, input_len, &got, &ti);
assert(!err);
assert(ti.ret_columns == strlen(inputs[i][1]) || ti.ret_columns <= j);
assert(ti.ret_bytes == expect_len);
assert(ti.ret_bytes == strlen(got));
assert( 0 == strcmp(got, expect) );
free((void*) got);
// Now, check that the quoting works correctly when writing.
err = qio_channel_create(&writing, f, QIO_CH_BUFFERED, 0, 1, 0, INT64_MAX, &style);
assert(!err);
err = qio_channel_print_string(true, writing, input, input_len);
assert(!err);
qio_channel_release(writing);
err = qio_channel_create(&reading, f, QIO_CH_BUFFERED, 1, 0, 0, INT64_MAX, &style);
assert(!err);
err = qio_channel_read_amt(true, reading, buf, expect_len);
assert(!err);
qio_channel_release(reading);
//printf("Got %s expect %s\n", buf, expect);
assert( memcmp(buf, expect, expect_len) == 0 );
}
}
qio_file_release(f);
printf("PASS: quoted max length\n");
}
