int lime_init(void) { inits++; if (inits > 1) return 0; if (inits < 1) return -1; if (pthread_mutex_init(&global_lock, NULL)) abort(); eina_init(); static const float GAMMA = 2.2; int result; int i; for (i = 0; i < 256; i++) { result = (int)(pow(i/255.0, GAMMA)*65535.0 + 0.5); lime_g2l[i] = (unsigned short)result; } for (i = 0; i < 65536; i++) { result = (int)(pow(i/65535.0, 1/GAMMA)*255.0 + 0.5); lime_l2g[i] = (unsigned char)result; } lime_filters_init(); return 0; }
END_TEST START_TEST(eina_inarray_test_reverse) { Eina_Inarray *array; int i; eina_init(); array = eina_inarray_new(sizeof(short), 1); fail_unless(array != NULL); for (i = 0; i < numbers_count; i++) { short val = i; eina_inarray_push(array, &val); } eina_inarray_reverse(array); for (i = 0; i < numbers_count; i++) { short *member = eina_inarray_nth(array, i); fail_unless(*member == (numbers_count - i - 1)); } eina_inarray_free(array); eina_shutdown(); }
int main(int argc, char **argv) { Eina_Benchmark *test; unsigned int i; if (argc != 2) return -1; _mempool_init(); eina_init(); for (i = 0; etc[i].bench_case; ++i) { test = eina_benchmark_new(etc[i].bench_case, argv[1]); if (!test) continue; etc[i].build(test); eina_benchmark_run(test); eina_benchmark_free(test); } eina_bench_e17(); eina_shutdown(); _mempool_shutdown(); return 0; }
END_TEST START_TEST(eina_bezier_test_angle) { Eina_Bezier b; double angle; eina_init(); eina_bezier_values_set(&b, 1, 1, 3, 1, 5, 1, 7, 1); angle = eina_bezier_angle_at(&b, 0.5); fail_if(angle != 0); eina_bezier_values_set(&b, 1, 2, 1, 4, 1, 6, 1, 8); angle = eina_bezier_angle_at(&b, 0.5); fail_if(floor(angle) != 90); eina_shutdown(); }
int main(int argc, char **argv) { Eina_Value vtv, vtz; struct timeval tv; struct timezone tz; char *s; eina_init(); eina_value_setup(&vtv, EINA_VALUE_TYPE_TIMEVAL); eina_value_setup(&vtz, &TZ_TYPE); gettimeofday(&tv, &tz); eina_value_set(&vtv, tv); eina_value_set(&vtz, tz); s = eina_value_to_string(&vtv); printf("time: %s\n", s); free(s); s = eina_value_to_string(&vtz); printf("timezone: %s\n", s); free(s); eina_value_flush(&vtz); eina_value_flush(&vtv); }
EAPI int estate_init(void) { if (++_init_count == 1) { if (EINA_UNLIKELY(!eina_init())) { EINA_LOG_CRIT("Failed to init Eina"); return --_init_count; } _estate_log_dom = eina_log_domain_register("estate", EINA_COLOR_WHITE); if (EINA_UNLIKELY(_estate_log_dom < 0)) { EINA_LOG_CRIT("Failed to create log domain"); eina_shutdown(); return --_init_count; } #if 0 ESTATE_EVENT_ENTERER = ecore_event_type_new(); ESTATE_EVENT_EXITER = ecore_event_type_new(); ESTATE_EVENT_TRANSITION = ecore_event_type_new(); #endif } return _init_count; }
int main(int argc, char **argv) { const char* strings[] = { "helo", "hera", "starbuck", "kat", "boomer", "hotdog", "longshot", "jammer", "crashdown", "hardball", "duck", "racetrack", "apolo", "husker", "freaker", "skulls", "bulldog", "flat top", "hammerhead", "gonzo" }; char **str, **str2; Eina_Inarray *iarr; int i; eina_init(); iarr = eina_inarray_new(sizeof(char *), 0); for (i = 0; i < 20; i++){ str = (char **)(&strings[i]); eina_inarray_push(iarr, str); } printf("Inline array of strings:\n"); EINA_INARRAY_FOREACH(iarr, str2) printf("string: %s(pointer: %p)\n", *str2, str2); eina_inarray_free(iarr); eina_shutdown(); }
int main(void) { Eina_List *fonts; Font_Entry *fe; Msg_Index_List *msg = NULL; int size; eina_init(); _evas_cserve2_debug_log_dom = eina_log_domain_register ("evas_cserve2_debug", EINA_COLOR_BLUE); if (!_server_connect()) { ERR("Could not connect to server."); return -1; } while (!msg) msg = _server_read(&size); _shared_index_print(msg, size); _debug_msg_send(); fonts = _debug_msg_read(); EINA_LIST_FREE(fonts, fe) { _font_entry_print(fe); _font_entry_free(fe); }
int main(void) { FILE *file; long size; eina_init(); //1. Open XML File file = fopen("exia.xml", "rb"); if (!file) return 0; fseek(file, 0, SEEK_END); size = ftell(file); fseek(file, 0, SEEK_SET); //2. Read XML File char *buffer = malloc(size); if (!buffer) { fclose(file); return 0; } fread(buffer, 1, size, file); //3. Start Parsing XML eina_simple_xml_parse(buffer, size, EINA_FALSE, _xml_tag_parse_cb, NULL); fclose(file); free(buffer); return 0; }
END_TEST #ifdef HAVE_ICONV START_TEST(str_convert) { char *utf8 = "\xc3\xa9\xc3\xa1\xc3\xba\xc3\xad\xc3\xa8\xc3\xa0\xc3\xb9\xc3\xac\xc3\xab\xc3\xa4\xc3\xbc\xc3\xaf"; char *utf16 = "\xe9\x0\xe1\x0\xfa\x0\xed\x0\xe8\x0\xe0\x0\xf9\x0\xec\x0\xeb\x0\xe4\x0\xfc\x0\xef\x0"; char *ret; size_t ret_sz; int i; eina_init(); ret = eina_str_convert("UTF-8", "UTF-16LE", utf8); fail_if(ret == NULL); for( i=0; i<24; i++) fail_if(ret[i] != utf16[i]); free(ret); ret = eina_str_convert_len("UTF-8", "UTF-16LE", utf8, 24, &ret_sz); fail_if(ret == NULL); fail_if(ret_sz != 24); for( i=0; i<24; i++) fail_if(ret[i] != utf16[i]); free(ret); eina_shutdown(); }
int main(void) { double done; eina_init(); ecore_init(); ecore_con_init(); eina_log_domain_level_set("ecore_con", EINA_LOG_LEVEL_ERR); eina_log_domain_level_set("eina", EINA_LOG_LEVEL_ERR); counter = eina_counter_new("client"); eina_counter_start(counter); done = ecore_time_get(); ecore_job_add(_spawn, NULL); /* set event handler for server connect */ ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_add, NULL); ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_del, NULL); /* start client */ ecore_main_loop_begin(); eina_counter_stop(counter, 1); printf("\nTime elapsed for %i connections: %f seconds\n%s", NUM_CLIENTS, ecore_time_get() - done, eina_counter_dump(counter)); return 0; }
END_TEST START_TEST(str_join_len) { char dst[9]; size_t ret; size_t ds = (sizeof(dst) / sizeof(char)); eina_init(); dst[0] = '\0'; ret = eina_str_join_len(dst, ds, '#', "ab", 2, "cde", 3); fail_if(ret != 6); fail_if(strcmp(dst, "ab#cde") != 0); ret = eina_str_join_len(dst, ds, '#', "abcdefghi", 9, "cde", 3); fail_if(ret != 13); fail_if(strcmp(dst, "abcdefgh") != 0); ret = eina_str_join_len(dst, ds, '#', "abcdefgh", 8, "cde", 3); fail_if(ret != 12); fail_if(strcmp(dst, "abcdefgh") != 0); ret = eina_str_join_len(dst, ds, '#', "abcd", 4, "efgh", 4); fail_if(ret != 9); fail_if(strcmp(dst, "abcd#efg") != 0); eina_shutdown(); }
int main(void) { Eina_List *btl = NULL, *l; char buf[4096]; Bt *bt; int cols[6] = { 0 }, len, i; eina_init(); while (fgets(buf, sizeof(buf) - 1, stdin)) { btl = bt_append(btl, buf); } EINA_LIST_FOREACH(btl, l, bt) { len = strlen(bt->bin_dir); if (len > cols[0]) cols[0] = len; len = strlen(bt->bin_name); if (len > cols[1]) cols[1] = len; len = strlen(bt->file_dir); if (len > cols[2]) cols[2] = len; len = strlen(bt->file_name); if (len > cols[3]) cols[3] = len; snprintf(buf, sizeof(buf), "%i", bt->line); len = strlen(buf); if (len > cols[4]) cols[4] = len; len = strlen(bt->func_name); if (len > cols[5]) cols[5] = len; }
int main(int argc, char **argv) { Eina_Strbuf *buf; eina_init(); buf = eina_strbuf_new(); eina_strbuf_append_length(buf, "buffe", 5); eina_strbuf_append_char(buf, 'r'); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_insert_escaped(buf, "my ", 0); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_reset(buf); eina_strbuf_append_escaped(buf, "my buffer"); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_reset(buf); eina_strbuf_append_printf(buf, "%s%c", "buffe", 'r'); eina_strbuf_insert_printf(buf, " %s: %d", 6, "length", eina_strbuf_length_get(buf)); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_remove(buf, 0, 7); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_replace_all(buf, "length", "size"); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_free(buf); eina_shutdown(); return 0; }
/** * Set up connections, signal handlers, sockets etc. * @return 1 or greater on success, 0 otherwise * * This function sets up all singal handlers and the basic event loop. If it * succeeds, 1 will be returned, otherwise 0 will be returned. * * @code * #include <Ecore.h> * * int main(int argc, char **argv) * { * if (!ecore_init()) * { * printf("ERROR: Cannot init Ecore!\n"); * return -1; * } * ecore_main_loop_begin(); * ecore_shutdown(); * } * @endcode */ EAPI int ecore_init(void) { if (++_ecore_init_count != 1) return _ecore_init_count; #ifdef HAVE_LOCALE_H setlocale(LC_CTYPE, ""); #endif /* if (strcmp(nl_langinfo(CODESET), "UTF-8")) { WRN("Not a utf8 locale!"); } */ #ifdef HAVE_EVIL if (!evil_init()) return --_ecore_init_count; #endif if (!eina_init()) goto shutdown_evil; _ecore_log_dom = eina_log_domain_register("Ecore", ECORE_DEFAULT_LOG_COLOR); if (_ecore_log_dom < 0) { EINA_LOG_ERR("Ecore was unable to create a log domain."); goto shutdown_log_dom; } if (getenv("ECORE_FPS_DEBUG")) _ecore_fps_debug = 1; if (_ecore_fps_debug) _ecore_fps_debug_init(); _ecore_main_loop_init(); _ecore_signal_init(); _ecore_exe_init(); _ecore_thread_init(); _ecore_glib_init(); _ecore_job_init(); _ecore_time_init(); #if HAVE_MALLINFO if (getenv("ECORE_MEM_STAT")) { _ecore_memory_pid = getpid(); ecore_animator_add(_ecore_memory_statistic, NULL); } #endif #if defined(GLIB_INTEGRATION_ALWAYS) if (_ecore_glib_always_integrate) ecore_main_loop_glib_integrate(); #endif return _ecore_init_count; shutdown_log_dom: eina_shutdown(); shutdown_evil: #ifdef HAVE_EVIL evil_shutdown(); #endif return --_ecore_init_count; }
int main(int argc, char **argv) { Eina_List *list = NULL; Eina_List *l; void *list_data; eina_init(); list = eina_list_append(list, eina_stringshare_add("calvin")); list = eina_list_append(list, eina_stringshare_add("Leoben")); list = eina_list_append(list, eina_stringshare_add("D'Anna")); list = eina_list_append(list, eina_stringshare_add("Simon")); list = eina_list_append(list, eina_stringshare_add("Doral")); list = eina_list_append(list, eina_stringshare_add("Six")); list = eina_list_append(list, eina_stringshare_add("Sharon")); for(l = list; l; l = eina_list_next(l)) printf("%s\n", (char*)l->data); for(l = eina_list_last(list); l; l = eina_list_prev(l)) printf("%s\n", (char*)eina_list_data_get(l)); EINA_LIST_FREE(list, list_data) eina_stringshare_del(list_data); eina_shutdown(); return 0; }
END_TEST START_TEST(eina_rectangle_intersect) { Eina_Rectangle r1, r2, r3, r4, rd; fail_if(!eina_init()); EINA_RECTANGLE_SET(&r1, 10, 10, 50, 50); EINA_RECTANGLE_SET(&r2, 20, 20, 20, 20); EINA_RECTANGLE_SET(&r3, 0, 0, 10, 10); EINA_RECTANGLE_SET(&r4, 30, 30, 50, 50); rd = r1; fail_if(eina_rectangle_intersection(&rd, &r3)); fail_if(!eina_rectangle_intersection(&rd, &r2)); fail_if(rd.x != r2.x || rd.y != r2.y || rd.w != r2.w || rd.h != r2.h); rd = r1; fail_if(!eina_rectangle_intersection(&rd, &r4)); fail_if(rd.x != 30 || rd.y != 30 || rd.w != 30 || rd.h != 30); eina_shutdown(); }
END_TEST /* eina_binbuf_manage_new_length and eina_binbuf_manage_read_only_new_length * are deprecated */ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" START_TEST(binbuf_manage_simple) { Eina_Binbuf *buf; const char *_cbuf = "12\0 456 78\0 abcthis is some more random junk here!"; const unsigned char *cbuf = (const unsigned char *) _cbuf; size_t size = sizeof(cbuf) - 1; /* We don't care about the real NULL */ unsigned char *alloc_buf = malloc(size); memcpy(alloc_buf, cbuf, size); eina_init(); buf = eina_binbuf_manage_new_length(alloc_buf, size); fail_if(!buf); fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); fail_if(size != eina_binbuf_length_get(buf)); eina_binbuf_append_length(buf, cbuf, size); fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); fail_if(memcmp(eina_binbuf_string_get(buf) + size, cbuf, size)); fail_if(2 * size != eina_binbuf_length_get(buf)); eina_binbuf_free(buf); eina_shutdown(); }
int emqtt_init(void) { if (++_emqtt_init_count != 1) return _emqtt_init_count; if (!eina_init ()) return --_emqtt_init_count; _emqtt_log_dom_global = eina_log_domain_register("emqtt", EMQTT_DEFAULT_LOG_COLOR); if (_emqtt_log_dom_global < 0) { EINA_LOG_ERR("Enna-Server Can not create a general log domain."); goto shutdown_eina; } else INF("EMqtt Init"); if (!ecore_init ()) goto shutdown_eina; return _emqtt_init_count; shutdown_eina: eina_shutdown (); return --_emqtt_init_count; }
END_TEST START_TEST(binbuf_remove) { Eina_Binbuf *buf; const unsigned char cbuf[] = "12\0 456 78\0 abcthis is some more random junk here!"; size_t size = sizeof(cbuf) - 1; /* We don't care about the real NULL */ eina_init(); buf = eina_binbuf_new(); fail_if(!buf); eina_binbuf_append_length(buf, cbuf, size); fail_if(size != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 0, 4); fail_if(size - 4 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 8, 1000); fail_if(8 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 7, eina_binbuf_length_get(buf)); fail_if(7 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 2, 4); fail_if(5 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 4, 1); fail_if(5 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 0, eina_binbuf_length_get(buf)); fail_if(0 != eina_binbuf_length_get(buf)); eina_binbuf_free(buf); eina_shutdown(); }
END_TEST START_TEST(eina_fp_sin) { Eina_F32p32 fc; Eina_F32p32 fl; Eina_F32p32 step; Eina_F32p32 fresult; double dc; double dresult; double delta; fail_if(!eina_init()); fl = eina_f32p32_scale(EINA_F32P32_PI, 4); step = eina_f32p32_div(fl, eina_f32p32_int_from(2048)); for (fc = 0; fc < fl; fc += step) { fresult = eina_f32p32_sin(fc); dc = eina_f32p32_double_to(fc); dresult = sin(dc); delta = fabs(dresult - eina_f32p32_double_to(fresult)); fail_if(delta > 0.005); } eina_shutdown(); }
END_TEST START_TEST(binbuf_manage_simple) { Eina_Binbuf *buf; const char *_cbuf = "12\0 456 78\0 abcthis is some more random junk here!"; const unsigned char *cbuf = (const unsigned char *) _cbuf; size_t size = sizeof(cbuf) - 1; /* We don't care about the real NULL */ unsigned char *alloc_buf = malloc(size); memcpy(alloc_buf, cbuf, size); eina_init(); buf = eina_binbuf_manage_new_length(alloc_buf, size); fail_if(!buf); fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); fail_if(size != eina_binbuf_length_get(buf)); eina_binbuf_append_length(buf, cbuf, size); fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); fail_if(memcmp(eina_binbuf_string_get(buf) + size, cbuf, size)); fail_if(2 * size != eina_binbuf_length_get(buf)); eina_binbuf_free(buf); eina_shutdown(); }
END_TEST START_TEST(eina_bezier_test_length) { Eina_Bezier b; double length; eina_init(); eina_bezier_values_set(&b, 1, 1, 3, 1, 5, 1, 7, 1); length = eina_bezier_length_get(&b); fail_if(floor(length) != 6); eina_bezier_values_set(&b, 1, 1, 1, 1, 1, 1, 1, 1); length = eina_bezier_length_get(&b); fail_if(length != 0); eina_shutdown(); }
END_TEST START_TEST(eina_hash_extended) { Eina_Hash *hash = NULL; int i; fail_if(eina_init() != 2); hash = eina_hash_string_djb2_new(NULL); fail_if(hash == NULL); fail_if(eina_hash_direct_add(hash, "42", "42") != EINA_TRUE); for (i = 43; i < 3043; ++i) { char *tmp = malloc(10); fail_if(!tmp); eina_convert_itoa(i, tmp); fail_if(eina_hash_direct_add(hash, tmp, tmp) != EINA_TRUE); } fail_if(eina_hash_find(hash, "42") == NULL); eina_hash_free(hash); fail_if(eina_shutdown() != 1); }
int main() { eina_init(); ecore_con_init(); /*no new function because there's no free function*/ static zrpc_con zcon; /*set up host/port*/ // zcon.host = "www.domain.com"; // zcon.port = 4444; zcon.host = "10.10.10.6"; zcon.port = 65534; // char *username = "******"; // char *password = "******"; char *username = "******"; char *password = "******"; /*all zrpc functions take a minimum of 3 arguments: * 1) a zcon handle * 2) a zrpc_network_cb function * 3) a (void*) to pass to the callback */ zrpc_User_login(username, password, &zcon, (void*)post, &zcon); /*start the ecore job server*/ ecore_main_loop_begin(); return 0; }
int escarg_init(void) { if (++_escarg_init_count != 1) return _escarg_init_count; if (!eina_init()) { fprintf(stderr, "Escarg can not initialize Eina\n"); return --_escarg_init_count; } _escarg_log_dom_global = eina_log_domain_register("escarg", EINA_COLOR_RED); if (_escarg_log_dom_global < 0) { EINA_LOG_ERR("Escarg can not create a general log domain."); goto shutdown_eina; } DBG("Successfully started"); return _escarg_init_count; shutdown_eina: eina_shutdown(); return --_escarg_init_count; }
static Eina_Bool _ecore_imf_xim_init(void) { eina_init(); _ecore_imf_xim_log_dom = eina_log_domain_register("ecore_imf_xim", NULL); if (_ecore_imf_xim_log_dom < 0) { EINA_LOG_ERR("Could not register log domain: ecore_imf_xim"); return EINA_FALSE; } DBG(" "); if (!ecore_x_init(NULL)) { eina_shutdown(); return EINA_FALSE; } ecore_imf_module_register(&xim_info, xim_imf_module_create, xim_imf_module_exit); return EINA_TRUE; }
END_TEST START_TEST(eina_binshare_small) { char buf[4]; int i; eina_init(); for (i = 1; i < 3; i++) { const char *t0, *t1; int j; for (j = 0; j < i; j++) { char c; for (c = 'a'; c <= 'z'; c++) buf[j] = c; } buf[i] = '\0'; t0 = eina_binshare_add_length(buf, i); t1 = eina_binshare_add_length(buf, i); fail_if(t0 == NULL); fail_if(t1 == NULL); fail_if(t0 != t1); fail_if(memcmp(t0, buf, i) != 0); eina_binshare_del(t0); eina_binshare_del(t1); } eina_shutdown(); }
int main() { Ecore_Con_Server *svr; eina_init(); ecore_init(); ecore_con_init(); /* comment if not using gnutls */ gnutls_global_set_log_level(9); gnutls_global_set_log_function(tls_log_func); /* to use a PEM certificate with TLS and SSL3, uncomment the lines below */ if (!(svr = ecore_con_server_add(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_TLS | ECORE_CON_USE_SSL3 | ECORE_CON_LOAD_CERT, "127.0.0.1", 8080, NULL))) /* to use simple tcp with ssl/tls, use this line */ // if (!ecore_con_server_add(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_SSL3, "127.0.0.1", 8080, NULL)) exit(1); ecore_con_ssl_server_cert_add(svr, "server.pem"); ecore_con_ssl_server_privkey_add(svr, "server.pem"); /* set event handler for client connect */ ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_add, NULL); /* set event handler for client disconnect */ ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_del, NULL); /* set event handler for receiving client data */ ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb)_data, NULL); /* start server */ ecore_main_loop_begin(); }
EAPI int eolian_init(void) { const char *log_dom = "eolian"; if (_eolian_init_counter > 0) return ++_eolian_init_counter; eina_init(); _eolian_log_dom = eina_log_domain_register(log_dom, EINA_COLOR_LIGHTBLUE); if (_eolian_log_dom < 0) { EINA_LOG_ERR("Could not register log domain: %s", log_dom); return EINA_FALSE; } eina_log_timing(_eolian_log_dom, EINA_LOG_STATE_STOP, EINA_LOG_STATE_INIT); INF("Init"); _eolian_prefix = eina_prefix_new(NULL, eolian_init, "EOLIAN", "eolian", NULL, "", "", PACKAGE_DATA_DIR, ""); if (!_eolian_prefix) { ERR("Could not initialize the Eolian prefix."); return EINA_FALSE; } database_init(); eo_lexer_init(); return ++_eolian_init_counter; }