void check_mark(char* writepattern, char* readpattern)
{
qio_file_t* f;
qio_channel_t* writing;
qio_channel_t* reading;
int64_t offset;
int32_t got;
err_t err;
int i;
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);
err = qio_channel_offset(true, writing, &offset);
assert(!err);
assert(offset == 0);
for( i = 0; writepattern[i]; i++ ) {
switch (writepattern[i]) {
case 'M':
err = qio_channel_mark(true, writing);
break;
case 'R':
err = qio_channel_revert(true, writing);
break;
case 'C':
err = qio_channel_commit(true, writing);
break;
case 'A':
err = qio_channel_advance(true, writing, 1);
break;
default:
err = qio_channel_write_byte(true, writing, writepattern[i]);
}
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; readpattern[i]; i++ ) {
switch (readpattern[i]) {
case 'M':
err = qio_channel_mark(true, reading);
break;
case 'R':
err = qio_channel_revert(true, reading);
break;
case 'C':
err = qio_channel_commit(true, reading);
break;
case 'A':
err = qio_channel_advance(true, reading, 1);
break;
default:
got = qio_channel_read_byte(true, reading);
if( got >= 0 ) assert(got == readpattern[i]);
else err = -got;
}
assert(!err);
}
got = qio_channel_read_byte(true, reading);
assert( got == - EEOF );
qio_channel_release(reading);
// Close the file.
qio_file_release(f);
}
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 check_mark_easy(void)
{
qio_file_t* f;
qio_channel_t* writing;
qio_channel_t* reading;
int64_t offset;
err_t err;
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);
err = qio_channel_offset(true, writing, &offset);
assert(!err);
assert(offset == 0);
err = qio_channel_write_byte(true, writing, 'a');
assert(!err);
err = qio_channel_offset(true, writing, &offset);
assert(!err);
assert(offset == 1);
err = qio_channel_mark(true, writing);
assert(!err);
err = qio_channel_write_byte(true, writing, 'b');
assert(!err);
err = qio_channel_offset(true, writing, &offset);
assert(!err);
assert(offset == 2);
err = qio_channel_revert(true, writing);
assert(!err);
err = qio_channel_offset(true, writing, &offset);
assert(!err);
assert(offset == 1);
err = qio_channel_mark(true, writing);
assert(!err);
err = qio_channel_write_byte(true, writing, 'c');
assert(!err);
err = qio_channel_offset(true, writing, &offset);
assert(!err);
assert(offset == 2);
err = qio_channel_commit(true, writing);
assert(!err);
assert(offset == 2);
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);
assert('a' == qio_channel_read_byte(true, reading));
assert('c' == qio_channel_read_byte(true, reading));
assert(-EEOF == qio_channel_read_byte(true, reading));
qio_channel_release(reading);
// Close the file.
qio_file_release(f);
}
