int main(int argc, char *argv[]) { size_t i; printf("Testing lzjb-stream's size codec API ...\n"); /* Hard-coded edge cases. */ test_size(0); test_size(~(size_t) 0); /* A single walking 1-bit. */ for(i = 1; i != 0; i <<= 1) test_size(i); for(i = 0; i < 1000000; ++i) { test_size(rand()); } printf("Testing lzjb-stream's decompression API ...\n"); test_decompress(); printf("%zu/%zu tests passed\n", test_state.pass_count, test_state.count); printf("Testing performance ...\n"); test_performance("performance-data.lzjb"); printf("By the way, the stream itself is %zu bytes\n", sizeof (LZJBStream)); return EXIT_SUCCESS; }
int main() { int failures = 0; failures += test_size("sql_tinyint", mysqlpp::sql_tinyint(0), 1) == false; failures += test_size("sql_tinyint_unsigned", mysqlpp::sql_tinyint_unsigned(0), 1) == false; failures += test_size("sql_smallint", mysqlpp::sql_smallint(0), 2) == false; failures += test_size("sql_smallint_unsigned", mysqlpp::sql_smallint_unsigned(0), 2) == false; failures += test_size("sql_mediumint", mysqlpp::sql_mediumint(0), 4) == false; failures += test_size("sql_mediumint_unsigned", mysqlpp::sql_mediumint_unsigned(0), 4) == false; failures += test_size("sql_int", mysqlpp::sql_int(0), 4) == false; failures += test_size("sql_int_unsigned", mysqlpp::sql_int_unsigned(0), 4) == false; failures += test_size("sql_bigint", mysqlpp::sql_bigint(0), 8) == false; failures += test_size("sql_bigint_unsigned", mysqlpp::sql_bigint_unsigned(0), 8) == false; return failures; }
inline mxArray* do_det2x2(const mxArray *mxA) { int n = 0; if (test_size(mxA, 2, 2, n)) { const Mat2x2<T>* A = (const Mat2x2<T>*)mxGetData(mxA); mxArray *mxR = create_mat<T>(1, n); T *r = (T*)mxGetData(mxR); for (int i = 0; i < n; ++i) { r[i] = det(A[i]); } return mxR; } else if (test_size(mxA, 4, 1, n)) { const Mat2x2<T>* A = (const Mat2x2<T>*)mxGetData(mxA); mxArray *mxR = create_mat<T>(1, n); T *r = (T*)mxGetData(mxR); for (int i = 0; i < n; ++i) { r[i] = det(A[i]); } return mxR; } else if (test_size(mxA, 3, 1, n)) { const SMat2x2<T>* A = (const SMat2x2<T>*)mxGetData(mxA); mxArray *mxR = create_mat<T>(1, n); T *r = (T*)mxGetData(mxR); for (int i = 0; i < n; ++i) { r[i] = det(A[i]); } return mxR; } else { mexErrMsgIdAndTxt("det2x2:invalidarg", "The size of input array is invalid."); } return NULL; }
inline mxArray* do_sqrtm2x2(const mxArray *mxA) { int n = 0; if (test_size(mxA, 2, 2, n)) { const Mat2x2<T>* A = (const Mat2x2<T>*)mxGetData(mxA); mxArray *mxR = create_cube<T>(2, 2, n); Mat2x2<T>* R = (Mat2x2<T>*)mxGetData(mxR); for (int i = 0; i < n; ++i) { sqrtm(A[i], R[i]); } return mxR; } else if (test_size(mxA, 4, 1, n)) { const Mat2x2<T>* A = (const Mat2x2<T>*)mxGetData(mxA); mxArray *mxR = create_mat<T>(4, n); Mat2x2<T>* R = (Mat2x2<T>*)mxGetData(mxR); for (int i = 0; i < n; ++i) { sqrtm(A[i], R[i]); } return mxR; } else if (test_size(mxA, 3, 1, n)) { const SMat2x2<T>* A = (const SMat2x2<T>*)mxGetData(mxA); mxArray *mxR = create_mat<T>(3, n); SMat2x2<T>* R = (SMat2x2<T>*)mxGetData(mxR); for (int i = 0; i < n; ++i) { sqrtm(A[i], R[i]); } return mxR; } else { mexErrMsgIdAndTxt("sqrtm2x2:invalidarg", "The size of input array is invalid."); } return NULL; }
int main() { int Error = 0; Error += test_member_alloc_bug(); Error += test_ctr(); Error += test_operators<glm::mat4, glm::vec4>(); Error += test_operators<glm::lowp_mat4, glm::lowp_vec4>(); Error += test_operators<glm::mediump_mat4, glm::mediump_vec4>(); Error += test_operators<glm::highp_mat4, glm::highp_vec4>(); Error += test_operators<glm::dmat4, glm::dvec4>(); Error += test_operators<glm::lowp_dmat4, glm::lowp_dvec4>(); Error += test_operators<glm::mediump_dmat4, glm::mediump_dvec4>(); Error += test_operators<glm::highp_dmat4, glm::highp_dvec4>(); Error += test_inverse<glm::mat4>(); Error += test_inverse<glm::lowp_mat4>(); Error += test_inverse<glm::mediump_mat4>(); Error += test_inverse<glm::highp_mat4>(); Error += test_inverse<glm::dmat4>(); Error += test_inverse<glm::lowp_dmat4>(); Error += test_inverse<glm::mediump_dmat4>(); Error += test_inverse<glm::highp_dmat4>(); Error += test_size(); Error += test_constexpr(); return Error; }
int main(int argc, char** argv) { printf("KEY META TESTS\n"); printf("==================\n\n"); init (argc, argv); test_basic(); test_iterate(); test_size(); test_uid(); test_dup(); test_comment(); test_owner(); test_mode(); test_type(); test_examples(); test_copy(); test_ro(); test_new(); test_copyall(); printf("\ntest_ks RESULTS: %d test(s) done. %d error(s).\n", nbTest, nbError); return nbError; }
int file_reader(char *file, int ***map) { int fd; int ret; char *line; int i; if (!(init_map(map, file))) return (0); if (!test_file(file)) return (0); i = 0; fd = open(file, O_RDONLY); while ((ret = get_next_line(fd, &line)) > 0) { if (!((*map)[i] = line_filler(line, (*map)[i]))) return (0); ft_strdel(&line); i++; } if (!test_size(map)) return (0); close(fd); return ((ret < 0) ? 0 : 1); }
enum piglit_result piglit_display(void) { GLboolean pass = GL_TRUE; int sizeidx; testnr = 0; piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glClearColor(0.5, 0.5, 0.5, 1.0); glClear(GL_COLOR_BUFFER_BIT); glEnable(GL_TEXTURE_2D); for(sizeidx = 0; sizeidx < sizeof(sizes)/sizeof(sizes[0]); ++sizeidx) { if (!test_size(sizes[sizeidx].w, sizes[sizeidx].h)) { pass = GL_FALSE; } } glDisable(GL_TEXTURE_2D); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
static int test_pbkdf2(const struct ccdigest_info *di) { static test_vector vector[] = { { password1, saltstr128, 100, 16, "4fb479b7843efec99b2a9d137682bba2", // MD2 "a941b5a1246eb37e7d8bbfb803257d29", // MD4 "c21f6f8b192757dc79bfd67378255152", // MD5 "f61e774036c4007d4402fe9912e29a85", // SHA1 "78e396298731187a7e9a355694296b1f", // SHA224 "854a1e9b6834413dc51b4316dbe405e1", // SHA256 "813022dc740ec35fb4c4eaf67cd42539", // SHA384 "9842d62607fa2b5d5165d6526f74e119", // SHA512 "5dd09887fd05b8140c51883f6bed9949", // RMD128 "b68e9c0c55f521c3f2fcc84320a089de", // RMD160 "1cdb7e76936a6c2f528a38521dab24a8", // RMD256 "b68e9c0c55f521c3f2fcc84320a089de", // RMD320 }, { password1, saltstr128, 1000, 24, "ec806929819bb71b46b6552ac71d0e141af5360bfca0c03c", // MD2 "b8d26c6338b43b11fe2c8c7a45d31b015f72ae7cfde36778", // MD4 "cb2c261847e9e1c3141478bd084565da00024366ec9d167e", // MD5 "0309e2fe4e0bdfe7d0fe4828d41c234416e2d9bfb61cdd8f", // SHA1 "7d8603adef1af3704db8c7d2c471661ca73ac07c9044a5dc", // SHA224 "25eb86acc76e43018f18b9a8f90c2fed462d1c799e83d48a", // SHA256 "82d915ec6e30a50a987fe17cc6d260194c33fec4f2f14196", // SHA384 "c74e4080d0fbb41fee5868c0ff60fd75acae2638215987e5", // SHA512 "db8cc4a86241e5f9f4f2be8a020d2db8a6b065dc1604c92f", // RMD128 "e4d14f220779d824d281b50a5c688a4071219411ce4ece1c", // RMD160 "118c9330daafb701cd37c3f8e0f5fc1a1846b5e72153a65f", // RMD256 "e4d14f220779d824d281b50a5c688a4071219411ce4ece1c", // RMD320 }, { password1, saltstr128, 10000, 8, "3e6698827388fc04", // MD2 "a7e2590655919ffc", // MD4 "d352d8ec8e276adc", // MD5 "8e3e2f73c3eb6390", // SHA1 "a7150cd1d2a90e2d", // SHA224 "eb6c81535592203c", // SHA256 "24f67028f09c4d89", // SHA384 "5e5984ca905a5524", // SHA512 "468f482fbf85e70b", // RMD128 "b35814741b948ecb", // RMD160 "9d544ae850aea450", // RMD256 "b35814741b948ecb", // RMD320 }, }; int vector_size = sizeof (vector) / sizeof (test_vector); if(verbose) diag("pbkdf2 LT Test\n"); for(int i=0; i<vector_size; i++) { ok(test_oneshot(di, &vector[i]), "test one-shot with data less than blocksize"); } test_size(di); return 1; }
void hpack_size(grpc_end2end_test_config config) { static const int interesting_sizes[] = {4096, 0, 100, 1000, 32768, 4 * 1024 * 1024}; size_t i, j; for (i = 0; i < GPR_ARRAY_SIZE(interesting_sizes); i++) { for (j = 0; j < GPR_ARRAY_SIZE(interesting_sizes); j++) { test_size(config, interesting_sizes[i], interesting_sizes[j]); } } }
int main() { std::list<int> const data = build_list(); test_rbegin(data); test_rend(data); test_resize(data); test_size(data); test_splice(data); return boost::report_errors(); }
int main() { int Error = 0; Error += cast::test(); Error += test_ctr(); Error += test_operators(); Error += test_size(); return Error; }
int main() { int Error = 0; Error += test_ctr(); Error += test_two_axis_ctr(); Error += test_size(); Error += test_precision(); Error += test_constexpr(); return Error; }
int main() { std::multimap<int, int> const data = build_multimap(); test_multimap_insert(data); test_key_comp(data); test_max_size(data); test_rbegin(data); test_rend(data); test_size(data); test_value_comp(data); return boost::report_errors(); }
int main() { int Error = 0; Error += test_dual_quat_ctr(); Error += test_dquat_type(); Error += test_scalars(); Error += test_inverse(); Error += test_mul(); Error += test_size(); return Error; }
int main() { BOOST_STATIC_ASSERT((!phx::stl::has_mapped_type<std::list<int> >::value)); BOOST_STATIC_ASSERT((!phx::stl::has_key_type<std::list<int> >::value)); std::list<int> const data = build_list(); test_rbegin(data); test_rend(data); test_resize(data); test_size(data); test_splice(data); return boost::report_errors(); }
void find_len(t_list **lst, t_display *display) { t_list *tmp; tmp = *lst; while (tmp) { test_links(display, tmp); test_owner(display, tmp); test_group(display, tmp); test_size(display, tmp); tmp = tmp->next; } }
int main(void) { test_null(); test_num(); test_bytes(); test_appendNum(); test_appendBytes(); test_toByte(); test_toByte_4bitpadding(); test_size(); report(); return 0; }
int main(void) { int i; /* Too complicated to work out the exact number */ plan_no_plan(); for (i = 0; i < NSIZES; i++) { diag("Testing %d-bit bitmap", bitmap_sizes[i]); test_size(bitmap_sizes[i]); } /* This exits depending on whether all tests passed */ return exit_status(); }
void test_static_array() { test_constructor_destructor(); test_copy_constructor(); test_move_constructor(); test_size(); test_deep_copy(); test_reconstruct_element(); test_reconstruct_array(); test_zero_array(); test_get(); test_first_last(); test_get_range(); test_internal_array(); test_range_copy(); }
static off_t get_partition_size(int fd, off_t maxSize) { // binary search off_t lower = 0; off_t upper = maxSize; while (lower < upper) { off_t mid = (lower + upper + 1) / 2; if (test_size(fd, mid)) lower = mid; else upper = mid - 1; } return lower; }
int main(int argc, char *argv[]) { char *p = NULL; p = test_size(p, 0); p = test_size(p, 1); p = test_size(p, 8); p = test_size(p, 128); p = test_size(p, 1024); p = test_size(p, 16384); p = test_size(p, 8); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { test_null(); test_num(); test_bytes(); test_appendNum(); test_appendBytes(); test_toByte(); test_toByte_4bitpadding(); test_size(); test_append(); report(); return 0; }
int main() { std::deque<int> const data = build_deque(); test_insert(data); test_max_size(data); test_pop_back(data); test_pop_front(data); test_push_back(data); test_push_front(data); test_rbegin(data); test_rend(data); test_resize(data); test_size(data); return boost::report_errors(); }
int main(int argc, const char* argv[]) { (void)argc; (void)argv; if(argc<3) { return 1; } int maxu = atoi(argv[1]); int maxv = atoi(argv[2]); unsigned long long size = atoll(argv[3]); test_size(size, maxu, maxv); test_time(size, maxu, maxv); return 0; }
int main() { int Error = 0; repro Repro; Error += cast::test(); Error += test_ctr(); Error += test_inverse_dmat4x4(); Error += test_inverse_mat4x4(); Error += test_operators(); Error += test_inverse(); Error += test_size(); Error += perf_mul(); return Error; }
int main() { int Error = 0; Error += test_quat_ctr(); Error += test_quat_mul_vec(); Error += test_quat_two_axis_ctr(); Error += test_quat_mul(); Error += test_quat_precision(); Error += test_quat_type(); Error += test_quat_angle(); Error += test_quat_angleAxis(); Error += test_quat_mix(); Error += test_quat_normalize(); Error += test_quat_euler(); Error += test_quat_slerp(); Error += test_size(); return Error; }
int main(void) { int totaltests = 0; int i; for (i = 0; i < NSIZES; i++) { int size = bitmap_sizes[i]; /* Summing the arithmetic series gives: */ totaltests += size*(size + 3) + 1; } plan_tests(totaltests); for (i = 0; i < NSIZES; i++) { diag("Testing %d-bit bitmap", bitmap_sizes[i]); test_size(bitmap_sizes[i]); } /* This exits depending on whether all tests passed */ return exit_status(); }
int main(int argc, char **argv) { int i; int nb_error = 0; argc =argc; argv =argv; make_crc_table(); init_test_buf(); for (i=0; size_of_test[i] != 0; i++) { if (!test_size(size_of_test[i])) { nb_error++; } } if (nb_error) { g_fprintf(stderr, " FAIL CRC \n"); } else { g_fprintf(stderr, " PASS CRC\n"); } return nb_error; }
int main(void) { test_construct_with_null(); test_construct_with_empty_string(); test_construct_with_nonempty_string(); test_append_char(); test_at(); test_back(); test_capacity(); test_clear(); test_compare(); test_data(); test_empty(); test_free(); test_front(); test_length(); test_max_size(); test_pop_back(); test_push_back(); test_reserve(); test_resize(); test_size(); return EXIT_SUCCESS; }