int main(void) { type_t tau; init_type_table(&types, 0); init_variables(); init_types(); // pair(A) = (tuple A A) tau = pair_type(var[0], var[0]); test_macro("pair", 1, var, tau); // triple(B) = (tuple B B B) tau = triple_type(var[1], var[1], var[1]); test_macro("triple", 1, var+1, tau); // test(C, D) = bool test_macro("test", 2, var+2, base[0]); // fun(E, F) = (-> (tuple E E) F) tau = pair_type(var[4], var[4]); tau = function_type(&types, var[5], 1, &tau); test_macro("fun", 2, var+4, tau); // two constructors test_constructor("mk_type2", 2); test_constructor("mk_type3", 3); printf("\n====== TYPES ========\n"); print_type_table(stdout, &types); printf("\n===== MACROS ========\n"); print_type_macros(stdout, &types); printf("===\n\n"); // creation after remove // vector[G] = (-> int G) tau = int_type(&types); tau = function_type(&types, var[6], 1, &tau); test_macro("vector", 1, var+6, tau); // matrix[H] = (-> int int H) tau = int_type(&types); tau = binary_ftype(tau, tau, var[7]); test_macro("matrix", 1, var+7, tau); printf("\n====== TYPES ========\n"); print_type_table(stdout, &types); printf("\n===== MACROS ========\n"); print_type_macros(stdout, &types); printf("===\n\n"); delete_type_table(&types); return 0; }
int main() { test_constructor(); test_operator_assign(); test_comparison_operators(); test_operator_index(); test_operator_indexOf(); return 0; }
void test_leak () { // test memory leak. for (;;) { // use top4.1 to watch memory usage test_constructor(); test_assign(); test_conversion_deref(); test_bind_cmp(); test_use(); test_cycle(); } }
int main () { BEGIN_TESTS(0); test_constructor(); test_compare(); test_timezone(); return END_TESTS; }
int main(void) { test_simple(); test_constructor(); test_destructor(); test_copier(); test_full(); test_bad_constructor(); assert(R_Type_BytesAllocated == 0); printf("Pass\n"); return 0; }
int main (void) { START("CoolHandle"); test_constructor(); test_assign(); test_conversion_deref(); test_bind_cmp(); test_use(); test_cycle(); #if LEAK test_leak(); #endif SUMMARY(); return 0; }
static void TestMatrix44(skiatest::Reporter* reporter) { SkMatrix44 mat, inverse, iden1, iden2, rot; mat.reset(); mat.setTranslate(1, 1, 1); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); mat.setScale(2, 2, 2); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); mat.setScale(SK_MScalar1/2, SK_MScalar1/2, SK_MScalar1/2); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); mat.setScale(3, 3, 3); rot.setRotateDegreesAbout(0, 0, -1, 90); mat.postConcat(rot); REPORTER_ASSERT(reporter, mat.invert(NULL)); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); iden2.setConcat(inverse, mat); REPORTER_ASSERT(reporter, is_identity(iden2)); // test rol/col Major getters { mat.setTranslate(2, 3, 4); float dataf[16]; double datad[16]; mat.asColMajorf(dataf); assert16<float>(reporter, dataf, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 2, 3, 4, 1); mat.asColMajord(datad); assert16<double>(reporter, datad, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 2, 3, 4, 1); mat.asRowMajorf(dataf); assert16<float>(reporter, dataf, 1, 0, 0, 2, 0, 1, 0, 3, 0, 0, 1, 4, 0, 0, 0, 1); mat.asRowMajord(datad); assert16<double>(reporter, datad, 1, 0, 0, 2, 0, 1, 0, 3, 0, 0, 1, 4, 0, 0, 0, 1); } test_concat(reporter); if (false) { // avoid bit rot, suppress warning (working on making this pass) test_common_angles(reporter); } test_constructor(reporter); test_gettype(reporter); test_determinant(reporter); test_transpose(reporter); test_get_set_double(reporter); test_set_row_col_major(reporter); test_translate(reporter); test_scale(reporter); test_map2(reporter); }
void VectorTest::run_test_case(void) { message += "Running vector test case...\n"; // Constructor and destructor methods test_constructor(); test_destructor(); // Arithmetic operators test_sum_operator(); test_rest_operator(); test_multiplication_operator(); test_division_operator(); // Operation and assignment operators test_sum_assignment_operator(); test_rest_assignment_operator(); test_multiplication_assignment_operator(); test_division_assignment_operator(); // Equality and relational operators test_equal_to_operator(); test_not_equal_to_operator(); test_greater_than_operator(); test_greater_than_or_equal_to_operator(); test_less_than_operator(); test_less_than_or_equal_to_operator(); // Output operator test_output_operator(); // Get methods test_get_display(); // Set methods test_set(); test_set_display(); // Resize methods test_resize(); test_tuck_in(); test_take_out(); test_remove_element(); test_get_assembly(); // Initialization methods test_initialize(); test_initialize_sequential(); test_randomize_uniform(); test_randomize_normal(); // Checking methods test_contains(); test_is_in(); test_is_constant(); test_is_crescent(); test_is_decrescent(); // Mathematical methods test_dot_vector(); test_dot_matrix(); test_calculate_sum(); test_calculate_partial_sum(); test_calculate_product(); test_calculate_mean(); test_calculate_standard_deviation(); test_calculate_covariance(); test_calculate_mean_standard_deviation(); test_calculate_minimum(); test_calculate_maximum(); test_calculate_minimum_maximum(); test_calculate_minimum_missing_values(); test_calculate_maximum_missing_values(); test_calculate_minimum_maximum_missing_values(); test_calculate_explained_variance(); test_calculate_histogram(); test_calculate_bin(); test_calculate_frequency(); test_calculate_total_frequencies(); test_calculate_minimal_index(); test_calculate_maximal_index(); test_calculate_minimal_indices(); test_calculate_maximal_indices(); test_calculate_minimal_maximal_index(); test_calculate_cumulative_index(); test_calculate_closest_index(); test_calculate_norm(); test_calculate_normalized(); test_calculate_sum_squared_error(); test_calculate_mean_squared_error(); test_calculate_root_mean_squared_error(); test_apply_absolute_value(); test_calculate_lower_bounded(); test_calculate_upper_bounded(); test_calculate_lower_upper_bounded(); test_apply_lower_bound(); test_apply_upper_bound(); test_apply_lower_upper_bounds(); test_calculate_less_rank(); test_calculate_greater_rank(); test_calculate_linear_correlation(); test_calculate_linear_correlation_missing_values(); test_calculate_linear_regression_parameters(); // Scaling and unscaling test_scale_minimum_maximum(); test_scale_mean_standard_deviation(); // Parsing methods test_parse(); // Serialization methods test_save(); test_load(); message += "End vector test case\n"; }
void MatrixTest::run_test_case(void) { message += "Running matrix test case...\n"; // Constructor and destructor methods test_constructor(); test_destructor(); // Assignment operators methods test_assignment_operator(); // Reference operator methods test_reference_operator(); // Arithmetic operators test_sum_operator(); test_rest_operator(); test_multiplication_operator(); test_division_operator(); // Arithmetic and assignment operators test_sum_assignment_operator(); test_rest_assignment_operator(); test_multiplication_assignment_operator(); test_division_assignment_operator(); // Equality and relational operators test_equal_to_operator(); test_not_equal_to_operator(); test_greater_than_operator(); test_less_than_operator(); test_greater_than_or_equal_to_operator(); test_less_than_or_equal_to_operator(); // Output operators test_output_operator(); // Get methods test_get_rows_number(); test_get_columns_number(); test_arrange_row(); test_arrange_column(); test_arrange_submatrix(); // Set methods test_set(); test_set_rows_number(); test_set_columns_number(); test_set_row(); test_set_column(); // Diagonal methods test_get_diagonal(); test_set_diagonal(); test_sum_diagonal(); // Resize methods test_append_row(); test_append_column(); test_insert_row(); test_insert_column(); test_subtract_row(); test_subtract_column(); test_sort_less_rows(); test_sort_greater_rows(); // Initialization methods test_initialize(); test_randomize_uniform(); test_randomize_normal(); test_set_to_identity(); // Mathematical methods test_calculate_sum(); test_calculate_rows_sum(); test_dot_vector(); test_dot_matrix(); test_calculate_eigenvalues(); test_calculate_eigenvectors(); test_direct(); test_calculate_minimum_maximum(); test_calculate_mean_standard_deviation(); test_calculate_statistics(); test_calculate_histogram(); test_calculate_covariance_matrix(); test_calculate_minimal_indices(); test_calculate_maximal_indices(); test_calculate_minimal_maximal_indices(); test_calculate_sum_squared_error(); test_calculate_mean_squared_error(); test_calculate_root_mean_squared_error(); test_calculate_determinant(); test_calculate_transpose(); test_calculate_cofactor(); test_calculate_inverse(); test_is_symmetric(); test_is_antisymmetric(); // Scaling methods test_scale_mean_standard_deviation(); test_scale_rows_mean_standard_deviation(); test_scale_columns_mean_standard_deviation(); test_scale_rows_columns_mean_standard_deviation(); test_scale_minimum_maximum(); test_scale_rows_minimum_maximum(); test_scale_columns_minimum_maximum(); test_scale_rows_columns_minimum_maximum(); // Unscaling methods test_unscale_mean_standard_deviation(); test_unscale_rows_mean_standard_deviation(); test_unscale_columns_mean_standard_deviation(); test_unscale_rows_columns_mean_standard_deviation(); test_unscale_minimum_maximum(); test_unscale_rows_minimum_maximum(); test_unscale_columns_minimum_maximum(); test_unscale_rows_columns_minimum_maximum(); test_convert_angular_variables_degrees(); test_convert_angular_variables_radians(); // Serialization methods test_print(); test_load(); test_save(); test_parse(); message += "End of matrix test case.\n"; }
DEF_TEST(Matrix44, reporter) { SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor); SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor); SkMatrix44 iden1(SkMatrix44::kUninitialized_Constructor); SkMatrix44 iden2(SkMatrix44::kUninitialized_Constructor); SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor); mat.setTranslate(1, 1, 1); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); mat.setScale(2, 2, 2); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); mat.setScale(SK_MScalar1/2, SK_MScalar1/2, SK_MScalar1/2); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); mat.setScale(3, 3, 3); rot.setRotateDegreesAbout(0, 0, -1, 90); mat.postConcat(rot); REPORTER_ASSERT(reporter, mat.invert(NULL)); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); iden2.setConcat(inverse, mat); REPORTER_ASSERT(reporter, is_identity(iden2)); // test tiny-valued matrix inverse mat.reset(); auto v = SkDoubleToMScalar(1.0e-12); mat.setScale(v,v,v); rot.setRotateDegreesAbout(0, 0, -1, 90); mat.postConcat(rot); mat.postTranslate(v,v,v); REPORTER_ASSERT(reporter, mat.invert(NULL)); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); // test mixed-valued matrix inverse mat.reset(); mat.setScale(SkDoubleToMScalar(1.0e-2), SkDoubleToMScalar(3.0), SkDoubleToMScalar(1.0e+2)); rot.setRotateDegreesAbout(0, 0, -1, 90); mat.postConcat(rot); mat.postTranslate(SkDoubleToMScalar(1.0e+2), SkDoubleToMScalar(3.0), SkDoubleToMScalar(1.0e-2)); REPORTER_ASSERT(reporter, mat.invert(NULL)); mat.invert(&inverse); iden1.setConcat(mat, inverse); REPORTER_ASSERT(reporter, is_identity(iden1)); // test degenerate matrix mat.reset(); mat.set3x3(1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0); REPORTER_ASSERT(reporter, !mat.invert(NULL)); // test rol/col Major getters { mat.setTranslate(2, 3, 4); float dataf[16]; double datad[16]; mat.asColMajorf(dataf); assert16<float>(reporter, dataf, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 2, 3, 4, 1); mat.asColMajord(datad); assert16<double>(reporter, datad, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 2, 3, 4, 1); mat.asRowMajorf(dataf); assert16<float>(reporter, dataf, 1, 0, 0, 2, 0, 1, 0, 3, 0, 0, 1, 4, 0, 0, 0, 1); mat.asRowMajord(datad); assert16<double>(reporter, datad, 1, 0, 0, 2, 0, 1, 0, 3, 0, 0, 1, 4, 0, 0, 0, 1); } test_concat(reporter); if (false) { // avoid bit rot, suppress warning (working on making this pass) test_common_angles(reporter); } test_constructor(reporter); test_gettype(reporter); test_determinant(reporter); test_invert(reporter); test_transpose(reporter); test_get_set_double(reporter); test_set_row_col_major(reporter); test_translate(reporter); test_scale(reporter); test_map2(reporter); test_3x3_conversion(reporter); test_has_perspective(reporter); test_preserves_2d_axis_alignment(reporter); test_toint(reporter); }