static void memcmp_func() { char* src; char* dst; for(int i = 1; i < 4000; i++) { src = malloc(i); dst = malloc(i); memset(src, 0, i); memset(dst, 0, i); int rtn = __memcmp(src, dst, i); assert_int_equal(0, rtn); free(src); src = NULL; free(dst); dst = NULL; } for(int i = 1; i < 4000; i++) { src = malloc(i); dst = malloc(i); memset(src, 1, i); memset(dst, 2, i); int rtn = __memcmp(dst, src, i); if(*src > *dst) { assert_in_range(rtn, 1, INT32_MAX); } else if(*src < *dst) { assert_in_range(rtn, INT32_MIN, -1); } } }
static void calloc_func() { size_t pool_size = 0x40000; size_t malloc_size; /* element size 1 */ for(size_t i = 1; i < pool_size - 0x3e001; i++) { malloc_size = i; void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); char* mem = __calloc(malloc_size, 1, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); for(size_t j = 0; j < malloc_size; j++) assert_int_equal(0, (int)mem[j]); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; } /* element size 4 */ for(size_t i = 1; i < (pool_size - 0x3e001) / 4; i++) { malloc_size = i; void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); int* mem = __calloc(malloc_size, 4, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); for(size_t j = 0; j < malloc_size; j++) assert_int_equal(0, (int)mem[j]); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; } /* element size 8 */ for(size_t i = 1; i < (pool_size - 0x3e001) / 8; i++) { malloc_size = i; void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); uint64_t* mem = __calloc(malloc_size, 8, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); for(size_t j = 0; j < malloc_size; j++) assert_int_equal(0, mem[j]); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; } }
static void strncmp_func() { char text[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0"; char equal[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0"; /* Difference in head */ char not_eqaul_1[1024] = "11234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0"; /* Difference in middle */ char not_eqaul_2[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,.!~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0"; /* Difference in tail */ char not_eqaul_3[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNMM?!\0"; /* Comparing from head */ for(size_t i = 1; i < strlen(text); i++) { assert_int_equal(0, __strncmp(text, equal, i)); } /* Comparing subset from head and forwarding to tail */ for(size_t i = 1; i < strlen(text); i++) { assert_int_equal(0, __strncmp(text + i, equal + i, strlen(text) - i)); } /* When return value is over zero */ assert_in_range(__strncmp(text, not_eqaul_1, strlen(text)), 1, INT32_MAX); assert_in_range(__strncmp(text, not_eqaul_2, strlen(text)), 1, INT32_MAX); /* when retrun value is under zero */ assert_in_range(__strncmp(text, not_eqaul_3, strlen(text)), INT32_MIN, -1); }
static void malloc_func(void** state) { size_t pool_size = 0x40000; /* void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); size_t mem_size = 0x3e000; void* mem = __malloc(mem_size, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); printf("extra malloc\n"); void* mem2 = __malloc(1800, malloc_pool); assert_in_range(mem2, malloc_pool, malloc_pool + pool_size); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; return; */ /* * 0x3e000 is max size that won't make failure of malloc * when pool size is set to 0x4000 * If malloc size over the 0x3e000(may be 0x3e001), malloc failed. * more problems is descirbed in Packetngin App Test Sheet. */ /* use private malloc_pool */ for(size_t i = 1; i < pool_size - 0x3e001; i++) { void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); size_t mem_size = i; void* mem = __malloc(mem_size, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; } /* use __malloc_pool */ for(size_t i = 1; i < pool_size - 0x3e001; i++) { __malloc_pool = malloc(pool_size); init_memory_pool(pool_size, __malloc_pool, 0); size_t mem_size = i; void* mem = __malloc(mem_size, NULL); assert_in_range(mem, __malloc_pool, __malloc_pool + pool_size); destroy_memory_pool(__malloc_pool); free(__malloc_pool); __malloc_pool = NULL; } }
static void torture_timeout_update(void **state){ struct ssh_timestamp ts; (void) state; ssh_timestamp_init(&ts); usleep(50000); assert_int_equal(ssh_timeout_update(&ts,25), 0); assert_in_range(ssh_timeout_update(&ts,30000),29000,29960); assert_in_range(ssh_timeout_update(&ts,75),1,40); assert_int_equal(ssh_timeout_update(&ts,0),0); assert_int_equal(ssh_timeout_update(&ts,-1),-1); }
/* Should work until Apnic decides to assign it :) */ #define BLACKHOLE "1.1.1.1" static int sshd_setup(void **state) { torture_setup_sshd_server(state); return 0; } static int sshd_teardown(void **state) { torture_teardown_sshd_server(state); return 0; } static int session_setup(void **state) { struct torture_state *s = *state; int verbosity = torture_libssh_verbosity(); struct passwd *pwd; int rc; pwd = getpwnam("bob"); assert_non_null(pwd); rc = setuid(pwd->pw_uid); assert_return_code(rc, errno); s->ssh.session = ssh_new(); assert_non_null(s->ssh.session); ssh_options_set(s->ssh.session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity); return 0; } static int session_teardown(void **state) { struct torture_state *s = *state; ssh_disconnect(s->ssh.session); ssh_free(s->ssh.session); return 0; } static void torture_connect_nonblocking(void **state) { struct torture_state *s = *state; ssh_session session = s->ssh.session; int rc; rc = ssh_options_set(session, SSH_OPTIONS_HOST, TORTURE_SSH_SERVER); assert_true(rc == SSH_OK); ssh_set_blocking(session,0); do { rc = ssh_connect(session); assert_true(rc != SSH_ERROR); } while(rc == SSH_AGAIN); assert_true(rc == SSH_OK); } #if 0 /* This does not work with socket_wrapper */ static void torture_connect_timeout(void **state) { struct torture_state *s = *state; ssh_session session = s->ssh.session; struct timeval before, after; int rc; long timeout = 2; time_t sec; suseconds_t usec; rc = ssh_options_set(session, SSH_OPTIONS_HOST, BLACKHOLE); assert_true(rc == SSH_OK); rc = ssh_options_set(session, SSH_OPTIONS_TIMEOUT, &timeout); assert_true(rc == SSH_OK); rc = gettimeofday(&before, NULL); assert_true(rc == 0); rc = ssh_connect(session); assert_true(rc == SSH_ERROR); rc = gettimeofday(&after, NULL); assert_true(rc == 0); sec = after.tv_sec - before.tv_sec; usec = after.tv_usec - before.tv_usec; /* Borrow a second for the missing usecs, but don't bother calculating */ if (usec < 0) sec--; assert_in_range(sec, 1, 3); }
time_t date_time::to_time(const tm_type& tm, bool check_wday) { assert_in_range(tm, check_wday); time_t t; tm_type tt = tm; #ifdef _WIN32 t = _mkgmtime(&tt); #else t = timegm(&tt); #endif if (t == NULL_TIME) throw std::invalid_argument("invalid time structure on conversion to date and time"); // Check that tm is canonical. std::string err; if (check_wday && tm.tm_wday != tt.tm_wday) err = std::string("week day (1-7) incorrect: ") + uripp::convert(tm.tm_wday + 1); else if (tm.tm_mday != tt.tm_mday) err = std::string("month day (1-31) incorrect: ") + uripp::convert(tm.tm_mday); else if (tm.tm_sec != tt.tm_sec) err = std::string("second (0-60) incorrect: ") + uripp::convert(tm.tm_sec); if (!err.empty()) { std::ostringstream oss; oss << "time structure for date (YYY-MM-DD) " << (tm.tm_year + 1900) << "-" << std::setw(2) << std::setfill('0') << (tm.tm_mon + 1) << "-" << std::setw(2) << std::setfill('0') << tm.tm_mday << ": " << err; throw std::invalid_argument(oss.str()); } return t; }
void test_processes_monitor(void) { double cf_this[100] = { 0.0 }; MonProcessesGatherData(cf_this); MonProcessesGatherData(cf_this); MonProcessesGatherData(cf_this); int usr, rusr, ousr; usr = rusr = ousr = 0; bool res = GetSysUsers(&usr, &rusr, &ousr); if (!res) { Log(LOG_LEVEL_NOTICE, "TEST SKIPPED!"); return; } usr = 3*usr; rusr = 3*rusr; ousr = 3*ousr; Log(LOG_LEVEL_NOTICE, "Counted %d/3 different users on the process table," " while CFEngine counted %f/3", usr, cf_this[ob_users]); Log(LOG_LEVEL_NOTICE, "This is a non-deterministic test," " the two numbers should be *about* the same since the 'ps'" " commands run very close to each other"); int upper = (int) ((double) usr*1.10); int lower = (int) ((double) usr*0.90); assert_in_range((long long) cf_this[ob_users], lower, upper); }
void test_processes_monitor(void) { # ifdef __sun return; //redmine 6316 # endif double cf_this[100] = { 0.0 }; MonProcessesGatherData(cf_this); MonProcessesGatherData(cf_this); MonProcessesGatherData(cf_this); int usr, rusr, ousr; usr = rusr = ousr = 0; bool res = GetSysUsers(&usr, &rusr, &ousr); if (res == false ) { assert_true(1); return; } usr = 3*usr; rusr = 3*rusr; ousr = 3*ousr; int upper = (int)((double)usr*1.10); int lower = (int)((double)usr*0.90); assert_in_range((long long)cf_this[ob_users], lower, upper); }
void debug_assert_in_range( size_type offset, size_type size_in ) const { (void)offset; (void)size_in; #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK assert_in_range(offset, size_in); #endif }
static void test_res_fake_a_query_case_insensitive(void **state) { int rv; struct __res_state dnsstate; unsigned char answer[ANSIZE]; char addr[INET_ADDRSTRLEN]; ns_msg handle; ns_rr rr; /* expanded resource record */ (void) state; /* unused */ memset(&dnsstate, 0, sizeof(struct __res_state)); rv = res_ninit(&dnsstate); assert_int_equal(rv, 0); rv = res_nquery(&dnsstate, "CWRAP.ORG", ns_c_in, ns_t_a, answer, sizeof(answer)); assert_in_range(rv, 1, 100); ns_initparse(answer, sizeof(answer), &handle); /* The query must finish w/o an error, have one answer and the answer * must be a parseable RR of type A and have the address that our * fake hosts file contains. Case does not matter. */ assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror); assert_int_equal(ns_msg_count(handle, ns_s_an), 1); assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_a); assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr), addr, sizeof(addr))); assert_string_equal(addr, "127.0.0.21"); res_nclose(&dnsstate); }
static void test_res_fake_aaaa_query(void **state) { int rv; struct __res_state dnsstate; unsigned char answer[ANSIZE]; char addr[INET6_ADDRSTRLEN]; ns_msg handle; ns_rr rr; /* expanded resource record */ (void) state; /* unused */ memset(&dnsstate, 0, sizeof(struct __res_state)); rv = res_ninit(&dnsstate); assert_int_equal(rv, 0); rv = res_nquery(&dnsstate, "cwrap6.org", ns_c_in, ns_t_aaaa, answer, sizeof(answer)); assert_in_range(rv, 1, 100); ns_initparse(answer, sizeof(answer), &handle); /* The query must finish w/o an error, have one answer and the answer * must be a parseable RR of type AAAA and have the address that our * fake hosts file contains */ assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror); assert_int_equal(ns_msg_count(handle, ns_s_an), 1); assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_aaaa); assert_non_null(inet_ntop(AF_INET6, ns_rr_rdata(rr), addr, sizeof(addr))); assert_string_equal(addr, "2a00:1450:4013:c01::63"); }
static void interface_alloc_func(void** state) { void* malloc_pool = malloc(POOL_SIZE); init_memory_pool(POOL_SIZE, malloc_pool, 0); IPv4Interface* interface = interface_alloc(malloc_pool); assert_in_range(interface, malloc_pool, malloc_pool + POOL_SIZE); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; }
static void realloc_func() { size_t pool_size = 0x40000; size_t malloc_size; for(size_t i = 1; i < pool_size - 0x3e001; i++) { malloc_size = i; void* malloc_pool = malloc(pool_size); init_memory_pool(pool_size, malloc_pool, 0); void* mem = __malloc(malloc_size, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); mem = __realloc(mem, 0x3e000, malloc_pool); assert_in_range(mem, malloc_pool, malloc_pool + pool_size); destroy_memory_pool(malloc_pool); free(malloc_pool); malloc_pool = NULL; } }
static void strcmp_func() { char text[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0"; char equal[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0"; /* Difference in head that is smaller than origin text */ char not_eqaul_1[1024] = "11234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0"; /* Difference in middle that is bigger than origin text */ char not_eqaul_2[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,.!~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0"; /* Difference in tail that is biggeer than origin text */ char not_eqaul_3[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNMM?!\0"; assert_int_equal(0, __strcmp(text, equal)); /* When return value is over zero */ assert_in_range(__strcmp(text, not_eqaul_1), 1, INT32_MAX); assert_in_range(__strcmp(text, not_eqaul_2), 1, INT32_MAX); /* when retrun value is under zero */ assert_in_range(__strcmp(text, not_eqaul_3), INT32_MIN, -1); assert_int_not_equal(0, __strcmp(text, not_eqaul_1)); assert_int_not_equal(0, __strcmp(text, not_eqaul_2)); assert_int_not_equal(0, __strcmp(text, not_eqaul_3)); }
void test__AOSegmentFilePathNameLen(void **state) { RelationData reldata; char* basepath = "base/21381/123"; expect_any(relpath, &rnode); will_return(relpath, strdup(basepath)); int r = AOSegmentFilePathNameLen(&reldata); assert_in_range(r, strlen(basepath) + 3, strlen(basepath) + 10); }
static void test_res_fake_srv_query(void **state) { int rv; struct __res_state dnsstate; unsigned char answer[ANSIZE]; ns_msg handle; ns_rr rr; /* expanded resource record */ const uint8_t *rrdata; int prio; int weight; int port; char hostname[MAXDNAME]; (void) state; /* unused */ memset(&dnsstate, 0, sizeof(struct __res_state)); rv = res_ninit(&dnsstate); assert_int_equal(rv, 0); rv = res_nquery(&dnsstate, "_ldap._tcp.cwrap.org", ns_c_in, ns_t_srv, answer, sizeof(answer)); assert_in_range(rv, 1, 100); ns_initparse(answer, sizeof(answer), &handle); /* * The query must finish w/o an error, have one answer and the answer * must be a parseable RR of type SRV and have the priority, weight, * port and hostname as in the fake hosts file */ assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror); assert_int_equal(ns_msg_count(handle, ns_s_an), 1); assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_srv); rrdata = ns_rr_rdata(rr); NS_GET16(prio, rrdata); NS_GET16(weight, rrdata); NS_GET16(port, rrdata); rv = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), rrdata, hostname, MAXDNAME); assert_int_not_equal(rv, -1); assert_int_equal(prio, 1); assert_int_equal(weight, 5); assert_int_equal(port, 389); assert_string_equal(hostname, "ldap.cwrap.org"); }
static void test_res_fake_aaaa_query_notfound(void **state) { int rv; struct __res_state dnsstate; unsigned char answer[ANSIZE]; ns_msg handle; (void) state; /* unused */ memset(&dnsstate, 0, sizeof(struct __res_state)); rv = res_ninit(&dnsstate); assert_int_equal(rv, 0); rv = res_nquery(&dnsstate, "nosuchentry.org", ns_c_in, ns_t_aaaa, answer, sizeof(answer)); assert_in_range(rv, 1, 100); ns_initparse(answer, sizeof(answer), &handle); /* The query must finish w/o an error and have no answer */ assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror); assert_int_equal(ns_msg_count(handle, ns_s_an), 0); }
/* * Test the case of a SRV record query where the * fake hosts file entry is minimal in the sense * that it omits the priority and weight entries. * The server then fills in some default values. */ static void test_res_fake_srv_query_minimal(void **state) { int rv; struct __res_state dnsstate; unsigned char answer[ANSIZE]; ns_msg handle; ns_rr rr; /* expanded resource record */ const uint8_t *rrdata; int prio; int weight; int port; char hostname[MAXDNAME]; char addr[INET_ADDRSTRLEN]; (void) state; /* unused */ memset(&dnsstate, 0, sizeof(struct __res_state)); rv = res_ninit(&dnsstate); assert_int_equal(rv, 0); rv = res_nquery(&dnsstate, "_krb5._tcp.cwrap.org", ns_c_in, ns_t_srv, answer, sizeof(answer)); assert_in_range(rv, 1, 256); ns_initparse(answer, sizeof(answer), &handle); /* * The query must finish w/o an error, have one answer and the answer * must be a parseable RR of type SRV and have the priority, weight, * port and hostname as in the fake hosts file */ assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror); assert_int_equal(ns_msg_count(handle, ns_s_an), 1); assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_srv); rrdata = ns_rr_rdata(rr); NS_GET16(prio, rrdata); NS_GET16(weight, rrdata); NS_GET16(port, rrdata); rv = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), rrdata, hostname, MAXDNAME); assert_int_not_equal(rv, -1); assert_int_equal(prio, 1); assert_int_equal(weight, 100); assert_int_equal(port, 88); assert_string_equal(hostname, "krb5.cwrap.org"); /* The additional section contains the A record of krb5.cwrap.org */ assert_int_equal(ns_msg_count(handle, ns_s_ar), 1); assert_int_equal(ns_parserr(&handle, ns_s_ar, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_a); assert_string_equal(ns_rr_name(rr), "krb5.cwrap.org"); assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr), addr, sizeof(addr))); assert_string_equal(addr, "127.0.0.23"); }
static void test_res_fake_a_via_cname(void **state) { int rv; struct __res_state dnsstate; unsigned char answer[ANSIZE]; ns_msg handle; ns_rr rr; /* expanded resource record */ const uint8_t *rrdata; char cname[MAXDNAME]; char addr[INET_ADDRSTRLEN]; (void) state; /* unused */ memset(&dnsstate, 0, sizeof(struct __res_state)); rv = res_ninit(&dnsstate); assert_int_equal(rv, 0); /* Query for A record, but the key is a CNAME. The expected result is * that the whole chain of CNAMEs will be included in the answer section * along with the resulting A */ rv = res_nquery(&dnsstate, "rwrap.org", ns_c_in, ns_t_a, answer, sizeof(answer)); assert_in_range(rv, 1, 256); ns_initparse(answer, sizeof(answer), &handle); /* * The query must finish w/o an error, have three answers and the answers * must be a parseable RR of type CNAME and have the cname as in the * fake hosts file */ assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror); assert_int_equal(ns_msg_count(handle, ns_s_an), 3); assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_cname); rrdata = ns_rr_rdata(rr); rv = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), rrdata, cname, MAXDNAME); assert_int_not_equal(rv, -1); assert_string_equal(cname, "web.cwrap.org"); assert_int_equal(ns_parserr(&handle, ns_s_an, 1, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_cname); rrdata = ns_rr_rdata(rr); rv = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), rrdata, cname, MAXDNAME); assert_int_not_equal(rv, -1); assert_string_equal(cname, "www.cwrap.org"); assert_int_equal(ns_parserr(&handle, ns_s_an, 2, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_a); assert_string_equal(ns_rr_name(rr), "www.cwrap.org"); assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr), addr, sizeof(addr))); assert_string_equal(addr, "127.0.0.22"); }
static void test_res_fake_cname_query(void **state) { int rv; struct __res_state dnsstate; unsigned char answer[ANSIZE]; ns_msg handle; ns_rr rr; /* expanded resource record */ const uint8_t *rrdata; char cname[MAXDNAME]; char addr[INET_ADDRSTRLEN]; (void) state; /* unused */ memset(&dnsstate, 0, sizeof(struct __res_state)); rv = res_ninit(&dnsstate); assert_int_equal(rv, 0); rv = res_nquery(&dnsstate, "rwrap.org", ns_c_in, ns_t_cname, answer, sizeof(answer)); assert_in_range(rv, 1, 256); ns_initparse(answer, 256, &handle); ns_initparse(answer, sizeof(answer), &handle); /* * The query must finish w/o an error, have one answer and the answer * must be a parseable RR of type CNAME and have the cname as in the * fake hosts file */ assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror); assert_int_equal(ns_msg_count(handle, ns_s_an), 1); assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_cname); rrdata = ns_rr_rdata(rr); rv = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), rrdata, cname, MAXDNAME); assert_int_not_equal(rv, -1); assert_string_equal(cname, "web.cwrap.org"); /* The CNAME points to an A record that's present in the additional * section */ assert_int_equal(ns_msg_count(handle, ns_s_ar), 2); assert_int_equal(ns_parserr(&handle, ns_s_ar, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_cname); assert_string_equal(ns_rr_name(rr), "web.cwrap.org"); rrdata = ns_rr_rdata(rr); rv = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), rrdata, cname, MAXDNAME); assert_int_not_equal(rv, -1); assert_string_equal(cname, "www.cwrap.org"); assert_int_equal(ns_parserr(&handle, ns_s_ar, 1, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_a); assert_string_equal(ns_rr_name(rr), "www.cwrap.org"); assert_non_null(inet_ntop(AF_INET, ns_rr_rdata(rr), addr, sizeof(addr))); assert_string_equal(addr, "127.0.0.22"); }
static void test_value_range(void **state) { int a = *((int *)*state); assert_in_range(a, 0, 100); }
static void test_res_fake_soa_query(void **state) { int rv; struct __res_state dnsstate; unsigned char answer[ANSIZE]; ns_msg handle; ns_rr rr; /* expanded resource record */ const uint8_t *rrdata; char nameser[MAXDNAME]; char admin[MAXDNAME]; int serial; int refresh; int retry; int expire; int minimum; (void) state; /* unused */ memset(&dnsstate, 0, sizeof(struct __res_state)); rv = res_ninit(&dnsstate); assert_int_equal(rv, 0); rv = res_nquery(&dnsstate, "cwrap.org", ns_c_in, ns_t_soa, answer, sizeof(answer)); assert_in_range(rv, 1, 100); ns_initparse(answer, sizeof(answer), &handle); /* * The query must finish w/o an error, have one answer and the answer * must be a parseable RR of type SOA and have the data as in the fake * hosts file */ assert_int_equal(ns_msg_getflag(handle, ns_f_rcode), ns_r_noerror); assert_int_equal(ns_msg_count(handle, ns_s_an), 1); assert_int_equal(ns_parserr(&handle, ns_s_an, 0, &rr), 0); assert_int_equal(ns_rr_type(rr), ns_t_soa); rrdata = ns_rr_rdata(rr); rv = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), rrdata, nameser, MAXDNAME); assert_int_not_equal(rv, -1); rrdata += rv; rv = ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), rrdata, admin, MAXDNAME); assert_int_not_equal(rv, -1); rrdata += rv; NS_GET32(serial, rrdata); NS_GET32(refresh, rrdata); NS_GET32(retry, rrdata); NS_GET32(expire, rrdata); NS_GET32(minimum, rrdata); assert_string_equal(nameser, "ns1.cwrap.org"); assert_string_equal(admin, "admin.cwrap.org"); assert_int_equal(serial, 2014100457); assert_int_equal(refresh, 3600); assert_int_equal(retry, 300); assert_int_equal(expire, 1814400); assert_int_equal(minimum, 600); }
static void newRand_void_sizeInRangeZeroToTen (void **state) { array_t array = Array_newRand(); assert_in_range (Array_getSize(array),0, 10); Array_delete(array); }