int main(int argc, char *argv[]) {
if (argc < 2) die("USAGE: ex18 4 3 1 5 6");
int count = argc - 1;
int i = 0;
char **inputs = argv + 1;
int *numbers = malloc(count * sizeof(int));
if (!numbers) die("Memory error.");
for (i = 0; i < count; i++) {
numbers[i] = atoi(inputs[i]);
}
test_sort(numbers, count, sorted_order);
test_sort(numbers, count, reverse_order);
test_sort(numbers, count, strange_order);
test_sort(numbers, count, invalid_function);
dump_callback(sorted_order);
dump_callback(reverse_order);
dump_callback(strange_order);
free(numbers);
return 0;
}
int main()
{
random_fill(0,0x7fffffff,6,list0,list1,list2,list3,list4,list5);
//random_fill(0,N,6,list0,list1,list2,list3,list4,list5);
test_sort(list0,0,N-1,"my quick_sort_0",quick_sort_0);
test_sort(list1,0,N-1,"my quick_sort_1",quick_sort_1);
test_sort(list2,0,N-1,"other_quick_sort_0",other_quick_sort_0);
test_sort(list3,0,N-1,"other eq_sort",eq_sort);
// test_sort(list3,0,N-1,"clib_quick_sort",clib_quick_sort);
test_sort1(list4,0,N-1,"other bq_sort",bq_sort);
test_sort1(list5,0,N-1,"my quick_sort_2",quick_sort_2);
return 0;
}
int main(int argc, char **argv)
{
test_sort(bubble_sort);
test_sort(selection_sort);
test_sort(insertion_sort);
return 0;
}
int main(int argc, char **argv)
{
int array[] = { 1, 6, 3, 9, 11, 5, 4, 7, 2};
int array2[] = { 9, 1, 3, 8, 11, 5, 4, 7, 21};
test_sort(array, ARRAY_SIZE(array));
test_sort(array2, ARRAY_SIZE(array));
return 0;
}
void sort(int arr[],int size)//BUBBLE SORT//COMPLETE
{
//int test=1;
int i=0;
int temp;
while (test_sort(arr,size))// the test_sort function sees if the array is order if it is not continues while loop
{
i=0;
while (i<size-1)
{
if (arr[i]>arr[i+1])
{
temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
i++;
}
}
i=0;
while (i<size-1)
{
//printf("%d ",arr[i]);
if (arr[i]>arr[i+1])
{
printf("Error Sorting Unsuccessful\n");
return;
}
i++;
}
printf("\nSorting Successful and Verified\n");
}
void test_mem(void) {
test_memfn();
test_chrfn();
test_dmem();
test_sort();
test_search();
}
void test_generic_set<ValueTraits, ContainerDefiner>::test_all()
{
typedef typename ValueTraits::value_type value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
std::vector<value_type> values (6);
for (int i = 0; i < 6; ++i)
values[i].value_ = random_init[i];
typedef typename ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
>::type set_type;
{
set_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_insert_advanced(values);
test_swap(values);
test_find(values);
test_impl();
test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values);
}
void test_generic_multiset<ValueTraits, ContainerDefiner>::test_all ()
{
typedef typename ValueTraits::value_type value_type;
static const int random_init[6] = { 3, 2, 4, 1, 5, 2 };
value_cont_type values (6);
for (int i = 0; i < 6; ++i)
(&values[i])->value_ = random_init[i];
typedef ContainerDefiner
< value_type
, value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size>
> definer_function;
typedef typename definer_function::type multiset_type;
{
multiset_type testset(values.begin(), values.end());
test::test_container(testset);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_common_unordered_and_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_associative_container(testset, values);
testset.clear();
testset.insert(values.begin(), values.end());
test::test_non_unique_container(testset, values);
}
test_sort(values);
test_insert(values);
test_swap(values);
test_find(values);
test_impl();
test_generic_assoc<ValueTraits, ContainerDefiner>::test_all(values);
}
int main(int argc, char *argv[])
{
char*filename;
FILE*fd;
int N,i,j;
int*A;
if(argc<2)return 1;
filename = argv[1];
fd = fopen(filename,"r");
if(!fd)return 1;
i = fscanf(fd,"%d",&N);
A = (int*)calloc(N,sizeof(int));
for(i=0;i<N;i++)
j = fscanf(fd,"%d",A+i);
fclose(fd);
printf("read.. ok\n");
i = test_sort(A,N);
if(i==0){
printf("OK\n");
}else{
printf("FAIL (%d)\n",i);
}
free(A);
return 0;
}
void test_int_sort(void (*sort)(void**, size_t, int (*cmp)(void*, void*)),
int* array,
size_t size,
const char* message) {
void** pointers = generate_pointer_array((void*) array, size, sizeof(int));
test_sort(sort, int_compare, pointers, size, message);
free(pointers);
}
int main() {
uint32_t n;
for (n=0; n <= 100; n += 20) {
printf("\n==== size %"PRIu32" ====\n", n);
set_array_constant(a, n);
test_sort(a, n);
set_array_increasing(a, n);
test_sort(a, n);
set_array_decreasing(a, n);
test_sort(a, n);
set_array_random(a, n);
test_sort(a, n);
set_array_random(a, n);
test_sort(a, n);
}
return 0;
}
int test_all()
{
int result = 0;
result += test_random();
result += test_linked_list();
result += test_vstack();
result += test_vqueue();
result += test_sort();
/* result += test_hash(); HASH IS NOT COMPLETE */
return result;
}
int main(void)
{
static const size_t MAX_N = 4 * 1024 * 1024;
for (size_t i = 0; i < 20; ++i) {
const size_t n = MAX_N >> i;
test_sort(n, MAX_N);
}
return 0;
}
// run tests for all sort functions
int test_sorts( void )
{
struct sortdef_s *s;
for ( s = sort_definitions; s->sortfn != NULL; s++ )
{
printf("%s: ", s->name);
test_sort(s->sortfn);
}
return 0;
}
void pre_sort(t_box *box)
{
int error;
int locat;
error = amount_error(box, &locat);
if (error == 0)
return ;
if (A[0] > A[1] && locat == 0 && A[box->size - 2] > A[box->size - 1])
swap_a(box);
else if (locat >= (box->size / 2) && error == 1)
test_sort(box);
else if (A[0] > A[1] && error == 1)
test_sort(box);
else if (box->size <= 3)
test_sort(box);
if (!(check_sort(A, box->size)))
basic_sort(box);
if (box->b_op == 1)
print_nbop(box);
}
int main(int argc, char ** argv)
{
string path = "/Users/andreasfragner/Desktop/";
// TEST STACK DIRECTION (misc.hpp)
StackDirection(&argc);
// SEARCH
testSearch();
// SEEDS
srand( int(time(NULL)) );
// TESTS/SPECS
BitTest mytest;
mytest.run();
// RANDOM
testRandom();
// DATA STRUCTURES
test_SL();
test_Stack();
test_Queue();
TowersOfHanoi(10);
// NUMERICAL
test_Numerical();
// PRIMES
test_primes();
// SORT
test_sort();
// MISC
test_misc();
cout << "\n\n\n\n-----------------------------"<<endl;
cout << "-----------------------------"<<endl;
return 0;
}
int main(int argc, char** argv) {
wlog("testing creating, get, set and iteration\n");
test_create_and_access();
wlog("testing realloc resize clear and freedata\n");
test_realloc_resize();
wlog("testing push pop and extend\n");
test_pushpop();
wlog("testing sort\n");
test_sort();
wlog("testing basic type long\n");
test_long();
wlog("testing pointer\n");
test_ptr();
}
int main(int argc, char* argv[])
{
int i;
//_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
srand(time(NULL));
for (i = 1000; i < 300000; i++)
test_sort(i);
getchar();
return 0;
}
END_TEST
int main(int argc, char** argv)
{
//plan_tests(1);
int _testnum = 1;
ok( test_insert_remove() , "insert and remove");
ok( test_binary_search() , "binary search");
ok( test_sort() , "sort");
// TODO more tests
return 0;
}
void test_slist(struct cag_test_series *tests)
{
test_it(tests);
test_new(tests);
test_prepend(tests);
test_insert(tests);
test_insertp(tests);
test_distance(tests);
test_front(tests);
test_erase(tests);
test_copy(tests);
test_reverse(tests);
test_copy_over(tests);
test_sort(tests);
test_find(tests);
}
int main(int argc, char* argv[]) {
int errors = 0;
test_append(&errors);
test_remove(&errors);
test_is_empty(&errors);
test_reverse(&errors);
test_sort(&errors);
if (errors == 0)
printf("All tests passed\n");
else
printf("\nTests done with %d error(s)\n", errors);
return 0;
}
int
main (void)
{
mpfr_prec_t p;
unsigned long n;
tests_start_mpfr ();
check_special ();
test_sort (1764, 1026);
for (p = 2 ; p < 444 ; p += 17)
for (n = 2 ; n < 1026 ; n += 42 + p)
test_sum (p, n);
tests_end_mpfr ();
return 0;
}
int main()
{
setlocale(LC_CTYPE, "");
test_sort(WS_NOSPACE);
test_sort(WS_NOCASE);
test_sort(WS_NUMERIC);
test_sort(WS_NOARTICLE|WS_NOSPACE);
test_sort(WS_NOCASE|WS_NOSPACE|WS_ACCENT);
test_sort(WS_LIGATURE|WS_NOCASE|WS_NOSPACE|WS_NUMERIC|WS_ACCENT|WS_NOARTICLE);
return 0;
}
void test(){
test_sum();
test_max();
test_min();
test_second_max();
test_second_min();
test_equal();
test_occurences();
test_countNegatives();
test_indexOf();
test_clearWith();
test_insertElement();
test_removeElement();
test_copy();
test_merge();
test_reverse();
test_sort();
printf("All passed!!!!");
}
void test_buildin()
{
int failures=0;
printf("*** Testing of builtin ***\n");
failures += test_length();
failures += test_copy();
failures += test_find();
failures += test_sort();
if(failures)
{
printf("\n\n!!! ERROR has occured during testing !!!\n\n");
}
else
{
printf("\n\nOK. Everything is fine.\n\n");
}
}
int test_all(void)
{
/* Seed PRNG with current time */
fprintf(stderr, "test_all: seeding PRNG...\n");
time_t const seed = time(NULL);
if (seed < ((time_t) 0))
{
perror("time");
return(-1);
}
srand((unsigned int) seed);
fprintf(stderr, "test_hash_table: starting...\n");
int const hash_table_exit = test_hash_table();
fprintf(stderr, "test_hash_table: done, exit code: %d\n", hash_table_exit);
/*fprintf(stderr, "test_splay_tree: starting...\n");
int const splay_tree_exit = test_splay_tree();
fprintf(stderr, "test_splay_tree: done, exit code: %d\n", splay_tree_exit);*/
fprintf(stderr, "test_sort: starting...\n");
int const sort_exit = test_sort();
fprintf(stderr, "test_sort: done, exit code: %d\n", sort_exit);
int const exit_code = (hash_table_exit < 0 || /*splay_tree_exit < 0 || */sort_exit < 0 ? -1 : 0);
fprintf(stderr, "test_all: done, exit code: %d\n", exit_code);
return exit_code;
}
bool test_sort_man(T sort, bool logEvents=false)
{
return test_sort(sort,logEvents);
}
void call_cpp_api(void)
{
test_sort();
}
