int main(){ struct gameState g_s; int a_cards[10] = {adventurer, council_room, minion, great_hall, cutpurse, mine, gardens, sea_hag, tribute, smithy}; int test_result1, real_result; printf("\n*****Card test for great hall*****\n"); initializeGame(2, a_cards, 3, &g_s); test_result1 = numHandCards(&g_s); real_result = cardEffect(great_hall, 0, 0, 0, &g_s, 0, 0); if(!assert_result(real_result, 0)) printf("FAILURE 1: This card cannot be executed\n"); else{ printf("PASS 1: This card can be executed\n"); real_result = numHandCards(&g_s); if(!assert_result(real_result, test_result1+1-1)) printf("Failure 2: The effact of this card is incorrect\n"); else printf("PASS 2: The effact of this card is correct\n"); } printf("*********************************\n"); return 0; }
resource_service_fn_t *rs_simple_create(void *arg, tbx_inip_file_t *kf, char *section) { service_manager_t *ess = (service_manager_t *)arg; rs_simple_priv_t *rss; resource_service_fn_t *rs; //** Create the new RS list tbx_type_malloc_clear(rss, rs_simple_priv_t, 1); assert_result(apr_pool_create(&(rss->mpool), NULL), APR_SUCCESS); apr_thread_mutex_create(&(rss->lock), APR_THREAD_MUTEX_DEFAULT, rss->mpool); apr_thread_mutex_create(&(rss->update_lock), APR_THREAD_MUTEX_DEFAULT, rss->mpool); apr_thread_cond_create(&(rss->cond), rss->mpool); rss->rid_mapping = apr_hash_make(rss->mpool); rss->mapping_updates = apr_hash_make(rss->mpool); rss->ds = lookup_service(ess, ESS_RUNNING, ESS_DS); rss->da = lookup_service(ess, ESS_RUNNING, ESS_DA); //** Set the resource service fn ptrs tbx_type_malloc_clear(rs, resource_service_fn_t, 1); rs->priv = rss; rs->get_rid_config = rss_get_rid_config; rs->register_mapping_updates = rss_mapping_register; rs->unregister_mapping_updates = rss_mapping_unregister; rs->translate_cap_set = rss_translate_cap_set; rs->query_new = rs_query_base_new; rs->query_dup = rs_query_base_dup; rs->query_add = rs_query_base_add; rs->query_append = rs_query_base_append; rs->query_destroy = rs_query_base_destroy; rs->query_print = rs_query_base_print; rs->query_parse = rs_query_base_parse; rs->get_rid_value = rs_simple_get_rid_value; rs->data_request = rs_simple_request; rs->destroy_service = rs_simple_destroy; rs->type = RS_TYPE_SIMPLE; //** This is the file to use for loading the RID table rss->fname = tbx_inip_get_string(kf, section, "fname", NULL); rss->dynamic_mapping = tbx_inip_get_integer(kf, section, "dynamic_mapping", 0); rss->check_interval = tbx_inip_get_integer(kf, section, "check_interval", 300); rss->check_timeout = tbx_inip_get_integer(kf, section, "check_timeout", 60); rss->min_free = tbx_inip_get_integer(kf, section, "min_free", 100*1024*1024); //** Set the modify time to force a change rss->modify_time = 0; //** Load the RID table assert_result(_rs_simple_refresh(rs), 0); //** Launch the check thread tbx_thread_create_assert(&(rss->check_thread), NULL, rss_check_thread, (void *)rs, rss->mpool); return(rs); }
void gop_dummy_init() { //** Make the variables assert_result(apr_pool_create(&gd_pool, NULL), APR_SUCCESS); assert_result(apr_thread_mutex_create(&gd_lock, APR_THREAD_MUTEX_DEFAULT, gd_pool), APR_SUCCESS); assert_result(apr_thread_cond_create(&gd_cond, gd_pool), APR_SUCCESS); gd_stack = new_stack(); //** and launch the thread thread_create_assert(&gd_thread, NULL, gd_thread_func, NULL, gd_pool); }
void checkSmity(struct gameState *g_s){ int test_result, real_result; test_result = numHandCards(g_s); real_result = cardEffect(smithy, 0, 0, 0, g_s, 0, 0); if(!assert_result(real_result, 0)) error_list[0]++; real_result = numHandCards(g_s); if(!assert_result(real_result, test_result+3-1)) error_list[1]++; }
void *gop_control_new(void *arg, int size) { gop_control_t *shelf; int i; type_malloc_clear(shelf, gop_control_t, size); for (i=0; i<size; i++) { assert_result(apr_thread_mutex_create(&(shelf[i].lock), APR_THREAD_MUTEX_DEFAULT,_opque_pool), APR_SUCCESS); assert_result(apr_thread_cond_create(&(shelf[i].cond), _opque_pool), APR_SUCCESS); } return((void *)shelf); }
void init_opque_system() { log_printf(15, "init_opque_system: counter=%d\n", _opque_counter); if (atomic_inc(_opque_counter) == 0) { //** Only init if needed assert_result(apr_pool_create(&_opque_pool, NULL), APR_SUCCESS); _gop_control = new_pigeon_coop("gop_control", 50, sizeof(gop_control_t), NULL, gop_control_new, gop_control_free); gop_dummy_init(); atomic_init(); } }
gop_thread_pool_context_t *gop_tp_context_create(char *tp_name, int min_threads, int max_threads, int max_recursion_depth) { // char buffer[1024]; gop_thread_pool_context_t *tpc; apr_interval_time_t dt; int i; log_printf(15, "count=%d\n", _tp_context_count); tbx_type_malloc_clear(tpc, gop_thread_pool_context_t, 1); if (tbx_atomic_inc(_tp_context_count) == 0) { apr_pool_create(&_tp_pool, NULL); apr_thread_mutex_create(&_tp_lock, APR_THREAD_MUTEX_DEFAULT, _tp_pool); thread_pool_stats_init(); } if (thread_local_depth_key == NULL) apr_threadkey_private_create(&thread_local_depth_key,_thread_pool_destructor, _tp_pool); tpc->pc = gop_hp_context_create(&_tp_base_portal); //** Really just used for the submit default_thread_pool_config(tpc); if (min_threads > 0) tpc->min_threads = min_threads; if (max_threads > 0) tpc->max_threads = max_threads + 1; //** Add one for the recursion depth starting offset being 1 tpc->recursion_depth = max_recursion_depth + 1; //** The min recusion normally starts at 1 so just slap an extra level and we don't care about 0|1 starting location tpc->max_concurrency = tpc->max_threads - tpc->recursion_depth; if (tpc->max_concurrency <= 0) { tpc->max_threads += 5 - tpc->max_concurrency; //** MAke sure we have at least 5 threads for work tpc->max_concurrency = tpc->max_threads - tpc->recursion_depth; log_printf(0, "Specified max threads and recursion depth don't work. Adjusting max_threads=%d\n", tpc->max_threads); } dt = tpc->min_idle * 1000000; assert_result(apr_thread_pool_create(&(tpc->tp), tpc->min_threads, tpc->max_threads, _tp_pool), APR_SUCCESS); apr_thread_pool_idle_wait_set(tpc->tp, dt); apr_thread_pool_threshold_set(tpc->tp, 0); tpc->name = (tp_name == NULL) ? NULL : strdup(tp_name); tbx_atomic_set(tpc->n_ops, 0); tbx_atomic_set(tpc->n_completed, 0); tbx_atomic_set(tpc->n_started, 0); tbx_atomic_set(tpc->n_submitted, 0); tbx_atomic_set(tpc->n_running, 0); tbx_type_malloc(tpc->overflow_running_depth, int, tpc->recursion_depth); tbx_type_malloc(tpc->reserve_stack, tbx_stack_t *, tpc->recursion_depth); for (i=0; i<tpc->recursion_depth; i++) { tpc->overflow_running_depth[i] = -1; tpc->reserve_stack[i] = tbx_stack_new(); } return(tpc); }
/* * Class: sun_awt_windows_ThemeReader * Method: setWindowTheme * Signature: (Ljava/lang/String;)V */ JNIEXPORT void JNICALL Java_sun_awt_windows_ThemeReader_setWindowTheme (JNIEnv *env, jclass klass, jstring subAppName) { LPCTSTR str = NULL; if (subAppName != NULL) { str = (LPCTSTR) JNU_GetStringPlatformChars(env, subAppName, NULL); } // We need to set the Window theme on the same theme that we opened it with. HRESULT hres = SetWindowTheme(AwtToolkit::GetInstance().GetHWnd(), str, NULL); assert_result(hres, env); if (subAppName != NULL) { JNU_ReleaseStringPlatformChars(env, subAppName, str); } }
tbx_ns_t *tbx_ns_new() { tbx_ns_t *ns = (tbx_ns_t *)malloc(sizeof(tbx_ns_t)); if (ns == NULL) { log_printf(0, "new_netstream: Failed malloc!!\n"); abort(); } assert_result(apr_pool_create(&(ns->mpool), NULL), APR_SUCCESS); apr_thread_mutex_create(&(ns->read_lock), APR_THREAD_MUTEX_DEFAULT,ns->mpool); apr_thread_mutex_create(&(ns->write_lock), APR_THREAD_MUTEX_DEFAULT,ns->mpool); _ns_init(ns, 0); ns->id = ns->cuid = -1; return(ns); }
int main(){ struct gameState g_s; int a_cards[10] = {adventurer, council_room, minion, great_hall, cutpurse, mine, gardens, sea_hag, tribute, smithy}; int real_result; printf("\n****Unit test for fullDeckCount()*****\n"); initializeGame(2, a_cards, 3, &g_s); real_result = fullDeckCount(0, 0, &g_s); if(!assert_result(real_result, 0)) printf("FAILURE 1: The function is wrong\n"); else printf("PASS 1: The function is correct\n"); printf("*********************************\n"); return 0; }
void run_server() { zctx_t *ctx; void *socket; int i, n, nclient; char buf[256]; char data[256]; char client[256]; ctx = new_context(); socket = new_socket(ctx, ZMQ_ROUTER); // socket = new_socket(ctx, ZMQ_REP); assert_result(socket_bind(socket, host), 0); // assert_result(zmq_bind(socket, host), 0); log_printf(0, "my identity=%s\n", zsocket_identity(socket)); i = 0; for (;;) { log_printf(0, "Waiting %d\n", i); nclient = zmq_recv(socket, client, sizeof(client), 0); client[nclient] = 0; log_printf(0, "From %s [%d]\n", client, nclient); n = zmq_recv(socket, buf, sizeof(buf), 0); buf[n] = 0; if (n != 0) log_printf(0, "Missing EMPTY frame! buf=%s\n", buf); n = zmq_recv(socket, buf, sizeof(buf), 0); buf[n] = 0; log_printf(0, "Got %s\n", buf); zmq_send(socket, client, nclient, ZMQ_SNDMORE); zmq_send(socket, NULL, 0, ZMQ_SNDMORE); snprintf(data, sizeof(buf), "(%s) World %d", buf, i); zmq_send(socket, data, strlen(data)+1, 0); i++; } destroy_context(ctx); }
tbx_network_t *network_init() { int i; tbx_network_t *net; //**** Allocate space for the data structures *** net = (tbx_network_t *)malloc(sizeof(tbx_network_t));FATAL_UNLESS(net != NULL); net->used_ports = 0; net->accept_pending = 0; net->monitor_index = 0; assert_result(apr_pool_create(&(net->mpool), NULL), APR_SUCCESS); apr_thread_mutex_create(&(net->ns_lock), APR_THREAD_MUTEX_DEFAULT,net->mpool); apr_thread_cond_create(&(net->cond), net->mpool); net->used_ports = 0; for (i=0; i<NETWORK_MON_MAX; i++) { net->nm[i].port = -1; } return(net); }
portal_context_t *create_hportal_context(portal_fn_t *imp) { portal_context_t *hpc; //log_printf(1, "create_hportal_context: start\n"); hpc = (portal_context_t *)malloc(sizeof(portal_context_t)); assert(hpc != NULL); memset(hpc, 0, sizeof(portal_context_t)); assert_result(apr_pool_create(&(hpc->pool), NULL), APR_SUCCESS); hpc->table = apr_hash_make(hpc->pool); assert(hpc->table != NULL); //log_printf(15, "create_hportal_context: hpc=%p hpc->table=%p\n", hpc, hpc->table); apr_thread_mutex_create(&(hpc->lock), APR_THREAD_MUTEX_DEFAULT, hpc->pool); hpc->fn = imp; hpc->next_check = time(NULL); hpc->count = 0; tbx_ns_timeout_set(&(hpc->dt), 1, 0); return(hpc); }
/* * Class: sun_awt_windows_ThemeReader * Method: closeTheme * Signature: (J)V */ JNIEXPORT void JNICALL Java_sun_awt_windows_ThemeReader_closeTheme (JNIEnv *env, jclass klass, jlong theme) { HRESULT hres = CloseThemeData((HTHEME)theme); assert_result(hres, env); }
host_portal_t *create_hportal(portal_context_t *hpc, void *connect_context, char *hostport, int min_conn, int max_conn, apr_time_t dt_connect) { host_portal_t *hp; log_printf(15, "create_hportal: hpc=%p\n", hpc); tbx_type_malloc_clear(hp, host_portal_t, 1); assert_result(apr_pool_create(&(hp->mpool), NULL), APR_SUCCESS); char host[sizeof(hp->host)]; int port; char *hp2 = strdup(hostport); char *bstate; int fin; host[0] = '\0'; strncpy(host, tbx_stk_string_token(hp2, HP_HOSTPORT_SEPARATOR, &bstate, &fin), sizeof(host)-1); host[sizeof(host)-1] = '\0'; port = atoi(bstate); free(hp2); log_printf(15, "create_hportal: hostport: %s host=%s port=%d min=%d max=%d dt=" TT "\n", hostport, host, port, min_conn, max_conn, dt_connect); strncpy(hp->host, host, sizeof(hp->host)-1); hp->host[sizeof(hp->host)-1] = '\0'; //** Check if we can resolve the host's IP address char in_addr[6]; if (tbx_dnsc_lookup(host, in_addr, NULL) != 0) { log_printf(1, "create_hportal: Can\'t resolve host address: %s:%d\n", host, port); hp->invalid_host = 0; // hp->invalid_host = 1; } else { hp->invalid_host = 0; } hp->port = port; snprintf(hp->skey, sizeof(hp->skey), "%s", hostport); hp->connect_context = hpc->fn->dup_connect_context(connect_context); hp->context = hpc; hp->min_conn = min_conn; hp->max_conn = max_conn; hp->dt_connect = dt_connect; hp->sleeping_conn = 0; hp->workload = 0; hp->executing_workload = 0; hp->cmds_processed = 0; hp->n_conn = 0; hp->conn_list = tbx_stack_new(); hp->closed_que = tbx_stack_new(); hp->que = tbx_stack_new(); hp->direct_list = tbx_stack_new(); hp->pause_until = 0; hp->stable_conn = max_conn; hp->closing_conn = 0; hp->failed_conn_attempts = 0; hp->successful_conn_attempts = 0; hp->abort_conn_attempts = hpc->abort_conn_attempts; apr_thread_mutex_create(&(hp->lock), APR_THREAD_MUTEX_DEFAULT, hp->mpool); apr_thread_cond_create(&(hp->cond), hp->mpool); return(hp); }
resource_service_fn_t *rs_remote_server_create(void *arg, tbx_inip_file_t *fd, char *section) { service_manager_t *ess = (service_manager_t *)arg; resource_service_fn_t *rs; rs_remote_server_priv_t *rsrs; rs_create_t *rs_create; mq_command_table_t *ctable; char *stype, *ctype; if (section == NULL) section = "rs_remote_server"; tbx_type_malloc_clear(rs, resource_service_fn_t, 1); tbx_type_malloc_clear(rsrs, rs_remote_server_priv_t, 1); rs->priv = (void *)rsrs; //** Make the locks and cond variables assert_result(apr_pool_create(&(rsrs->mpool), NULL), APR_SUCCESS); apr_thread_mutex_create(&(rsrs->lock), APR_THREAD_MUTEX_DEFAULT, rsrs->mpool); apr_thread_cond_create(&(rsrs->cond), rsrs->mpool); rsrs->pending = tbx_stack_new(); memset(&(rsrs->my_map_version), 0, sizeof(rsrs->my_map_version)); memset(&(rsrs->notify_map_version), 0, sizeof(rsrs->notify_map_version)); rsrs->notify_map_version.lock = rsrs->lock; rsrs->notify_map_version.cond = rsrs->cond; //** Get the host name we bind to rsrs->hostname= tbx_inip_get_string(fd, section, "address", NULL); //** Start the child RS. The update above should have dumped a RID config for it to load stype = tbx_inip_get_string(fd, section, "rs_local", NULL); if (stype == NULL) { //** Oops missing child RS log_printf(0, "ERROR: Mising child RS section=%s key=rs_local!\n", section); tbx_log_flush(); free(stype); abort(); } //** and load it ctype = tbx_inip_get_string(fd, stype, "type", RS_TYPE_SIMPLE); rs_create = lookup_service(ess, RS_SM_AVAILABLE, ctype); rsrs->rs_child = (*rs_create)(ess, fd, stype); if (rsrs->rs_child == NULL) { log_printf(1, "ERROR loading child RS! type=%s section=%s\n", ctype, stype); tbx_log_flush(); abort(); } free(ctype); free(stype); //** Get the MQC rsrs->mqc = lookup_service(ess, ESS_RUNNING, ESS_MQ); assert(rsrs->mqc != NULL); //** Make the server portal rsrs->server_portal = mq_portal_create(rsrs->mqc, rsrs->hostname, MQ_CMODE_SERVER); ctable = mq_portal_command_table(rsrs->server_portal); mq_command_set(ctable, RSR_GET_RID_CONFIG_KEY, RSR_GET_RID_CONFIG_SIZE, rs, rsrs_rid_config_cb); mq_command_set(ctable, RSR_GET_UPDATE_CONFIG_KEY, RSR_GET_UPDATE_CONFIG_SIZE, rs, rsrs_rid_config_cb); mq_command_set(ctable, RSR_ABORT_KEY, RSR_ABORT_SIZE, rs, rsrs_abort_cb); mq_portal_install(rsrs->mqc, rsrs->server_portal); //** Launch the config changes thread tbx_thread_create_assert(&(rsrs->monitor_thread), NULL, rsrs_monitor_thread, (void *)rs, rsrs->mpool); //** Set up the fn ptrs. This is just for syncing the rid configuration and state //** so very little is implemented rs->destroy_service = rs_remote_server_destroy; rs->type = RS_TYPE_REMOTE_SERVER; return(rs); }
int main(int argc, char **argv) { int64_t block_size, buf_size, state_offset; int64_t fsize1, fsize2, max_size, cpos, len, bad_bytes, bad_groups; int start_option, i, state; char *fname1, *fname2; char *buf1, *buf2; FILE *fd1, *fd2; block_size = 64 *1024; buf_size = 20 *1024*1024; if (argc < 3) { printf("\n"); printf("ldiff [-b block_size] [-s buffer_size] file1 file2\n"); printf(" -b block_size Block size for matching to cache page boundaries. Defaults to " I64T ". Can use units.\n", block_size); printf(" -s buffer_size Buffer size used in the comparison. This is divided in 1/2 for each buffer. Defaults to " I64T ". Cant use units.\n", buf_size); printf("\n"); return(1); } //*** Parse the args i=1; if (argc > 1) { do { start_option = i; if (strcmp(argv[i], "-b") == 0) { //** Block size i++; block_size = string_get_integer(argv[i]); i++; } else if (strcmp(argv[i], "-s") == 0) { //** Buffer size i++; buf_size = string_get_integer(argv[i]); i++; } } while ((start_option < i) && (i<argc)); } if ((argc-i) < 2) { printf("Missing filenames!\n"); return(1); } //** Open the files and get their sizes fname1 = argv[i]; fname2 = argv[i+1]; fd1 = fopen(fname1, "r"); assert(fd1 != NULL); fd2 = fopen(fname2, "r"); assert(fd2 != NULL); fseek(fd1, 0, SEEK_END); fseek(fd2, 0, SEEK_END); fsize1 = ftell(fd1); fsize2 = ftell(fd2); fseek(fd1, 0, SEEK_SET); fseek(fd2, 0, SEEK_SET); //** Print a summary of options printf("File 1: %s (" I64T " bytes)\n", fname1, fsize1); printf("File 2: %s (" I64T " bytes)\n", fname2, fsize2); if (fsize1 != fsize2) printf("WARNING: File sizes differ!!!!!\n"); printf("Block size: " I64T "\n", block_size); printf("Buffer size: " I64T "\n", buf_size); buf_size /= 2; //** It's split between the 2 buffers type_malloc(buf1, char, buf_size); type_malloc(buf2, char, buf_size); max_size = (fsize1 > fsize2) ? fsize2 : fsize1; printf("\n"); printf("Printing comparision breakdown -- Single byte matches are suppressed (max_size=" I64T ")\n", max_size); state = 0; state_offset = 0; bad_bytes = bad_groups = 0; for (cpos=0; cpos < max_size; cpos += buf_size) { len = ((cpos+buf_size) < max_size) ? buf_size : max_size - cpos; assert_result(fread(buf1, 1, len, fd1), len); assert_result(fread(buf2, 1, len, fd2), len); compare_buffers(buf1, buf2, len, cpos, &bad_bytes, &bad_groups, block_size, &state, &state_offset, max_size); } printf("\n"); printf("Bad bytes: " I64T " Bad groups: " I64T "\n", bad_bytes, bad_groups); free(buf1); free(buf2); fclose(fd1); fclose(fd2); i = ((bad_bytes > 0) || (fsize1 != fsize2)) ? 1 : 0; return(i); }
int main(int argc, char **argv) { int start_option, i, watch, summary, base; rs_mapping_notify_t notify, me; apr_time_t dt; char *config; //printf("argc=%d\n", argc); if (argc < 2) { printf("\n"); printf("lio_rs LIO_COMMON_OPTIONS [-w] [-b2 | -b10] [-s | -f]\n"); lio_print_options(stdout); printf(" -w - Watch for RID configuration changes. Press ^C to exit\n"); printf(" -b2 - Use powers of 2 for units(default)\n"); printf(" -b10 - Use powers of 10 for units\n"); printf(" -s - Print a RID space usage summary\n"); printf(" -f - Print the full RID configuration\n"); return(1); } lio_init(&argc, &argv); watch = 0; summary = 0; base = 1024; i=1; do { start_option = i; if (strcmp(argv[i], "-w") == 0) { //** Watch for any RID changes i++; watch = 1; } else if (strcmp(argv[i], "-s") == 0) { //** Print space summary instead of full conifg i++; summary = 1; } else if (strcmp(argv[i], "-b2") == 0) { //** base-2 units i++; base = 1024; } else if (strcmp(argv[i], "-b10") == 0) { //** base-10 units i++; base = 1000; } } while ((start_option < i) && (i<argc)); //** Make the APR stuff assert_result(apr_pool_create(&mpool, NULL), APR_SUCCESS); apr_thread_mutex_create(&lock, APR_THREAD_MUTEX_DEFAULT, mpool); apr_thread_cond_create(&cond, mpool); //if (watch == 1) { // printf("Sleeping for 60s\n"); fflush(stdout); // sleep(60); // printf("Woken up\n"); fflush(stdout); //} memset(¬ify, 0, sizeof(notify)); notify.lock = lock; notify.cond = cond; me = notify; me.map_version = 1; //** This triggers the initial load rs_register_mapping_updates(lio_gc->rs, ¬ify); dt = apr_time_from_sec(1); do { //** Check for an update apr_thread_mutex_lock(lock); if (watch == 1) apr_thread_cond_timedwait(notify.cond, notify.lock, dt); i = ((me.map_version != notify.map_version) || (me.status_version != notify.status_version)) ? 1 : 0; me = notify; apr_thread_mutex_unlock(lock); if (i != 0) { config = rs_get_rid_config(lio_gc->rs); printf("Map Version: %d Status Version: %d\n", me.map_version, me.status_version); printf("--------------------------------------------------------------------------------------------------\n"); if (config == NULL) { printf("ERROR NULL config!\n"); } else if (summary == 1) { print_rid_summary(config, base); } else { printf("%s", config); } printf("--------------------------------------------------------------------------------------------------\n"); if (config != NULL) free(config); } } while (watch == 1); info_printf(lio_ifd, 5, "BEFORE unregister\n"); tbx_info_flush(lio_ifd); rs_unregister_mapping_updates(lio_gc->rs, ¬ify); info_printf(lio_ifd, 5, "AFTER unregister\n"); tbx_info_flush(lio_ifd); //** Cleanup apr_pool_destroy(mpool); // info_printf(lio_ifd, 5, "AFTER shutdown\n"); tbx_info_flush(lio_ifd); lio_shutdown(); return(0); }