Пример #1
0
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;
}
Пример #2
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();
}
Пример #3
0
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;
}
Пример #4
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();
}
Пример #5
0
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);
}
Пример #6
0
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();
}
Пример #8
0
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;
}
Пример #10
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();
}
Пример #11
0
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;
}
Пример #12
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();
}
Пример #13
0
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;
     }
Пример #14
0
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;
}
Пример #15
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;
}
Пример #16
0
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();
}
Пример #18
0
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();
}
Пример #19
0
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();
}
Пример #21
0
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();
}
Пример #23
0
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();
}
Пример #24
0
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);
}
Пример #25
0
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;
}
Пример #26
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;
}
Пример #27
0
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;
}
Пример #28
0
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();
}
Пример #29
0
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();
}
Пример #30
0
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;
}