/** * @brief Saves Etk's config to disk * @return Returns ETK_TRUE on a successful save, ETK_FALSE otherwise. */ Etk_Bool etk_config_save(void) { Eet_File *ef; char buf[PATH_MAX]; char *home; Etk_Bool ret; home = getenv("HOME"); if (!home) return 0; snprintf(buf, sizeof(buf), "%s/.e/etk/config.eet", home); ef = eet_open(buf, EET_FILE_MODE_WRITE); if (!ef) return 0; ret = eet_data_write(ef, _etk_config_ver_edd, "config/version", _etk_config->version, 1); if (!ret) ETK_WARNING("Problem saving config!"); ret = eet_data_write(ef, _etk_config_gen_edd, "config/general", _etk_config->general, 1); if (!ret) ETK_WARNING("Problem saving config/stickies!"); eet_close(ef); return ret; }
int ex_config_write(Extrackt *ex) { Eet_File *ef; char buf[PATH_MAX]; char *home; int ret; Eina_List *l; home = getenv("HOME"); if(!home) return 0; snprintf(buf, sizeof(buf), "%s/.e/extrackt/config.eet", home); ef = eet_open(buf, EET_FILE_MODE_WRITE); if(!ef) return 0; ret = eet_data_write(ef, _ex_config_version_edd, "config/version", ex->config.version, 1); if(!ret) DEBUG(_("Problem saving config!")); ret = eet_data_write(ef, _ex_config_cd_edd, "config/cd", ex->config.cd, 1); if(!ret) DEBUG(_("Problem saving config!")); ret = eet_data_write(ef, _ex_config_cddb_edd, "config/cddb", ex->config.cddb, 1); if(!ret) DEBUG(_("Problem saving config!")); for(l = ex->config.rippers; l; l = l->next) { Ex_Config_Exe *ripper; char *buf; int size; ripper = l->data; size = strlen("config/rippers/") + strlen(ripper->name) + 1; buf = E_NEW(size, char); snprintf(buf, size, "config/rippers/%s", ripper->name); ret = eet_data_write(ef, _ex_config_exe_edd, buf, ripper, 1); if(!ret) DEBUG(_("Problem saving config!")); } ret = eet_data_write(ef, _ex_config_encode_edd, "config/encode", ex->config.encode, 1); if(!ret) DEBUG(_("Problem saving config!")); eet_close(ef); return ret; }
static Eina_Bool _ephoto_on_config_save(void *data) { Ephoto *ephoto = data; Eet_File *ef; char buf[4096], buf2[4096]; snprintf(buf, sizeof(buf), "%s/.config/ephoto/ephoto.cfg", getenv("HOME")); snprintf(buf2, sizeof(buf2), "%s.tmp", buf); ef = eet_open(buf2, EET_FILE_MODE_WRITE); if (!ef) goto save_end; eet_data_write(ef, edd, "config", ephoto->config, 1); if (eet_close(ef)) goto save_end; if (!ecore_file_mv(buf2, buf)) goto save_end; INF("Config saved"); save_end: ecore_file_unlink(buf2); if (save_timer) { ecore_timer_del(save_timer); save_timer = NULL; } return ECORE_CALLBACK_CANCEL; }
void config_flush(void) { Eet_File *cf; char path[PATH_MAX]; if (!config) return; snprintf(path, sizeof(path), "%s/%s", efreet_config_home_get(), "jesus.eet"); cf = eet_open(path, EET_FILE_MODE_WRITE); if (!cf) { printf("Failed to open config file"); } if (!eet_data_write(cf, edd, CONFIG_KEY, config, 0)) { printf("Failed to write config file"); } eet_close(cf); }
void Config::saveStateCache() { Eet_File *ef; std::string file = Utils::getCacheFile("iostates.cache"); std::string tmp = file + "_tmp"; ConfigStateCache *cache; cache = new ConfigStateCache; cache->version = CONFIG_STATES_CACHE_VERSION; cache->states = cache_states; ef = eet_open(tmp.c_str(), EET_FILE_MODE_WRITE); if (!ef) { cWarning() << "Could not open iostates.cache for write !"; delete cache; return; } Eina_Bool ret = eet_data_write(ef, edd_cache, "calaos/states/cache", cache, EINA_TRUE); eet_close(ef); delete cache; if (ret) { ecore_file_unlink(file.c_str()); ecore_file_mv(tmp.c_str(), file.c_str()); } cInfo() << "State cache file written successfully (" << file << ")"; }
static Eina_Bool config_save(Eet_Data_Descriptor *descriptor, const char *filename, const char *section, const void *data) { Eet_File *ef; FILE *f; char buffer[PATH_MAX]; int i; /* human readable version */ snprintf(buffer, PATH_MAX, "%s.%s", filename, section); f = fopen(buffer, "w"); if (!f) { fprintf(stderr, "Not able to open human readable config file.\n"); goto on_error; } /* save the configuration */ snprintf(buffer, PATH_MAX, "%s.eet", filename); ef = eet_open(buffer, EET_FILE_MODE_READ_WRITE); if (!ef) { fprintf(stderr, "Not able to open config file for read write mode.\n"); goto on_error; } if (!eet_data_write(ef, descriptor, section, data, 1)) { fprintf(stderr, "Can't write data inside the config file.\n"); goto on_write_error; } if (!eet_data_dump(ef, section, invert_fputs, f)) { fprintf(stderr, "Can't dump section `%s`.\n"); goto on_write_error; } eet_close(ef); sleep(2); fclose(f); return EINA_TRUE; on_write_error: eet_close(ef); snprintf(buffer, PATH_MAX, "%s.eet", filename); unlink(buffer); on_error: if (f) { fclose(f); snprintf(buffer, PATH_MAX, "%s.%s", filename, section); unlink(buffer); } return EINA_FALSE; }
int source_fontmap_save(Eet_File *ef, Eina_List *font_list) { Edje_Font_List fl; fl.list = font_list; return eet_data_write(ef, _font_list_edd, "edje_source_fontmap", &fl, compress_mode); }
/* Write the input method configuration to the file */ EAPI int e_intl_input_method_config_write(Eet_File *imc_file, E_Input_Method_Config *imc) { int ok = 0; if (imc_file) { ok = eet_data_write(imc_file, _e_intl_input_method_config_edd, "imc", imc, 0); } return ok; }
/** * @brief Save the connection associated to an essid in the configuration file * @param file the configuration file * @param c the connection * @return Returns 1 if success, else 0 */ int _exalt_eet_wireless_conn_save(const char*file, Exalt_Connection* c) { Eet_Data_Descriptor* edd; Eet_File* f; int res; edd = exalt_conn_edd_new(); f = eet_open(file, EET_FILE_MODE_READ_WRITE); if(!f) f = eet_open(file, EET_FILE_MODE_WRITE); res=eet_data_write(f, edd,exalt_conn_get_essid(c), c, 0); EXALT_ASSERT(res!=0); eet_close(f); eet_data_descriptor_free(edd); return res; }
/** * @brief Save a Exalt_Eth_Save structure in the configuration file * @param file the configuration file * @param s the Exalt_Eth_Save strucuture * @param udi the hal udi of the interface * @return Returns 1 if success, else 0 */ int _exalt_eet_eth_save(const char* file, Exalt_Eth_Save* s, const char* udi) { Eet_Data_Descriptor *edd; Eet_File* f; int res; edd = _exalt_eth_save_edd_new(); f = eet_open(file, EET_FILE_MODE_READ_WRITE); if(!f) f = eet_open(file, EET_FILE_MODE_WRITE); res=eet_data_write(f, edd,udi, s, 0); EXALT_ASSERT(res!=0); eet_close(f); eet_data_descriptor_free(edd); return res; }
static Eina_Bool _my_conf_save(const My_Conf_Type *my_conf, const char *filename) { char tmp[PATH_MAX]; Eet_File *ef; Eina_Bool ret; unsigned int i, len; struct stat st; len = eina_strlcpy(tmp, filename, sizeof(tmp)); if (len + 12 >= (int)sizeof(tmp)) { fprintf(stderr, "ERROR: file name is too big: %s\n", filename); return EINA_FALSE; } i = 0; do { snprintf(tmp + len, 12, ".%u", i); i++; } while (stat(tmp, &st) == 0); ef = eet_open(tmp, EET_FILE_MODE_WRITE); if (!ef) { fprintf(stderr, "ERROR: could not open '%s' for write\n", tmp); return EINA_FALSE; } ret = eet_data_write (ef, _my_conf_descriptor, MY_CONF_FILE_ENTRY, my_conf, EINA_TRUE); eet_close(ef); if (ret) { unlink(filename); rename(tmp, filename); } return ret; } /* _my_conf_save */
void ems_config_save(void) { Eet_File *file; FILE *fp; file = eet_open(ems_config_tmp_filename_get(), EET_FILE_MODE_READ_WRITE); eet_data_write(file, conf_edd, "config", ems_config, EINA_FALSE); printf("save to : %s\n", ems_config_filename_get()); fp = fopen(ems_config_filename_get(), "w"); if (!fp) goto error; eet_data_dump(file, "config", _dump_cb, fp); fclose(fp); error: eet_close(file); }
void write_histogram_to_file(char * output_file, Eina_Hash *map_histo) { Eet_File *ef; histogram_cache_t *cache_histo; printf("Writing cache map with %i entries\n" , eina_hash_population(map_histo)); unlink(output_file); cache_histo = malloc(sizeof(histogram_cache_t)); cache_histo->map_histo = map_histo; ef = eet_open(output_file, EET_FILE_MODE_WRITE); eet_data_write(ef, _histogram_cache_descriptor , CACHE_FILE_ENTRY, cache_histo, EINA_TRUE); eet_close(ef); free(cache_histo); }
/* * @brief save the list of interfaces * @param l the list * @param file the configuration file */ void waiting_iface_save(const Boot_Process_List* l, const char* file) { Eet_Data_Descriptor* edd; Eet_File* f; EXALT_ASSERT_RETURN_VOID(l!=NULL); EXALT_ASSERT_RETURN_VOID(file!=NULL); edd = waiting_iface_edd_new(); f = eet_open(file, EET_FILE_MODE_READ_WRITE); if(!f) { f = eet_open(file, EET_FILE_MODE_WRITE); } eet_data_write(f, edd,"boot process interface list", l, 0); eet_close(f); eet_data_descriptor_free(edd); }
Eina_Bool session_save(Session *session, const char *filename) { Eet_File *ef; Eina_Bool ret; if (filename) session->__eet_filename = eina_stringshare_add(filename); else if (session->__eet_filename) filename = session->__eet_filename; else return EINA_FALSE; ef = eet_open(filename, EET_FILE_MODE_READ_WRITE); if (!ef) { fprintf(stderr, "ERROR: could not open '%s' for write\n", filename); return EINA_FALSE; } ret = !!eet_data_write(ef, _session_descriptor, SESSION_ENTRY, session, EINA_TRUE); eet_close(ef); return ret; }
Eina_Bool fav_save(Fav *fav, const char *filename) { Eet_File *ef; Eina_Bool ret; if (filename) fav->__eet_filename = eina_stringshare_add(filename); else if (fav->__eet_filename) filename = fav->__eet_filename; else return EINA_FALSE; ef = eet_open(filename, EET_FILE_MODE_READ_WRITE); if (!ef) { fprintf(stderr, "ERROR: could not open '%s' for write\n", filename); return EINA_FALSE; } ret = !!eet_data_write(ef, _fav_descriptor, FAV_ENTRY, fav, EINA_TRUE); eet_close(ef); return ret; }
Eina_Bool config_save(Config *config, const char *filename) { Eet_File *ef; Eina_Bool ret; if (filename) config->__eet_filename = eina_stringshare_add(filename); else if (config->__eet_filename) filename = config->__eet_filename; else return EINA_FALSE; ef = eet_open(filename, EET_FILE_MODE_READ_WRITE); if (!ef) { fprintf(stderr, "ERROR: could not open '%s' for write\n", filename); return EINA_FALSE; } ret = !!eet_data_write(ef, _config_descriptor, CONFIG_ENTRY, config, EINA_TRUE); eet_close(ef); return ret; }
static void _eli_highscore_write(const char * game) { Eli_Highscore hiscore; Eet_File * file; hiscore.entries = eli_highscore_get(game); if (!hiscore.entries) return; if (ecore_file_exists(eet_file_name)) { file = eet_open(eet_file_name, EET_FILE_MODE_READ_WRITE); if (!file) fprintf(stderr, "Could not open file %s!\n", eet_file_name); } else { file = eet_open(eet_file_name, EET_FILE_MODE_WRITE); if (!file) fprintf(stderr, "Could not create file %s\n!", eet_file_name); } if (file) { eet_data_write(file, edd_hiscore, game, &hiscore, 1); eet_close(file); } }
int main(int argc, char **argv) { Edje_Part_Collection_Directory_Entry *ce; Old_Edje_File *oef; Edje_File *nef; Eina_Iterator *it; Eet_File *ef; setlocale(LC_NUMERIC, "C"); ecore_app_no_system_modules(); if (!eina_init()) return -1; _edje_cc_log_dom = eina_log_domain_register ("edje_convert", EDJE_CC_DEFAULT_LOG_COLOR); if (_edje_cc_log_dom < 0) { EINA_LOG_ERR("Enable to create a log domain."); exit(-1); } eet_init(); progname = argv[0]; if (argc > 2 || argc < 2 || !strcmp(argv[1], "-h")) { main_help(); return 0; } _edje_edd_old_init(); _edje_edd_init(); ef = eet_open(argv[1], EET_FILE_MODE_READ_WRITE); if (!ef) { EINA_LOG_ERR("Unable to open `%s'.", argv[1]); return -1; } oef = eet_data_read(ef, _edje_edd_old_edje_file, "edje_file"); if (!oef) { EINA_LOG_ERR("Unable to get edje_file section from old file format, are you sure it's an old file ?"); return -1; } nef = _edje_file_convert(ef, oef); _edje_file_set(nef); /* convert old structure to new one */ it = eina_hash_iterator_data_new(nef->collection); EINA_ITERATOR_FOREACH(it, ce) { Old_Edje_Part_Collection *opc; Edje_Part_Collection *npc; char buf[1024]; int bytes = 0; snprintf(buf, sizeof (buf), "collections/%i", ce->id); opc = eet_data_read(ef, _edje_edd_old_edje_part_collection, buf); if (!opc) { EINA_LOG_ERR("Unable to find collection `%s'[%i] in `%s'.", ce->entry, ce->id, argv[1]); return -1; } npc = _edje_collection_convert(ef, ce, opc); snprintf(buf, sizeof (buf), "edje/collections/%i", ce->id); bytes = eet_data_write(ef, _edje_edd_edje_part_collection, buf, npc, 1); if (bytes <= 0) { EINA_LOG_ERR("Unable to save `%s' in section `%s' of `%s'.", ce->entry, buf, argv[1]); return -1; } }
static int cache_add(const char *path, const char *file_id, int priority EINA_UNUSED, int *changed) { Efreet_Desktop *desk; char *ext; INF("FOUND: %s", path); if (file_id) INF(" (id): %s", file_id); ext = strrchr(path, '.'); if (!ext || (strcmp(ext, ".desktop") && strcmp(ext, ".directory"))) return 1; desk = efreet_desktop_new(path); if (desk) INF(" OK"); else INF(" FAIL"); if (!desk) return 1; if (!desk->eet) { /* This file isn't in cache */ *changed = 1; INF(" NEW"); } else if (ecore_file_mod_time(desk->orig_path) != desk->load_time) { efreet_desktop_free(desk); *changed = 1; desk = efreet_desktop_uncached_new(path); if (desk) INF(" CHANGED"); else INF(" NO UNCACHED"); } if (!desk) return 1; if (file_id && old_file_ids && !eina_hash_find(old_file_ids->hash, file_id)) { *changed = 1; INF(" NOT IN UTILS"); } if (!eina_hash_find(paths, desk->orig_path)) { if (!eet_data_write(ef, edd, desk->orig_path, desk, 0)) return 0; eina_hash_add(paths, desk->orig_path, (void *)1); } /* TODO: We should check priority, and not just hope we search in right order */ /* TODO: We need to find out if prioritized file id has changed because of * changed search order. */ if (!desk->hidden && desk->type == EFREET_DESKTOP_TYPE_APPLICATION && file_id && !eina_hash_find(file_ids, file_id)) { Eina_List *l; char *data; Efreet_Cache_Array_String *array; #define ADD_LIST(list, hash) \ EINA_LIST_FOREACH((list), l, data) \ { \ array = eina_hash_find((hash), data); \ if (!array) \ array = NEW(Efreet_Cache_Array_String, 1); \ array->array = realloc(array->array, sizeof (char *) * (array->array_count + 1)); \ array->array[array->array_count++] = desk->orig_path; \ eina_hash_set((hash), data, array); \ } #define ADD_ELEM(elem, hash) \ if ((elem)) \ { \ data = (elem); \ array = eina_hash_find((hash), data); \ if (!array) \ array = NEW(Efreet_Cache_Array_String, 1); \ array->array = realloc(array->array, sizeof (char *) * (array->array_count + 1)); \ array->array[array->array_count++] = desk->orig_path; \ eina_hash_set((hash), data, array); \ } ADD_LIST(desk->mime_types, mime_types); ADD_LIST(desk->categories, categories); ADD_ELEM(desk->startup_wm_class, startup_wm_class); ADD_ELEM(desk->name, name); ADD_ELEM(desk->generic_name, generic_name); ADD_ELEM(desk->comment, comment); ADD_ELEM(desk->exec, exec); eina_hash_add(file_ids, file_id, desk->orig_path); eina_hash_add(desktops, desk->orig_path, desk); } else efreet_desktop_free(desk); return 1; }
int main(int argc, char **argv) { /* TODO: * - Add file monitor on files, so that we catch changes on files * during whilst this program runs. * - Maybe linger for a while to reduce number of cache re-creates. */ Efreet_Cache_Hash hash; Efreet_Cache_Version version; Eina_List *dirs = NULL; Eina_List *systemdirs = NULL; Eina_List *extra_dirs = NULL; Eina_List *l = NULL; Eina_Inarray *stack = NULL; int priority = 0; char *dir = NULL; char *path; int lockfd = -1, tmpfd; int changed = 0; int i; char file[PATH_MAX] = { '\0' }; char util_file[PATH_MAX] = { '\0' }; mode_t um; if (!eina_init()) goto eina_error; _efreet_desktop_cache_log_dom = eina_log_domain_register("efreet_desktop_cache", EFREET_DEFAULT_LOG_COLOR); if (_efreet_desktop_cache_log_dom < 0) { EINA_LOG_ERR("Efreet: Could not create a log domain for efreet_desktop_cache."); return -1; } for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-v")) eina_log_domain_level_set("efreet_desktop_cache", EINA_LOG_LEVEL_DBG); else if ((!strcmp(argv[i], "-h")) || (!strcmp(argv[i], "-help")) || (!strcmp(argv[i], "--h")) || (!strcmp(argv[i], "--help"))) { printf("Options:\n"); printf(" -v Verbose mode\n"); printf(" -d dir1 dir2 Extra dirs\n"); exit(0); } else if (!strcmp(argv[i], "-d")) { while ((i < (argc - 1)) && (argv[(i + 1)][0] != '-')) extra_dirs = eina_list_append(extra_dirs, argv[++i]); } } extra_dirs = eina_list_sort(extra_dirs, -1, EINA_COMPARE_CB(strcmp)); #ifdef HAVE_SYS_RESOURCE_H setpriority(PRIO_PROCESS, 0, 19); #elif _WIN32 SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS); #endif /* init external subsystems */ if (!eet_init()) goto eet_error; if (!ecore_init()) goto ecore_error; efreet_cache_update = 0; /* finish efreet init */ if (!efreet_init()) goto efreet_error; /* create homedir */ snprintf(file, sizeof(file), "%s/efreet", efreet_cache_home_get()); if (!ecore_file_exists(file)) { if (!ecore_file_mkpath(file)) goto efreet_error; efreet_setowner(file); } /* lock process, so that we only run one copy of this program */ lockfd = cache_lock_file(); if (lockfd == -1) goto efreet_error; edd = efreet_desktop_edd(); if (!edd) goto edd_error; /* read user dirs from old cache */ ef = eet_open(efreet_desktop_util_cache_file(), EET_FILE_MODE_READ); if (ef) { old_file_ids = eet_data_read(ef, efreet_hash_string_edd(), "file_id"); eet_close(ef); } /* create cache */ snprintf(file, sizeof(file), "%s.XXXXXX", efreet_desktop_cache_file()); /* set secure umask for temporary files */ um = umask(0077); tmpfd = mkstemp(file); umask(um); if (tmpfd < 0) goto error; close(tmpfd); ef = eet_open(file, EET_FILE_MODE_READ_WRITE); if (!ef) goto error; snprintf(util_file, sizeof(util_file), "%s.XXXXXX", efreet_desktop_util_cache_file()); /* set secure umask for temporary files */ um = umask(0077); tmpfd = mkstemp(util_file); umask(um); if (tmpfd < 0) goto error; close(tmpfd); util_ef = eet_open(util_file, EET_FILE_MODE_READ_WRITE); if (!util_ef) goto error; /* write cache version */ version.major = EFREET_DESKTOP_UTILS_CACHE_MAJOR; version.minor = EFREET_DESKTOP_UTILS_CACHE_MINOR; eet_data_write(util_ef, efreet_version_edd(), EFREET_CACHE_VERSION, &version, 1); version.major = EFREET_DESKTOP_CACHE_MAJOR; version.minor = EFREET_DESKTOP_CACHE_MINOR; eet_data_write(ef, efreet_version_edd(), EFREET_CACHE_VERSION, &version, 1); desktops = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_desktop_free)); file_ids = eina_hash_string_superfast_new(NULL); paths = eina_hash_string_superfast_new(NULL); mime_types = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free)); categories = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free)); startup_wm_class = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free)); name = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free)); generic_name = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free)); comment = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free)); exec = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free)); dirs = efreet_default_dirs_get(efreet_data_home_get(), efreet_data_dirs_get(), "applications"); if (!dirs) goto error; stack = eina_inarray_new(sizeof(struct stat), 16); if (!stack) goto error; EINA_LIST_FREE(dirs, path) { char file_id[PATH_MAX] = { '\0' }; eina_inarray_flush(stack); if (!cache_scan(stack, path, file_id, priority++, 1, &changed)) goto error; systemdirs = eina_list_append(systemdirs, path); }
EINA_ITERATOR_FOREACH(it, sce) if (ce->id == sce->id) { memcpy(&ce->count, &sce->count, sizeof (ce->count)); break; } if (!sce) error_and_abort(ef, "Collection %s (%i) can't find an correct alias.\n", ce->entry, ce->id); eina_iterator_free(it); eina_hash_direct_add(edje_file->collection, ce->entry, ce); } } bytes = eet_data_write(ef, edd_edje_file, "edje/file", edje_file, 1); if (bytes <= 0) error_and_abort(ef, "Unable to write \"edje_file\" entry to \"%s\" \n", file_out); } if (verbose) { printf("%s: Wrote %9i bytes (%4iKb) for \"edje_file\" header\n", progname, bytes, (bytes + 512) / 1024); } return bytes; } static int
int source_append(Eet_File *ef) { return eet_data_write(ef, _srcfile_list_edd, "edje_sources", &srcfiles, compress_mode); }
END_TEST START_TEST(eet_test_file_fp) { char *file; Eet_Data_Descriptor_Class eddc; Eet_Data_Descriptor *edd_5FP; Eet_Data_Descriptor *edd_5DBL; Eet_File *ef; Eet_5FP origin; Eet_5DBL *convert; Eet_5FP *build; int tmpfd; file = strdup("/tmp/eet_suite_testXXXXXX"); eet_init(); EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_5FP); edd_5FP = eet_data_descriptor_file_new(&eddc); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp32", fp32, EET_T_F32P32); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp16", fp16, EET_T_F16P16); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp8", fp8, EET_T_F8P24); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f1", f1, EET_T_F32P32); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f0", f0, EET_T_F32P32); eet_eina_file_data_descriptor_class_set(&eddc, sizeof (eddc), "Eet_5FP", sizeof (Eet_5DBL)); edd_5DBL = eet_data_descriptor_file_new(&eddc); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp32", fp32, EET_T_DOUBLE); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp16", fp16, EET_T_DOUBLE); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp8", fp8, EET_T_FLOAT); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f1", f1, EET_T_DOUBLE); EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f0", f0, EET_T_DOUBLE); origin.fp32 = eina_f32p32_double_from(1.125); origin.fp16 = eina_f16p16_int_from(2000); origin.fp8 = eina_f8p24_int_from(125); origin.f1 = eina_f32p32_int_from(1); origin.f0 = 0; fail_if(-1 == (tmpfd = mkstemp(file))); fail_if(!!close(tmpfd)); ef = eet_open(file, EET_FILE_MODE_READ_WRITE); fail_if(!ef); fail_if(!eet_data_write(ef, edd_5FP, EET_TEST_FILE_KEY1, &origin, 1)); build = eet_data_read(ef, edd_5FP, EET_TEST_FILE_KEY1); fail_if(!build); convert = eet_data_read(ef, edd_5DBL, EET_TEST_FILE_KEY1); fail_if(!convert); fail_if(build->fp32 != eina_f32p32_double_from(1.125)); fail_if(build->fp16 != eina_f16p16_int_from(2000)); fail_if(build->fp8 != eina_f8p24_int_from(125)); fail_if(build->f1 != eina_f32p32_int_from(1)); fail_if(build->f0 != 0); fail_if(convert->fp32 != 1.125); fail_if(convert->fp16 != 2000); fail_if(convert->fp8 != 125); fail_if(convert->f1 != 1); fail_if(convert->f0 != 0); eet_close(ef); fail_if(unlink(file) != 0); eet_shutdown(); }
END_TEST START_TEST(eet_test_file_data_dump) { Eet_Data_Descriptor *edd; Eet_Test_Ex_Type *result; Eet_Data_Descriptor_Class eddc; Eet_Test_Ex_Type etbt; Eet_File *ef; char *string1; char *file; int test; int tmpfd; file = strdup("/tmp/eet_suite_testXXXXXX"); eet_init(); eet_test_ex_set(&etbt, 0); etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1)); etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1)); etbt.hash = eina_hash_string_superfast_new(NULL); eina_hash_add(etbt.hash, EET_TEST_KEY1, eet_test_ex_set(NULL, 2)); eina_hash_add(etbt.hash, EET_TEST_KEY2, eet_test_ex_set(NULL, 2)); etbt.ilist = eina_list_prepend(etbt.ilist, &i42); etbt.ilist = eina_list_prepend(etbt.ilist, &i42); etbt.ihash = eina_hash_string_superfast_new(NULL); eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7); eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7); etbt.slist = eina_list_prepend(NULL, "test"); etbt.shash = eina_hash_string_superfast_new(NULL); eina_hash_add(etbt.shash, EET_TEST_KEY1, "test"); memset(&etbt.charray, 0, sizeof(etbt.charray)); etbt.charray[0] = "test"; eet_eina_file_data_descriptor_class_set(&eddc, sizeof (eddc), "Eet_Test_Ex_Type", sizeof(Eet_Test_Ex_Type)); edd = eet_data_descriptor_file_new(&eddc); fail_if(!edd); eet_build_ex_descriptor(edd, EINA_FALSE); fail_if(-1 == (tmpfd = mkstemp(file))); fail_if(!!close(tmpfd)); /* Save the encoded data in a file. */ ef = eet_open(file, EET_FILE_MODE_WRITE); fail_if(!ef); fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0)); eet_close(ef); /* Use dump/undump in the middle */ ef = eet_open(file, EET_FILE_MODE_READ_WRITE); fail_if(!ef); string1 = NULL; fail_if(eet_data_dump(ef, EET_TEST_FILE_KEY1, append_string, &string1) != 1); fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0); fail_if(!eet_data_undump(ef, EET_TEST_FILE_KEY1, string1, strlen(string1), 1)); eet_close(ef); /* Test the correctness of the reinsertion. */ ef = eet_open(file, EET_FILE_MODE_READ); fail_if(!ef); result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1); fail_if(!result); eet_close(ef); /* Test the resulting data. */ fail_if(eet_test_ex_check(result, 0, EINA_TRUE) != 0); fail_if(eet_test_ex_check(eina_list_data_get(result->list), 1, EINA_TRUE) != 0); fail_if(eina_list_data_get(result->ilist) == NULL); fail_if(*((int *)eina_list_data_get(result->ilist)) != 42); fail_if(eina_list_data_get(result->slist) == NULL); fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0); fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL); fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0); fail_if(strcmp(result->charray[0], "test") != 0); test = 0; _dump_call = EINA_TRUE; if (result->hash) eina_hash_foreach(result->hash, func, &test); _dump_call = EINA_FALSE; fail_if(test != 0); if (result->ihash) eina_hash_foreach(result->ihash, func7, &test); fail_if(test != 0); fail_if(unlink(file) != 0); eet_shutdown(); }
END_TEST START_TEST(eet_test_file_data) { Eet_Data_Descriptor *edd; Eet_Test_Ex_Type *result; Eet_Dictionary *ed; Eet_File *ef; char **list; char *file; Eet_Data_Descriptor_Class eddc; Eet_Test_Ex_Type etbt; int size; int test; int tmpfd; file = strdup("/tmp/eet_suite_testXXXXXX"); eet_init(); eet_test_ex_set(&etbt, 0); etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1)); etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1)); etbt.hash = eina_hash_string_superfast_new(NULL); eina_hash_add(etbt.hash, EET_TEST_KEY1, eet_test_ex_set(NULL, 2)); etbt.hash = eina_hash_string_superfast_new(NULL); eina_hash_add(etbt.hash, EET_TEST_KEY2, eet_test_ex_set(NULL, 2)); etbt.ilist = eina_list_prepend(etbt.ilist, &i42); etbt.ilist = eina_list_prepend(etbt.ilist, &i42); etbt.ihash = eina_hash_string_superfast_new(NULL); eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7); etbt.ihash = eina_hash_string_superfast_new(NULL); eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7); etbt.slist = eina_list_prepend(NULL, "test"); etbt.shash = eina_hash_string_superfast_new(NULL); eina_hash_add(etbt.shash, EET_TEST_KEY1, "test"); memset(&etbt.charray, 0, sizeof(etbt.charray)); etbt.charray[0] = "test"; eet_test_setup_eddc(&eddc); eddc.name = "Eet_Test_Ex_Type"; eddc.size = sizeof(Eet_Test_Ex_Type); edd = eet_data_descriptor_file_new(&eddc); fail_if(!edd); eet_build_ex_descriptor(edd, EINA_FALSE); fail_if(-1 == (tmpfd = mkstemp(file))); fail_if(!!close(tmpfd)); /* Insert an error in etbt. */ etbt.i = 0; /* Save the encoded data in a file. */ ef = eet_open(file, EET_FILE_MODE_READ_WRITE); fail_if(!ef); fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0)); result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1); fail_if(!result); fail_if(eet_mode_get(ef) != EET_FILE_MODE_READ_WRITE); /* Test string space. */ ed = eet_dictionary_get(ef); fail_if(!eet_dictionary_string_check(ed, result->str)); fail_if(eet_dictionary_string_check(ed, result->istr)); eet_close(ef); /* Attempt to replace etbt by the correct one. */ etbt.i = EET_TEST_INT; ef = eet_open(file, EET_FILE_MODE_READ_WRITE); fail_if(!ef); fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0)); result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1); fail_if(!result); /* Test the resulting data. */ fail_if(eet_test_ex_check(result, 0, EINA_FALSE) != 0); eet_close(ef); /* Read back the data. */ ef = eet_open(file, EET_FILE_MODE_READ_WRITE); fail_if(!ef); fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY2, &etbt, 0)); result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1); fail_if(!result); /* Test string space. */ ed = eet_dictionary_get(ef); fail_if(!ed); fail_if(!eet_dictionary_string_check(ed, result->str)); fail_if(eet_dictionary_string_check(ed, result->istr)); /* Test the resulting data. */ fail_if(eet_test_ex_check(result, 0, EINA_FALSE) != 0); fail_if(eet_test_ex_check(eina_list_data_get(result->list), 1, EINA_FALSE) != 0); fail_if(eina_list_data_get(result->ilist) == NULL); fail_if(*((int *)eina_list_data_get(result->ilist)) != 42); fail_if(eina_list_data_get(result->slist) == NULL); fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0); fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL); fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0); fail_if(strcmp(result->charray[0], "test") != 0); test = 0; if (result->hash) eina_hash_foreach(result->hash, func, &test); fail_if(test != 0); if (result->ihash) eina_hash_foreach(result->ihash, func7, &test); fail_if(test != 0); list = eet_list(ef, "keys/*", &size); fail_if(eet_num_entries(ef) != 2); fail_if(size != 2); fail_if(!(strcmp(list[0], EET_TEST_FILE_KEY1) == 0 && strcmp(list[1], EET_TEST_FILE_KEY2) == 0) && !(strcmp(list[0], EET_TEST_FILE_KEY2) == 0 && strcmp(list[1], EET_TEST_FILE_KEY1) == 0)); free(list); fail_if(eet_delete(ef, NULL) != 0); fail_if(eet_delete(NULL, EET_TEST_FILE_KEY1) != 0); fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0); list = eet_list(ef, "keys/*", &size); fail_if(size != 1); fail_if(eet_num_entries(ef) != 1); /* Test some more wrong case */ fail_if(eet_data_read(ef, edd, "plop") != NULL); fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) != NULL); /* Reinsert and reread data */ fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0)); fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) == NULL); fail_if(eet_read_direct(ef, EET_TEST_FILE_KEY1, &size) == NULL); eet_close(ef); fail_if(unlink(file) != 0); eet_shutdown(); }