static void
test_append_from_base16(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_decode[] = "546573742001090a0f2048656c6c6f";
int err;
#define B16_DECODED "Test \x01\x09\x0a\x0f Hello"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("XYZ");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYZ"));
ASSERT_STR_EQ(buf.data, "XYZ");
slice = sol_str_slice_from_str(to_decode);
err = sol_buffer_append_from_base16(&buf, slice, SOL_DECODE_LOWERCASE);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYZ" B16_DECODED));
ASSERT_STR_EQ(buf.data, "XYZ" B16_DECODED);
sol_buffer_fini(&buf);
#undef B16_DECODED
}
static void test_getset_parameter_node_value (abts_case *tc, void *data)
{
cwmp_t * c = (cwmp_t*)data;
parameter_node_t * param;
char * name = "InternetGatewayDevice.DeviceInfo.SoftwareVersion";
char * retval;
char * value ;
pool_t * pool = pool_create(POOL_DEFAULT_SIZE);
FUNCTION_TRACE();
param = cwmp_get_parameter_path_node(c->root, name);
ASSERT_NOTNULL(param);
value = "V1.3.x";
cwmp_set_parameter_node_value(c, param, name, value, strlen(value));
retval = cwmp_data_get_parameter_value(c, param, name, pool);
printf("retval ------------------is %s\n", retval);
ASSERT_STR_EQ(value, retval);
value = "V1.4.x";
cwmp_set_parameter_node_value(c, param, name, value, strlen(value));
retval = cwmp_data_get_parameter_value(c, param, name, pool);
ASSERT_STR_EQ(value, retval);
pool_destroy(pool);
}
TEST_END
TEST_START(pushes_buf_kv)
{
clax_kv_list_t list;
clax_kv_list_init(&list);
clax_kv_list_pushn(&list, "foo", 3, "bar", 3);
ASSERT_EQ(list.size, 1);
ASSERT_STR_EQ(clax_kv_list_find(&list, "foo"), "bar");
clax_kv_list_pushn(&list, "", 0, "bar", 3);
ASSERT_EQ(list.size, 2);
ASSERT_STR_EQ(clax_kv_list_find(&list, ""), "bar");
clax_kv_list_pushn(&list, "baz", 3, "", 0);
ASSERT_EQ(list.size, 3);
ASSERT_STR_EQ(clax_kv_list_find(&list, "baz"), "");
clax_kv_list_pushn(&list, "", 0, "", 0);
ASSERT_EQ(list.size, 4);
size_t start = 3;
ASSERT_STR_EQ(clax_kv_list_find_all(&list, "", &start), "");
clax_kv_list_free(&list);
}
static void
test_insert_as_base16(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_encode[] = "Test \x01\x09\x0a\x0f Hello";
int err;
#define B16_ENCODED "546573742001090a0f2048656c6c6f"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("World");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("World"));
ASSERT_STR_EQ(buf.data, "World");
slice = sol_str_slice_from_str("Hello");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("HelloWorld"));
ASSERT_STR_EQ(buf.data, "HelloWorld");
slice = sol_str_slice_from_str(to_encode);
err = sol_buffer_insert_as_base16(&buf, strlen("Hello"), slice, false);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello" B16_ENCODED "World"));
ASSERT_STR_EQ(buf.data, "Hello" B16_ENCODED "World");
sol_buffer_fini(&buf);
#undef B16_ENCODED
}
TEST_END
TEST_START(finds_all_kv)
{
size_t start = 0;
clax_kv_list_t list;
clax_kv_list_init(&list);
ASSERT(clax_kv_list_find_all(&list, "foo", &start) == NULL);
ASSERT_EQ(start, 0);
start = 100;
ASSERT(clax_kv_list_find_all(&list, "foo", &start) == NULL);
ASSERT_EQ(start, 100);
clax_kv_list_push(&list, "foo", "bar");
clax_kv_list_push(&list, "bar", "baz");
clax_kv_list_push(&list, "bar", "zab");
start = 0;
ASSERT_STR_EQ(clax_kv_list_find_all(&list, "foo", &start), "bar");
ASSERT_EQ(start, 1);
ASSERT(clax_kv_list_find_all(&list, "foo", &start) == NULL);
ASSERT(clax_kv_list_find_all(&list, "foo", &start) == NULL);
start = 0;
ASSERT_STR_EQ(clax_kv_list_find_all(&list, "bar", &start), "baz");
ASSERT_STR_EQ(clax_kv_list_find_all(&list, "bar", &start), "zab");
ASSERT(clax_kv_list_find_all(&list, "bar", &start) == NULL);
ASSERT(clax_kv_list_find_all(&list, "bar", &start) == NULL);
clax_kv_list_free(&list);
}
static void
test_insert_as_base64(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_encode[] = "This is a message that is multiple of 3 chars";
int err;
#define B64_ENCODED "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("World");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("World"));
ASSERT_STR_EQ(buf.data, "World");
slice = sol_str_slice_from_str("Hello");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("HelloWorld"));
ASSERT_STR_EQ(buf.data, "HelloWorld");
slice = sol_str_slice_from_str(to_encode);
err = sol_buffer_insert_as_base64(&buf, strlen("Hello"), slice, SOL_BASE64_MAP);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello" B64_ENCODED "World"));
ASSERT_STR_EQ(buf.data, "Hello" B64_ENCODED "World");
sol_buffer_fini(&buf);
#undef B64_ENCODED
}
static void
test_append_from_base64(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_decode[] = "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz";
int err;
#define B64_DECODED "This is a message that is multiple of 3 chars"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("XYZ");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYZ"));
ASSERT_STR_EQ(buf.data, "XYZ");
slice = sol_str_slice_from_str(to_decode);
err = sol_buffer_append_from_base64(&buf, slice, SOL_BASE64_MAP);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYZ" B64_DECODED));
ASSERT_STR_EQ(buf.data, "XYZ" B64_DECODED);
sol_buffer_fini(&buf);
#undef B64_DECODED
}
static void
test_insert_slice(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
int err;
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("World");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("World"));
ASSERT_STR_EQ(buf.data, "World");
slice = sol_str_slice_from_str("Hello");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("HelloWorld"));
ASSERT_STR_EQ(buf.data, "HelloWorld");
slice = sol_str_slice_from_str(" -*- ");
err = sol_buffer_insert_slice(&buf, strlen("Hello"), slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello -*- World"));
ASSERT_STR_EQ(buf.data, "Hello -*- World");
sol_buffer_fini(&buf);
}
static void
test_set_slice(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char *str = "Hello";
char *backend;
int err;
backend = strdup(str);
slice = sol_str_slice_from_str(backend);
sol_buffer_init(&buf);
err = sol_buffer_set_slice(&buf, slice);
ASSERT(err >= 0);
ASSERT_INT_EQ(buf.used, strlen(backend));
ASSERT_STR_EQ(buf.data, backend);
backend[1] = 'a';
ASSERT_STR_NE(buf.data, backend);
ASSERT_STR_EQ(buf.data, str);
sol_buffer_fini(&buf);
free(backend);
}
TEST test_large_map(void)
{
struct mushroom_map *map = mushroom_map_new();
ASSERT_EQ_FMT((size_t)0, mushroom_map_get_count(map), "%zu");
int key_number = 300;
for (int i = 0; i < key_number; i++) {
char key[10];
sprintf(key, "key-%d", i);
mushroom_map_put(map, key, key);
}
char *value = mushroom_map_get(map, "key-9");
ASSERT(value != NULL);
ASSERT_STR_EQ("key-9", value);
for (int i = 0; i < key_number; i++) {
char key[10];
sprintf(key, "key-%d", i);
mushroom_map_put(map, key, key);
value = mushroom_map_get(map, key);
ASSERT(value != NULL);
ASSERT_STR_EQ(key, value);
}
value = mushroom_map_get(map, "key-9");
ASSERT(value != NULL);
ASSERT_STR_EQ("key-9", value);
ASSERT_EQ_FMT((size_t)300, mushroom_map_get_count(map), "%zu");
mushroom_map_free(map);
PASS();
}
TEST(ZXTestCAssertionTest, AssertStrEq) {
const char* str1 = "a";
const char* str2 = "a";
EXPECT_STR_EQ(str1, str2, "ASSERT_STR_EQ failed to identify equal strings.");
EXPECT_STR_EQ(str1, str1, "ASSERT_STR_EQ failed to identify equal strings.");
ASSERT_STR_EQ(str1, str2, "ASSERT_STR_EQ failed to identify equal strings.");
ASSERT_STR_EQ(str1, str1, "ASSERT_STR_EQ failed to identify equal strings.");
// No failures
ZX_ASSERT_MSG(!_ZXTEST_ABORT_IF_ERROR, "Assert was did not abort test.");
}
TEST write_flushes_multiple_times(void) {
enum status s;
s = NORM_INIT(h);
ASSERT_EQ(status_ok, s);
char b[] = "hello$me$how$are$you?";
s = buf_write(&h, b, sizeof(b));
ASSERT_STR_EQ("hello$me$how$are$", (char *)flush_buffer);
ASSERT_STR_EQ("you?", (char *)buffer);
PASS();
}
TEST write_flushes_on_terminator(void) {
enum status s;
s = NORM_INIT(h);
ASSERT_EQ(status_ok, s);
char b[] = "hello$ me";
s = buf_write(&h, b, sizeof(b));
ASSERT_STR_EQ("hello$", (char *)flush_buffer);
ASSERT_STR_EQ(" me", (char *)buffer);
PASS();
}
TEST close_works(void) {
char b[] = "hello";
ASSERT_EQ(status_ok, NORM_INIT(h));
ASSERT_EQ(status_ok, buf_write(&h, b, sizeof(b)));
ASSERT_STR_EQ("", (char *)flush_buffer);
ASSERT_STR_EQ("hello", (char *)buffer);
ASSERT_EQ(status_ok, buf_close(&h));
ASSERT_STR_EQ("hello", (char *)flush_buffer);
PASS();
};
TEST write_flushes_on_multi_char_term(void) {
enum status s;
s = MULT_INIT(h);
ASSERT_EQ(status_ok, s);
char b[] = "hello^me^@how are you?";
s = buf_write(&h, b, sizeof(b));
ASSERT_STR_EQ("hello^me^@", (char *)flush_buffer);
ASSERT_STR_EQ("how are you?", (char *)buffer);
PASS();
}
TEST write_flushes_when_out_of_space(void) {
enum status s;
s = CUST_BLEN_INIT(h, 5);
ASSERT_EQ(status_ok, s);
char b[] = "hello me";
s = buf_write(&h, b, sizeof(b));
ASSERT_EQ(status_ok, s);
ASSERT_STR_EQ("hello", (char *)flush_buffer);
ASSERT_STR_EQ(" me", (char *)buffer);
PASS();
}
TEST serialize(void) {
sl2_t a, b;
unsigned char bufa[256] = {0};
char bufb[256], bufc[256];
int i;
for (i = 0; i < 1024; i++) {
sl2_rand(a);
sl2_serialize(a, bufa);
sl2_unserialize(b, bufa);
ASSERT_STR_EQ(gf2p127_hex(bufb, a[0][0]), gf2p127_hex(bufc, b[0][0]));
ASSERT_STR_EQ(gf2p127_hex(bufb, a[0][1]), gf2p127_hex(bufc, b[0][1]));
ASSERT_STR_EQ(gf2p127_hex(bufb, a[1][0]), gf2p127_hex(bufc, b[1][0]));
ASSERT_STR_EQ(gf2p127_hex(bufb, a[1][1]), gf2p127_hex(bufc, b[1][1]));
}
PASS();
}
TEST multiplication_special_bit_right(void) {
sl2_t a, b, m[2];
char bufa[1024], bufb[1024];
int i;
sl2_init(m);
for (i = 0; i < 1024; i++) {
sl2_rand(a);
sl2_mul(b, a, m[i % 2]);
sl2_mul_bit_right(&a[0][0], &a[0][1], &a[1][0], &a[1][1], _mm_load_si128(&minmax[i % 2]));
ASSERT_STR_EQ(gf2p127_hex(bufa, a[0][0]), gf2p127_hex(bufb, b[0][0]));
ASSERT_STR_EQ(gf2p127_hex(bufa, a[0][1]), gf2p127_hex(bufb, b[0][1]));
ASSERT_STR_EQ(gf2p127_hex(bufa, a[1][0]), gf2p127_hex(bufb, b[1][0]));
ASSERT_STR_EQ(gf2p127_hex(bufa, a[1][1]), gf2p127_hex(bufb, b[1][1]));
}
PASS();
}
/* tests all conditions which should hold when reading to the end of the file. */
int test_dbfr_getline_2() {
dbfr_t *reader = dbfr_open(TEST_FILENAME);
ssize_t retval;
int i = 0;
char expected[80];
unittest_has_error = 0;
ASSERT_TRUE(reader != NULL, "dbfr_open: return non-null");
if (! reader) {
return 1;
}
while (i < LINES_IN_TEST_FILE) {
i++;
dbfr_getline(reader);
ASSERT_LONG_EQ(i, reader->line_no, "dbfr_getline: line_no incremented");
}
ASSERT_TRUE(reader->current_line != NULL, "current_line not NULL at EOF");
ASSERT_TRUE(reader->next_line == NULL, "next_line NULL at EOF");
sprintf(expected, "this is line %d\n", LINES_IN_TEST_FILE);
ASSERT_STR_EQ(expected, reader->current_line, "current_line intact at EOF");
retval = dbfr_getline(reader);
ASSERT_LONG_GT(0, retval, "dbfr_getline() returns < 0 at EOF");
ASSERT_TRUE(reader->eof, "dbfr_t.eof set at EOF");
dbfr_close(reader);
return 0;
}
static void
test_remove_data(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
int err;
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("ABCDEFGHI");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("ABCDEFGHI"));
ASSERT_STR_EQ(buf.data, "ABCDEFGHI");
err = sol_buffer_remove_data(&buf, strlen("ABC"), 0);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("DEFGHI"));
err = sol_buffer_remove_data(&buf, strlen("GHI"), 3);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("DEF"));
err = sol_buffer_remove_data(&buf, strlen("DEF"), 0);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, 0);
err = sol_buffer_remove_data(&buf, 100, 0);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, 0);
err = sol_buffer_remove_data(&buf, 0, 100);
ASSERT_INT_EQ(err, -EINVAL);
sol_buffer_fini(&buf);
}
static bool basic_test(void) {
BEGIN_TEST;
zx::socket client, server;
ASSERT_EQ(ZX_OK, zx::socket::create(ZX_SOCKET_HAS_CONTROL, &client, &server));
async_loop_t* loop = nullptr;
ASSERT_EQ(ZX_OK, async_loop_create(&kAsyncLoopConfigNoAttachToThread, &loop), "");
ASSERT_EQ(ZX_OK, async_loop_start_thread(loop, "spaceship-dispatcher", nullptr), "");
async_dispatcher_t* dispatcher = async_loop_get_dispatcher(loop);
ASSERT_EQ(ZX_OK, fidl_bind_socket(dispatcher, server.release(),
reinterpret_cast<fidl_dispatch_t*>(fidl_test_fakesocket_Control_dispatch),
nullptr, &kOps));
ASSERT_EQ(ZX_OK, fidl_test_fakesocket_ControlBind(client.get(), "xy", 2u));
char buffer[64];
memset(buffer, 0, sizeof(buffer));
size_t actual = 0u;
ASSERT_EQ(ZX_OK, fidl_test_fakesocket_ControlGetPeerAddr(client.get(), 5, buffer, sizeof(buffer), &actual));
ASSERT_EQ(3u, actual);
buffer[3] = '\0';
ASSERT_STR_EQ("abc", buffer);
client.reset();
async_loop_destroy(loop);
END_TEST;
}
static void
test_base64_encode(void)
{
const char base64_map[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
const char instr[] = "This is a message that is multiple of 3 chars";
const char *expectstrs[] = {
"VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz",
"VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXI=",
"VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYQ==",
"VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNo"
};
struct sol_str_slice slice;
char outstr[(sizeof(instr) / 3 + 1) * 4 + 1];
size_t r, i;
slice = sol_str_slice_from_str(instr);
for (i = 0; i < SOL_UTIL_ARRAY_SIZE(expectstrs); i++) {
struct sol_str_slice exp = sol_str_slice_from_str(expectstrs[i]);
memset(outstr, 0xff, sizeof(outstr));
r = sol_util_base64_encode(outstr, sizeof(outstr), slice, base64_map);
ASSERT_INT_EQ(r, exp.len);
ASSERT_INT_EQ(outstr[r], (char)0xff);
outstr[r] = '\0';
ASSERT_STR_EQ(outstr, exp.data);
slice.len--;
}
}
TEST_END
TEST_START(sets_new_val)
{
clax_kv_list_t list;
clax_kv_list_init(&list);
clax_kv_list_set(&list, "foo", "bar");
ASSERT_STR_EQ(clax_kv_list_find(&list, "foo"), "bar");
clax_kv_list_set(&list, "foo", "baz");
ASSERT_STR_EQ(clax_kv_list_find(&list, "foo"), "baz");
clax_kv_list_free(&list);
}
void assert_parse_package(const char* package_name, const char* java_text) {
JavaDocStructure* java_doc = parse_text(java_text, TRUE, FALSE);
ASSERT_NOT_NULL(java_doc);
ASSERT_NOT_NULL(java_doc->package_declaration);
ASSERT_STR_EQ(package_name, java_doc->package_declaration->package_name);
java_doc_free(java_doc);
}
TEST_END
TEST_START(parses_basic_auth)
{
opt options;
clax_options_init(&options);
char *argv[] = {"clax", "-n", "-r", ".", "-a", "foo:bar"};
int ret = clax_parse_options(&options, sizeof_array(argv), argv);
ASSERT_EQ(ret, 0);
ASSERT_STR_EQ(options.basic_auth_username, "foo");
ASSERT_STR_EQ(options.basic_auth_password, "bar");
clax_options_free(&options);
}
TEST ibwt_bacabba()
{
char *input = "bcbbaaa";
char output[8];
ibwt(input, output, 4, 7);
output[7] = '\0';
ASSERT_STR_EQ("bacabba", output);
PASS();
}
TEST ibwt_abracadabra()
{
char *input = "rdarcaaaabb";
char output[12];
ibwt(input, output, 2, 11);
output[11] = '\0';
ASSERT_STR_EQ("abracadabra", output);
PASS();
}
TEST_END
TEST_START(parses_ssl_options)
{
opt options;
clax_options_init(&options);
char *argv[] = {"clax", "-r", ".", "-t", "ssl/server.crt", "-p", "ssl/server.key"};
int ret = clax_parse_options(&options, sizeof_array(argv), argv);
ASSERT_EQ(ret, 0)
ASSERT_EQ(options.no_ssl, 0)
ASSERT_EQ(options.no_ssl_verify, 0)
ASSERT_STR_EQ(options.cert_file, "ssl/server.crt")
ASSERT_STR_EQ(options.key_file, "ssl/server.key")
clax_options_free(&options);
}
static void
test_simple_SOL_MEMDESC_TYPE_STRING(void)
{
const struct sol_memdesc desc = {
SOL_SET_API_VERSION(.api_version = SOL_MEMDESC_API_VERSION, )
.type = SOL_MEMDESC_TYPE_STRING,
.defcontent.s = "hello world"
};
char *a, *b;
const char *c;
int r;
r = sol_memdesc_init_defaults(&desc, &a);
ASSERT_INT_EQ(r, 0);
ASSERT(a != desc.defcontent.s);
ASSERT_STR_EQ(a, "hello world");
r = sol_memdesc_init_defaults(&desc, &b);
ASSERT_INT_EQ(r, 0);
ASSERT(b != desc.defcontent.s);
ASSERT_STR_EQ(b, "hello world");
r = sol_memdesc_compare(&desc, &a, &b);
ASSERT_INT_EQ(r, 0);
ASSERT_INT_EQ(errno, 0);
c = "other string";
r = sol_memdesc_set_content(&desc, &a, &c);
ASSERT_INT_EQ(r, 0);
ASSERT(a != c);
ASSERT_STR_EQ(a, "other string");
r = sol_memdesc_compare(&desc, &a, &c);
ASSERT_INT_EQ(r, 0);
ASSERT_INT_EQ(errno, 0);
r = sol_memdesc_compare(&desc, &a, &b);
ASSERT(r > 0);
sol_memdesc_free_content(&desc, &a);
sol_memdesc_free_content(&desc, &b);
}
/* tests all conditions which should hold after reading the first line
of the file. */
int test_dbfr_getline_1() {
dbfr_t *reader = dbfr_open(TEST_FILENAME);
ssize_t retval;
unittest_has_error = 0;
ASSERT_TRUE(reader != NULL, "dbfr_open: return non-null");
if (! reader) {
return 1;
}
retval = dbfr_getline(reader);
ASSERT_LONG_EQ(strlen("this is line 1\n"), retval,
"dbfr_getline: return string length");
ASSERT_LONG_EQ(1, reader->line_no,
"dbfr_getline: increment line_no");
ASSERT_STR_EQ("this is line 1\n", reader->current_line,
"dbfr_getline: initialize current_line");
ASSERT_STR_EQ("this is line 2\n", reader->next_line,
"dbfr_getline: initialize next_line");
dbfr_close(reader);
return unittest_has_error;
}
