static int __init ll_init(void)
{
printk(KERN_ALERT "Hello, linked_lists\n");
test_stack();
print_processes_backwards();
return 0;
}
int main(int argc, char * argv[]) {
test_graph();
test_stack();
test_chaitin();
test_chaitin_spill();
return EXIT_SUCCESS;
}
static int __init stack_init(void)
{
printk("init stack module\n");
test_stack(4);
return 0;
}
void run_tests() {
test_entry_expansion();
test_table_expansion();
test_automaton_eval();
test_list();
test_bs_build();
test_stack();
test_queue();
}
int main(int argc, char* argv[])
{
test_list();
test_q();
test_stack();
return 0;
}
int main(int argc, char **argv) {
struct node *stack = NULL;
if(argc < 2) {
printf("call with more args\n");
exit(0);
}
test_stack(argc-1, argv+1);
test_auxappend(argc-1, argv+1);
}
int main() {
/* TESTS FOR STACK.C */
printf("Testing stack.c functions...\n");
printf(" stack_new\n");
printf(" push\n");
printf(" pop\n");
printf(" peek\n");
printf(" reverse\n");
assert(test_stack());
printf("All stack.c tests passed!\n");
printf("(* Note: all functions tested together, not individually *)\n\n");
}
int main(int argc, char** argv)
{
std::cout << "data_structures!" << std::endl;
test_stack();
test_array();
std::cout << "Press Enter to continue...";
std::cin.get();
return 0;
}
static void test_stack(unsigned int level)
{
int arr[1024];
int i;
if (level <= 0)
return;
for (i = 0; i < 1024; i++)
arr[i] = i * level;
test_stack(level - 1);
}
int main(int argc, char *argv[])
{
test_list();
test_dlist();
test_stack();
test_evaluate();
puts("##########################################");
puts("all tests have been completed!!");
puts("##########################################");
return 0;
}
bool test_all()
{
printf("Test Stack: %s\n", test_stack()?"PASS":"******");
printf("Test Queue: %s\n", test_queue()?"PASS":"******");
printf("Test List: %s\n", test_list()?"PASS":"******");
printf("Test MinHeap: %s\n",test_minheap()?"PASS":"******");
printf("Test MaxHeap: %s\n",test_maxheap()?"PASS":"******");
printf("Test RedBlack: %s\n", /*test_redblack()*/false?"PASS":"******");
printf("Test BST: %s\n", test_bst()?"PASS":"******");
printf("Test HashTable: %s\n",test_hashtable()?"PASS":"******");
printf("Test Tuple: %s\n",test_tuple()?"PASS":"******");
if(DEBUG)functional_tests();
return 1;
}
int main()
{
char value[10] = "test\n";
int status = AXIS2_SUCCESS;
axutil_env_t *env = NULL;
env = create_environment();
status = test_stack(env,value);
if(status != AXIS2_SUCCESS)
{
printf("The test failed");
}
axutil_env_free(env);
return 0;
}
int main(int argc, char *argv[])
{
printf("==== start\n");
if (sthread_init())
err(1, "sthread_init()");
printf("==== Basic sthread\n");
test_sthread();
test_sthread();
printf("==== Globals\n");
_global = 2;
test_global();
if (_global != 2)
errx(1, "global in master %d\n", _global);
test_global();
printf("==== Stack\n");
test_stack();
test_stack();
printf("==== smalloc\n");
test_smalloc();
printf("==== fd\n");
test_fd();
printf("==== syscall\n");
test_syscall();
printf("==== parallel\n");
test_parallel();
printf("==== end\n");
exit(0);
}
int main()
{
dcTest_initPlatform();
printf("Allocating ...\n");
printf("... W^X memory: ");
test_wx();
printf("... heap memory: ");
test_heap();
printf("... stack memory: ");
test_stack();
dcTest_deInitPlatform();
return 0;
}
int main(int argc, const char *argv[]) {
program_name = argv[0];
(void) argc;
test_card();
test_cursor();
test_deck();
test_gui();
test_frame();
test_game();
test_keyboard();
test_stack();
test_test_helper();
return(0);
}
int main()
{
dcTest_initPlatform();
signal(SIGSEGV, segv_handler);
printf("Allocating ...\n");
printf("... W^X memory: ");
test_wx();
printf("... heap memory: ");
test_heap();
printf("... stack memory: ");
test_stack();
dcTest_deInitPlatform();
return 0;
}
int main()
{
print_testname("Doubly Linked List");
test_doublylinkedlist();
print_testname("BST");
test_binarysearchtree();
print_testname("Undirected Graph");
test_undirectedgraph();
print_testname("Stack");
test_stack();
print_testname("Queue");
test_queue();
return 0;
}
int main()
#endif
{
tnet_startup();
#if RUN_TEST_LOOP
for(;;)
#endif
{
/* Print copyright information */
printf("Doubango Project\nCopyright (C) 2009 - 2010 Mamadou Diop \n\n");
#if RUN_TEST_ALL || RUN_TEST_MESSAGES
test_messages();
#endif
#if RUN_TEST_ALL || RUN_TEST_URI
test_uri();
#endif
#if RUN_TEST_ALL ||RUN_TEST_TRANSAC
test_transac();
#endif
#if RUN_TEST_ALL || RUN_TEST_STACK
test_stack();
#endif
#if RUN_TEST_ALL || RUN_TEST_IMS_AKA
test_imsaka();
#endif
}
tnet_cleanup();
return 0;
}
void stack_test( int loop )
{
// Create the stack
stack<int> test_stack( 5 );
for (int i = 0; i < loop; ++i)
{
// int add = rand() % loop;
// std::cout << i << " -> ";
test_stack.push( i );
}
// std::cout << '\n';
// std::cout << '\n';
// int * all = test_stack.all();
// for ( int i = test_stack.size() - 1; i >= 0 ; --i )
// {
// std::cout << all[ i ] << " -> ";
// }
// std::cout << '\n';
// delete [] all;
// for ( int i = 0; i < loop / 2; ++i )
// {
// // std::cout << "pop: " << * test_stack.peek() << '\n';
// test_stack.pop();
// }
// all = test_stack.all();
// for ( int i = 0; i < test_stack.size(); ++i )
// {
// std::cout << all[ i ] << " -> ";
// }
// std::cout << '\n';
// delete [] all;
}
int main()
{
test_stack();
return 0;
}
int main(int argc, char *argv[])
{
int ret = 0;
int do_stack_tests;
int do_sched_tests;
/* Initialize output routine */
output_init();
/* Test abilities */
do_sched_tests = (sysconf(_SC_THREAD_PRIORITY_SCHEDULING) > 0 ? 1 : 0);
do_stack_tests = (test_stack(NULL, 0) == 0 ? 1 : 0);
#if VERBOSE > 0
output
("Test starting\n Stack tests %s be executed.\n Sched tests %s be executed.\n",
do_stack_tests ? "will" : "won't",
do_sched_tests ? "will" : "won't");
#endif
/* Initialize thread attribute objects */
scenar_init();
for (sc = 0; sc < NSCENAR; sc++) {
#if VERBOSE > 0
output("-----\n");
output("Starting test with scenario (%i): %s\n", sc,
scenarii[sc].descr);
#endif
if (do_stack_tests) {
/* stack grow test */
/* We need the thread attribute to specify a minimal stack */
if ((scenarii[sc].altstack == 0)
&& (scenarii[sc].altsize == 1)) {
#if VERBOSE > 2
output("Processing stack grow test\n");
#endif
ret =
test_stack(&scenarii[sc].ta,
2 *
sysconf(_SC_THREAD_STACK_MIN));
if (ret == 0) {
if (scenarii[sc].guard == 2) {
FAILED
("Changing the stacksize after the thread was created changed the running thread stack size");
}
#if VERBOSE > 2
else
output
("We were able to overflow the stack, but the guard area is unknow or null\n");
#endif
}
if ((ret != 2) && (scenarii[sc].result == 1)) {
UNRESOLVED(-1,
"An error was expected but the thread creation succeeded");
}
#if VERBOSE > 2
if ((ret == 1)) {
output("Stack grow test passed\n");
}
if ((ret == 2) && (scenarii[sc].result == 2)) {
output
("Something went wrong -- we don't care in this case\n");
}
#endif
if ((ret == 2) && (scenarii[sc].result == 0)) {
UNRESOLVED(-1,
"An unexpected error occured\n");
}
/* Ok, set back the thread attribute object to a correct value */
ret =
pthread_attr_setstacksize(&scenarii[sc].ta,
sysconf
(_SC_THREAD_STACK_MIN));
if (ret != 0) {
UNRESOLVED(ret,
"Failed to set stacksize back");
}
}
/* stack decrease test */
if ((scenarii[sc].altstack == 0)
&& (scenarii[sc].altsize == 0)) {
#if VERBOSE > 2
output("Processing stack decrease test\n");
#endif
ret =
test_stack(&scenarii[sc].ta,
sysconf(_SC_THREAD_STACK_MIN));
if (ret == 1) {
FAILED
("Decreasing the stack size after thread is created had an influence on the thread");
}
if ((ret == 0) && (scenarii[sc].result == 1)) {
UNRESOLVED(-1,
"An error was expected but the thread creation succeeded");
}
if ((ret == 2) && (scenarii[sc].result == 0)) {
UNRESOLVED(-1,
"An unexpected error occured\n");
}
#if VERBOSE > 2
if (ret == 0)
output("Stack decrease test passed.\n");
else
output
("Something failed but we don't care here.\n");
#endif
}
}
/* if do_stack_tests */
if (do_sched_tests) {
/* Sched policy/param change test */
if (scenarii[sc].explicitsched != 0) { /* We need a specified policy */
pthread_t child;
int policy_ori, newpol_max;
struct sched_param param_ori, tmp;
testdata_t td;
#if VERBOSE > 2
output
("Processing sched policy/param change test\n");
#endif
/* Backup the scenario object */
ret =
pthread_attr_getschedpolicy(&
(scenarii
[sc].ta),
&policy_ori);
if (ret != 0) {
UNRESOLVED(ret,
"Unable to read sched policy from thread attribute");
}
ret =
pthread_attr_getschedparam(&
(scenarii
[sc].ta),
¶m_ori);
if (ret != 0) {
UNRESOLVED(ret,
"Unable to read sched param from thread attribute");
}
/* Initialize the barrier */
ret = pthread_barrier_init(&(td.bar), NULL, 2);
if (ret != 0) {
UNRESOLVED(ret,
"Unable to initialize the barrier");
}
/* Create a new thread with this scenario attribute */
ret =
pthread_create(&child, &(scenarii[sc].ta),
schedtest, &td);
if (ret != 0) {
if (scenarii[sc].result == 0) {
UNRESOLVED(ret,
"Failed to create a thread");
}
#if VERBOSE > 2
if (scenarii[sc].result == 2) {
output
("The thread creation failed -- we don't care\n");
}
if (scenarii[sc].result == 1) {
output
("The thread creation failed as expected\n");
}
#endif
} else { /* Thread created */
if (scenarii[sc].result == 1) {
UNRESOLVED(-1,
"The thread was created where an error was expected");
}
#if VERBOSE > 2
if (scenarii[sc].result == 2)
output("Thread is created\n");
#endif
/* sync 1 */
ret = pthread_barrier_wait(&(td.bar));
if ((ret != 0)
&& (ret !=
PTHREAD_BARRIER_SERIAL_THREAD))
{
UNRESOLVED(ret,
"Failed to synchronize on the barrier");
}
/* Check the new thread reports the attributes */
if (td.policy != policy_ori) {
FAILED
("The new thread does not report the scheluling policy that was specified");
}
if (td.param.sched_priority !=
param_ori.sched_priority) {
FAILED
("The new thread does not report the scheduling priority that was specified at creation");
}
/* Change the thread attribute object policy & param */
if (policy_ori == SCHED_RR) {
ret =
pthread_attr_setschedpolicy
(&(scenarii[sc].ta),
SCHED_FIFO);
newpol_max =
sched_get_priority_max
(SCHED_FIFO);
} else {
ret =
pthread_attr_setschedpolicy
(&(scenarii[sc].ta),
SCHED_RR);
newpol_max =
sched_get_priority_max
(SCHED_RR);
}
if (ret != 0) {
UNRESOLVED(ret,
"Failed to change the attribute object");
}
if (newpol_max ==
param_ori.sched_priority)
newpol_max--;
tmp.sched_priority = newpol_max;
ret =
pthread_attr_setschedparam(&
(scenarii
[sc].ta),
&tmp);
if (ret != 0) {
UNRESOLVED(ret,
"Failed to set the attribute sched param");
}
/* sync 2 */
ret = pthread_barrier_wait(&(td.bar));
if ((ret != 0)
&& (ret !=
PTHREAD_BARRIER_SERIAL_THREAD))
{
UNRESOLVED(ret,
"Failed to synchronize on the barrier");
}
/* sync 3 */
ret = pthread_barrier_wait(&(td.bar));
if ((ret != 0)
&& (ret !=
PTHREAD_BARRIER_SERIAL_THREAD))
{
UNRESOLVED(ret,
"Failed to synchronize on the barrier");
}
/* Check if the thread saw the change (should not) */
if (td.policy != policy_ori) {
FAILED
("The new thread does not report the scheluling policy that was specified");
}
if (td.param.sched_priority !=
param_ori.sched_priority) {
FAILED
("The new thread does not report the scheduling priority that was specified at creation");
}
/* Check what we can see for the child thread from here */
ret =
pthread_getschedparam(child,
&(td.policy),
&(td.param));
if (ret != 0) {
UNRESOLVED(ret,
"Failed to read child thread policy / param");
}
if (td.policy != policy_ori) {
FAILED
("The child thread does not report the scheduling policy that was specified at creation");
}
if (td.param.sched_priority !=
param_ori.sched_priority) {
FAILED
("The child thread does not report the scheduling priority that was specified at creation");
}
/* Restore the thread attribute */
ret =
pthread_attr_setschedpolicy(&
(scenarii
[sc].ta),
policy_ori);
if (ret != 0) {
UNRESOLVED(ret,
"Unable to read sched policy from thread attribute");
}
ret =
pthread_attr_setschedparam(&
(scenarii
[sc].ta),
¶m_ori);
if (ret != 0) {
UNRESOLVED(ret,
"Unable to read sched param from thread attribute");
}
/* sync 4 */
ret = pthread_barrier_wait(&(td.bar));
if ((ret != 0)
&& (ret !=
PTHREAD_BARRIER_SERIAL_THREAD))
{
UNRESOLVED(ret,
"Failed to synchronize on the barrier");
}
/* sync 5 */
ret = pthread_barrier_wait(&(td.bar));
if ((ret != 0)
&& (ret !=
PTHREAD_BARRIER_SERIAL_THREAD))
{
UNRESOLVED(ret,
"Failed to synchronize on the barrier");
}
/* check if the thread attribute reports a change (should not) */
ret =
pthread_attr_getschedpolicy(&
(scenarii
[sc].ta),
&
(td.policy));
if (ret != 0) {
UNRESOLVED(ret,
"Unable to read sched policy from thread attribute");
}
ret =
pthread_attr_getschedparam(&
(scenarii
[sc].ta),
&
(td.param));
if (ret != 0) {
UNRESOLVED(ret,
"Unable to read sched param from thread attribute");
}
if (td.policy != policy_ori) {
FAILED
("The child thread does not report the scheduling policy that was specified at creation");
}
if (td.param.sched_priority !=
param_ori.sched_priority) {
FAILED
("The child thread does not report the scheduling priority that was specified at creation");
}
/* Wait for the sem and join eventually the thread */
do {
ret =
sem_wait(&scenarii[sc].sem);
}
while ((ret == -1) && (errno == EINTR));
if (ret == -1) {
UNRESOLVED(errno,
"Failed to wait for the semaphore");
}
if (scenarii[sc].detached == 0) {
ret = pthread_join(child, NULL);
if (ret != 0) {
UNRESOLVED(ret,
"Unable to join a thread");
}
}
#if VERBOSE > 2
output
("Sched policy/param change test passed\n");
#endif
} /* thread created */
}
/* We could also test if the inheritsched does not influence the new thread */
} /* if do_sched_tests */
}
scenar_fini();
#if VERBOSE > 0
output("-----\n");
output("All test data destroyed\n");
output("Test PASSED\n");
#endif
PASSED;
}
int
main (void)
{
atexit (check_called);
char st1[32768];
stack_t stack_before, stack_after;
sigaltstack (NULL, &stack_before);
puts ("making contexts");
if (getcontext (&ctx[1]) != 0)
{
if (errno == ENOSYS)
{
back_in_main = 1;
exit (0);
}
printf ("%s: getcontext: %m\n", __FUNCTION__);
exit (1);
}
test_stack (1, 2, 3, 4);
/* Play some tricks with this context. */
if (++global == 1)
if (setcontext (&ctx[1]) != 0)
{
printf ("%s: setcontext: %m\n", __FUNCTION__);
exit (1);
}
if (global != 2)
{
printf ("%s: 'global' not incremented twice\n", __FUNCTION__);
exit (1);
}
ctx[1].uc_stack.ss_sp = st1;
ctx[1].uc_stack.ss_size = sizeof st1;
ctx[1].uc_link = &ctx[0];
{
ucontext_t tempctx = ctx[1];
makecontext (&ctx[1], (void (*) (void)) f1, 4, 1, 2, 3, -4);
/* Without this check, a stub makecontext can make us spin forever. */
if (memcmp (&tempctx, &ctx[1], sizeof ctx[1]) == 0)
{
puts ("makecontext was a no-op, presuming not implemented");
return 0;
}
}
if (getcontext (&ctx[2]) != 0)
{
printf ("%s: second getcontext: %m\n", __FUNCTION__);
exit (1);
}
ctx[2].uc_stack.ss_sp = st2;
ctx[2].uc_stack.ss_size = sizeof st2;
ctx[2].uc_link = &ctx[1];
makecontext (&ctx[2], f2, 0);
puts ("swapping contexts");
if (swapcontext (&ctx[0], &ctx[2]) != 0)
{
printf ("%s: swapcontext: %m\n", __FUNCTION__);
exit (1);
}
puts ("back at main program");
back_in_main = 1;
sigaltstack (NULL, &stack_after);
if (was_in_f1 == 0)
{
puts ("didn't reach f1");
exit (1);
}
if (was_in_f2 == 0)
{
puts ("didn't reach f2");
exit (1);
}
/* Check sigaltstack state is not clobbered as in BZ #16629. */
if (stack_before.ss_sp != stack_after.ss_sp)
{
printf ("stack ss_sp mismatch: %p %p\n",
stack_before.ss_sp, stack_after.ss_sp);
exit (1);
}
if (stack_before.ss_size != stack_after.ss_size)
{
printf ("stack ss_size mismatch: %zd %zd\n",
stack_before.ss_size, stack_after.ss_size);
exit (1);
}
puts ("test succeeded");
return 0;
}
int
main (void)
{
char st1[32768];
puts ("making contexts");
if (getcontext (&ctx[1]) != 0)
{
if (errno == ENOSYS)
exit (0);
printf ("%s: getcontext: %m\n", __FUNCTION__);
exit (1);
}
test_stack (1, 2, 3, 4);
/* Play some tricks with this context. */
if (++global == 1)
if (setcontext (&ctx[1]) != 0)
{
printf ("%s: setcontext: %m\n", __FUNCTION__);
exit (1);
}
if (global != 2)
{
printf ("%s: 'global' not incremented twice\n", __FUNCTION__);
exit (1);
}
ctx[1].uc_stack.ss_sp = st1;
ctx[1].uc_stack.ss_size = sizeof st1;
ctx[1].uc_link = &ctx[0];
{
ucontext_t tempctx = ctx[1];
makecontext (&ctx[1], (void (*) (void)) f1, 4, 1, 2, 3, -4);
/* Without this check, a stub makecontext can make us spin forever. */
if (memcmp (&tempctx, &ctx[1], sizeof ctx[1]) == 0)
{
puts ("makecontext was a no-op, presuming not implemented");
return 0;
}
}
if (getcontext (&ctx[2]) != 0)
{
printf ("%s: second getcontext: %m\n", __FUNCTION__);
exit (1);
}
ctx[2].uc_stack.ss_sp = st2;
ctx[2].uc_stack.ss_size = sizeof st2;
ctx[2].uc_link = &ctx[1];
makecontext (&ctx[2], f2, 0);
puts ("swapping contexts");
if (swapcontext (&ctx[0], &ctx[2]) != 0)
{
printf ("%s: swapcontext: %m\n", __FUNCTION__);
exit (1);
}
puts ("back at main program");
if (was_in_f1 == 0)
{
puts ("didn't reach f1");
exit (1);
}
if (was_in_f2 == 0)
{
puts ("didn't reach f2");
exit (1);
}
puts ("test succeeded");
return 0;
}
