A little abstraction to have abstract data content bound to a type.
Reviewed-by: Cedric BAIL <cedric.bail@free.fr>
Reviewed-by: Xavi Artigas <xavierartigas@yahoo.es>
Differential Revision: https://phab.enlightenment.org/D11018
#include <eina_debug.h>
#include <eina_promise.h>
#include <eina_vpath.h>
+#include <eina_abstract_content.h>
#undef EAPI
#define EAPI
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <Eina.h>
+#include "eina_abstract_content.h"
+
+struct _Eina_Content
+{
+ Eina_Rw_Slice data;
+ const char *type;
+ const char *file;
+ EINA_REFCOUNT;
+};
+EAPI const Eina_Value_Type *EINA_VALUE_TYPE_CONTENT;
+
+static int _eina_abstract_content_log_domain = -1;
+
+#ifdef ERR
+#undef ERR
+#endif
+#define ERR(...) EINA_LOG_DOM_ERR(_eina_abstract_content_log_domain, __VA_ARGS__)
+
+#ifdef DBG
+#undef DBG
+#endif
+#define DBG(...) EINA_LOG_DOM_DBG(_eina_abstract_content_log_domain, __VA_ARGS__)
+
+static Eina_Hash *conversion_callbacks;
+
+typedef struct {
+ const char *to;
+ Eina_Content_Conversion_Callback callback;
+} Eina_Content_Conversion_Node;
+
+static void
+_eina_content_ref(Eina_Content *content)
+{
+ EINA_REFCOUNT_REF(content);
+}
+
+EAPI Eina_Bool
+eina_content_converter_conversion_register(const char *from, const char *to, Eina_Content_Conversion_Callback conversion)
+{
+ Eina_Content_Conversion_Node *node = calloc(1, sizeof(Eina_Content_Conversion_Node));
+
+ Eina_Stringshare *shared_from = eina_stringshare_add(from);
+
+ if (eina_content_converter_convert_can(from, to))
+ {
+ ERR("Convertion from %s to %s is already possible", from, to);
+ return EINA_FALSE;
+ }
+
+ node->to = eina_stringshare_add(to);
+ node->callback = conversion;
+
+ eina_hash_list_append(conversion_callbacks, shared_from, node);
+
+ return EINA_TRUE;
+}
+
+static inline Eina_List*
+_conversion_callback_fetch_possible(const char *from)
+{
+ Eina_Stringshare *shared_from = eina_stringshare_add(from);
+ Eina_List *res = eina_hash_find(conversion_callbacks, shared_from);
+ eina_stringshare_del(shared_from);
+ return res;
+}
+
+static inline Eina_Content_Conversion_Callback
+_conversion_callback_fetch(const char *from, const char *to)
+{
+ Eina_List *possibilities = _conversion_callback_fetch_possible(from);
+ Eina_Content_Conversion_Node *n;
+ Eina_Content_Conversion_Callback result = NULL;
+ Eina_List *l;
+ Eina_Stringshare *shared_to = eina_stringshare_add(to);
+
+ EINA_LIST_FOREACH(possibilities, l, n)
+ {
+ if (n->to == shared_to)
+ {
+ result = n->callback;
+ goto end;
+ }
+ }
+end:
+ eina_stringshare_del(shared_to);
+ return result;
+}
+
+EAPI Eina_Bool
+eina_content_converter_convert_can(const char *from, const char *to)
+{
+ return !!_conversion_callback_fetch(from, to);
+}
+
+static const void*
+_process_cb(const void *container EINA_UNUSED, void *data, void *fdata EINA_UNUSED)
+{
+ Eina_Content_Conversion_Node *n = data;
+
+ return n->to;
+ }
+
+EAPI Eina_Iterator*
+eina_content_converter_possible_conversions(const char *from)
+{
+ Eina_List *possibilities = _conversion_callback_fetch_possible(from);
+
+ return eina_iterator_processed_new(eina_list_iterator_new(possibilities) , EINA_PROCESS_CB(_process_cb), NULL, possibilities);
+}
+
+EAPI Eina_Content*
+eina_content_new(Eina_Slice data, const char *type)
+{
+ Eina_Content *content;
+
+ if (!strncmp(type, "text", strlen("text")))
+ {
+ //last char in the mem must be \0
+ if (((char*)data.mem)[data.len - 1] != '\0')
+ {
+ ERR("Last character is not a null character! but type is text!");
+ return NULL;
+ }
+ }
+
+ content = calloc(1, sizeof(Eina_Content));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(content, NULL);
+ content->data = eina_slice_dup(data);
+ content->type = eina_stringshare_add(type);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(content->data.mem, NULL);
+
+ _eina_content_ref(content);
+ return content;
+}
+
+EAPI void
+eina_content_free(Eina_Content *content)
+{
+ EINA_REFCOUNT_UNREF(content)
+ {
+ if (content->file)
+ eina_tmpstr_del(content->file);
+ free(content->data.mem);
+ free(content);
+ }
+}
+
+EAPI const char*
+eina_content_as_file(Eina_Content *content)
+{
+ if (!content->file)
+ {
+ Eina_Tmpstr *path;
+ int fd = eina_file_mkstemp("prefixXXXXXX.ext", &path);
+
+ if (fd < 0)
+ {
+ ERR("Failed to create tmp file");
+ return NULL;
+ }
+
+ if (write(fd, content->data.mem, content->data.len) < 0)
+ {
+ ERR("Failed to write to a file");
+ eina_tmpstr_del(path);
+ close(fd);
+ return NULL;
+ }
+
+ content->file = path;
+ close(fd);
+ }
+ return content->file;
+}
+
+EAPI const char*
+eina_content_type_get(Eina_Content *content)
+{
+ return content->type;
+}
+
+EAPI const Eina_Slice
+eina_content_data_get(Eina_Content *content)
+{
+ return eina_rw_slice_slice_get(content->data);
+}
+
+EAPI Eina_Content*
+eina_content_convert(Eina_Content *content, const char *new_type)
+{
+ Eina_Content_Conversion_Callback callback = _conversion_callback_fetch(content->type, new_type);
+
+ if (!callback)
+ {
+ ERR("No suitable conversion found");
+ return NULL;
+ }
+
+ return callback(content, new_type);
+}
+
+static Eina_Content*
+_copy_converter(Eina_Content *from, const char *to_type)
+{
+ Eina_Slice slice = eina_content_data_get(from);
+ return eina_content_new(slice, to_type);
+}
+
+static Eina_Content*
+_latin1_to_utf8_converter(Eina_Content *from, const char *to_type)
+{
+ Eina_Slice slice = eina_content_data_get(from);
+ Eina_Strbuf *out = eina_strbuf_new();
+
+ for (unsigned int i = 0; i < slice.len; ++i)
+ {
+ const unsigned char c = ((char*)slice.mem)[i];
+ if (c < 128)
+ eina_strbuf_append_char(out, c);
+ else
+ {
+ eina_strbuf_append_char(out, 0xc0 | c >> 6);
+ eina_strbuf_append_char(out, 0x80 | (c & 0x3f));
+ }
+ }
+ Eina_Slice new;
+ new.len = eina_strbuf_length_get(out);
+ new.mem = eina_strbuf_string_get(out);
+ Eina_Content *c = eina_content_new(new, to_type);
+ eina_strbuf_free(out);
+ return c;
+}
+
+static Eina_Bool
+_eina_value_type_content_setup(const Eina_Value_Type *type EINA_UNUSED, void *mem)
+{
+ memset(mem, 0, sizeof(Eina_Content*));
+ return EINA_TRUE;
+}
+
+static Eina_Bool
+_eina_value_type_content_flush(const Eina_Value_Type *type EINA_UNUSED,
+ void *mem EINA_UNUSED)
+{
+ Eina_Content **content = mem;
+
+ eina_content_free(*content);
+
+ return EINA_TRUE;
+}
+
+static Eina_Bool
+_eina_value_type_content_copy(const Eina_Value_Type *type EINA_UNUSED, const void *src, void *dst)
+{
+ Eina_Content * const *srcc = src;
+ Eina_Content **dstc = dst;
+
+ *dstc = *srcc;
+ _eina_content_ref(*dstc);
+ return EINA_TRUE;
+}
+
+static int
+_eina_value_type_content_compare(const Eina_Value_Type *type EINA_UNUSED, const void *a, const void *b)
+{
+ Eina_Content * const *ra = a;
+ Eina_Content * const *rb = b;
+
+ if ((*ra)->type != (*rb)->type)
+ return -1;
+
+ return eina_rw_slice_compare((*ra)->data, (*rb)->data);
+}
+
+static Eina_Bool
+_eina_value_type_content_convert_to(const Eina_Value_Type *type EINA_UNUSED, const Eina_Value_Type *convert EINA_UNUSED, const void *type_mem EINA_UNUSED, void *convert_mem EINA_UNUSED)
+{
+ Eina_Content * const *ra = type_mem;
+
+ if (convert == EINA_VALUE_TYPE_STRINGSHARE ||
+ convert == EINA_VALUE_TYPE_STRING)
+ {
+ const char *type = eina_content_type_get(*ra);
+ if (eina_streq(type, "text/plain;charset=utf-8"))
+ {
+ Eina_Slice data = eina_content_data_get(*ra);
+ return eina_value_type_pset(convert, convert_mem, &data.mem);
+ }
+ else
+ {
+ Eina_Iterator *iter = eina_content_possible_conversions(*ra);
+ const char *type;
+
+ EINA_ITERATOR_FOREACH(iter, type)
+ {
+ if (eina_streq(type, "text/plain;charset=utf-8"))
+ {
+ Eina_Content *conv_result = eina_content_convert(*ra, type);
+
+ Eina_Slice data = eina_content_data_get(conv_result);
+ Eina_Bool success = eina_value_type_pset(convert, convert_mem, &data.mem);
+ eina_content_free(conv_result);
+ return success;
+ }
+ }
+ //create some fallback
+ {
+ char buf[PATH_MAX];
+ char *tmp = (char*) &buf;
+ snprintf(buf, sizeof(buf), "Content %p cannot be converted to \"text/plain;charset=utf-8\"", *ra);
+ return eina_value_type_pset(convert, convert_mem, &tmp);
+ }
+ }
+ }
+ return EINA_FALSE;
+}
+
+static Eina_Bool
+_eina_value_type_content_convert_from(const Eina_Value_Type *type EINA_UNUSED, const Eina_Value_Type *convert EINA_UNUSED, void *type_mem EINA_UNUSED, const void *convert_mem EINA_UNUSED)
+{
+ return EINA_FALSE;
+}
+
+static Eina_Bool
+_eina_value_type_content_pset(const Eina_Value_Type *type EINA_UNUSED, void *mem, const void *ptr)
+{
+ Eina_Content * const *srcc = ptr;
+ Eina_Content **dstc = mem;
+
+ *dstc = *srcc;
+ _eina_content_ref(*dstc);
+ return EINA_TRUE;
+}
+
+static Eina_Bool
+_eina_value_type_content_vset(const Eina_Value_Type *type EINA_UNUSED, void *mem, va_list args)
+{
+ Eina_Content **dst = mem;
+ Eina_Content *content = va_arg(args, Eina_Content*);
+
+ *dst = content;
+ _eina_content_ref(*dst);
+ return EINA_TRUE;
+}
+
+static Eina_Bool
+_eina_value_type_content_pget(const Eina_Value_Type *type EINA_UNUSED, const void *mem, void *ptr)
+{
+ Eina_Content * const *src = mem;
+ Eina_Content **dst = ptr;
+
+ *dst = *src;
+ _eina_content_ref(*dst);
+ return EINA_TRUE;
+}
+
+EAPI const Eina_Value_Type _EINA_VALUE_TYPE_CONTENT ={
+ EINA_VALUE_TYPE_VERSION,
+ sizeof(Eina_Content*),
+ "Eina_Abstract_Content",
+ _eina_value_type_content_setup,
+ _eina_value_type_content_flush,
+ _eina_value_type_content_copy,
+ _eina_value_type_content_compare,
+ _eina_value_type_content_convert_to,
+ _eina_value_type_content_convert_from,
+ _eina_value_type_content_vset,
+ _eina_value_type_content_pset,
+ _eina_value_type_content_pget
+};
+
+static void
+_free_node(void *v)
+{
+ Eina_Content_Conversion_Node *n;
+ EINA_LIST_FREE(v, n)
+ {
+ eina_stringshare_del(n->to);
+ free(n);
+ }
+}
+
+Eina_Bool
+eina_abstract_content_init(void)
+{
+ _eina_abstract_content_log_domain = eina_log_domain_register("eina_abstract_content", "white");
+ conversion_callbacks = eina_hash_stringshared_new(_free_node);
+
+ EINA_VALUE_TYPE_CONTENT = &_EINA_VALUE_TYPE_CONTENT;
+
+ // text/plain is assumed to be charset "US-ASCII"
+
+ eina_content_converter_conversion_register("text/plain", "text/plain;charset=utf-8", _copy_converter);
+ eina_content_converter_conversion_register("text/plain", "text/plain;charset=iso-8859-1", _copy_converter);
+ eina_content_converter_conversion_register("text/plain;charset=iso-8859-1", "text/plain;charset=utf-8", _latin1_to_utf8_converter);
+ eina_content_converter_conversion_register("text/plain;charset=iso-8859-1", "text/plain", _copy_converter);
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+eina_abstract_content_shutdown(void)
+{
+ eina_hash_free(conversion_callbacks);
+
+ return EINA_TRUE;
+}
+
+Eina_Value*
+eina_value_content_new(Eina_Content *content)
+{
+ Eina_Value *v = eina_value_new(EINA_VALUE_TYPE_CONTENT);
+
+ eina_value_pset(v, &content);
+ return v;
+}
+
+
+Eina_Value
+eina_value_content_init(Eina_Content *content)
+{
+ Eina_Value v;
+
+ eina_value_setup(&v, EINA_VALUE_TYPE_CONTENT);
+ eina_value_pset(&v, &content);
+
+ return v;
+}
+
+
+Eina_Content*
+eina_value_to_content(const Eina_Value *value)
+{
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(eina_value_type_get(value) == EINA_VALUE_TYPE_CONTENT, NULL);
+ Eina_Content *result = calloc(1, sizeof(Eina_Content));
+ eina_value_pget(value, &result);
+ return result;
+}
--- /dev/null
+#ifndef EINA_ABSTRACT_CONTENT_H
+#define EINA_ABSTRACT_CONTENT_H
+
+
+/**
+ * @typedef Eina_Content
+ * Defines a abstract content segment
+ *
+ * Each Abstract content contains out of a Eina_Slice of memory. And a type.
+ * The type are IANA meme types.
+ *
+ * @note if the type is a text-style type, the last byte of the slice must be \0
+ *
+ * @since 1.24
+ */
+typedef struct _Eina_Content Eina_Content;
+
+/**
+ * @typedef Eina_Content_Convertion_Callback
+ *
+ * Callback called when convertion from one type to another type is requested.
+ * The from and to type is specified when the callback is registered.
+ * The to type is also passed in the callback here.
+ * The type of the from pointer does not need to be checked.
+ */
+typedef Eina_Content* (*Eina_Content_Conversion_Callback)(Eina_Content *from, const char *to_type);
+
+/**
+ * Get the path to a file, containing the slice memory as content.
+ *
+ * @param[in] content The content that will be in the file.
+ *
+ * @return The path to the file. Do not free this.
+ *
+ */
+EAPI const char* eina_content_as_file(Eina_Content *content);
+
+/**
+ * Convert the content of the object to another type.
+ *
+ * In case the convertion cannot be performaned, NULL is returned.
+ *
+ * @param[in] content The content to convert.
+ * @param[in] new_type The new type the returned content will have.
+ *
+ * @return A new content object. The caller of this function is owning this.
+ */
+EAPI Eina_Content* eina_content_convert(Eina_Content *content, const char *new_type);
+
+/**
+ * Get the type of the passed content.
+ *
+ * @param[in] content The content to fetch the type from.
+ *
+ * @return The type of this content. Do no free this.
+ */
+EAPI const char* eina_content_type_get(Eina_Content *content);
+
+/**
+ * Get the type of the passed content.
+ *
+ * @param[in] content The content to fetch the type from.
+ *
+ * @return The path to the file. Do not free this.
+ */
+EAPI const Eina_Slice eina_content_data_get(Eina_Content *content);
+
+/**
+ * Create a new content object, with the slice of data with a specific type.
+ *
+ * @param[in] data A slice of memory, the memory is duplicated.
+ * @param[in] type The type of memory.
+ *
+ * @return The new content object. The caller owns this object.
+ */
+EAPI Eina_Content* eina_content_new(Eina_Slice data, const char *type);
+
+/**
+ * Free the content object.
+ *
+ * @param[in] content The content to free.
+ */
+EAPI void eina_content_free(Eina_Content *content);
+
+/**
+ * Register a new conversion callback.
+ *
+ * @param[in] from The tyoe you convert from.
+ * @param[in] in The type you convert to.
+ *
+ * @return True on success false otherwise.
+ */
+EAPI Eina_Bool eina_content_converter_conversion_register(const char *from, const char *to, Eina_Content_Conversion_Callback convertion);
+
+/**
+ * Check if a specific convertion can be performanced.
+ *
+ * A convertion can only be performed if a callback is registered.
+ *
+ * @param[in] from The type you convert from.
+ * @param[in] in The type you convert to.
+ *
+ * @return True if it can be performed, false if not.
+ */
+EAPI Eina_Bool eina_content_converter_convert_can(const char *from, const char *to);
+
+/**
+ * Returns a iterator that can be used to find all the possible types that can be converted to.
+ *
+ * @param[in] form The type you convert from
+ *
+ * @return A Iterator, containing strings, free this via eina_iterator_free.
+ */
+EAPI Eina_Iterator* eina_content_converter_possible_conversions(const char *from);
+
+EAPI extern const Eina_Value_Type *EINA_VALUE_TYPE_CONTENT;
+
+/**
+ * Convert the Eina_Content object to a Eina_Value.
+ *
+ * @param[in] content The Eina_Content struct that will be converted to a Eina_Value
+ *
+ * @return A Eina_Value that is allocated, you need to free it.
+ */
+EAPI Eina_Value* eina_value_content_new(Eina_Content *content);
+
+/**
+ * Convert the Eina_Content object to a Eina_Value.
+ *
+ * @param[in] content The Eina_Content struct that will be converted to a Eina_Value
+ *
+ * @return A Eina_Value with type EINA_VALUE_TYPE_CONTENT
+ */
+EAPI Eina_Value eina_value_content_init(Eina_Content *content);
+
+/**
+ * Get the content from the Eina_Value
+ *
+ * If the value is not of the type EINA_VALUE_TYPE_CONTENT, NULL will be returned and a error will be printed.
+ *
+ * @param[in] value The value to get the content from
+ *
+ * @return A allocated Eina_Content, you need to free it.
+ */
+EAPI Eina_Content* eina_value_to_content(const Eina_Value *value);
+
+
+static inline Eina_Iterator*
+eina_content_possible_conversions(Eina_Content *content)
+{
+ return eina_content_converter_possible_conversions(eina_content_type_get(content));
+}
+
+#endif
S(slstr);
S(promise);
S(vpath);
+ S(abstract_content);
#undef S
struct eina_desc_setup
S(safepointer),
S(slstr),
S(promise),
+ S(abstract_content)
#undef S
};
static const size_t _eina_desc_setup_len = sizeof(_eina_desc_setup) /
#else
#define EINA_SLICE_STR(str) {.len = strlen((str)), .mem = (str)}
#endif
+/**
+ * @def EINA_SLICE_STR_FULL(str)
+ *
+ * Same as EINA_SLICE_STR_FULL, but it also contains the \0 element of the string
+ *
+ * @param[in] str The string to create the slice from.
+ * @return The initialized slice object.
+ *
+ * @note This macro is usable with both Eina_Slice or Eina_Rw_Slice.
+ *
+ * @code
+ * Eina_Slice ro_slice = EINA_SLICE_STR_FULL("hello world");
+ * @endcode
+ *
+ * @see EINA_SLICE_STR_FULL() for specific version using literals.
+ *
+ * @since 1.24
+ */
+#ifdef __cplusplus
+#define EINA_SLICE_STR_FULL(str) {strlen((str)) + 1, (str)}
+#else
+#define EINA_SLICE_STR_FULL(str) {.len = strlen((str)) + 1, .mem = (str)}
+#endif
+
/**
* @def EINA_SLICE_STR_FMT
'eina_freeq.h',
'eina_slstr.h',
'eina_vpath.h',
+'eina_abstract_content.h'
]
public_headers = [
'eina_freeq.c',
'eina_slstr.c',
'eina_vpath.c',
-'eina_vpath_xdg.c'
+'eina_vpath_xdg.c',
+'eina_abstract_content.c',
]
if sys_windows == true
{ "slstr", eina_test_slstr },
{ "Vpath", eina_test_vpath },
{ "debug", eina_test_debug },
+ { "Abstract Content", eina_test_abstract_content },
{ NULL, NULL }
};
void eina_test_slstr(TCase *tc);
void eina_test_vpath(TCase *tc);
void eina_test_debug(TCase *tc);
+void eina_test_abstract_content(TCase *tc);
#endif /* EINA_SUITE_H_ */
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+
+#include <Eina.h>
+
+#include "eina_suite.h"
+
+EFL_START_TEST(eina_test_content_create_destroy)
+{
+ const char *text_str = "TestAsDf";
+ Eina_Content *content = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(text_str), "text/plain");
+
+ ck_assert_str_eq(eina_content_type_get(content), "text/plain");
+ ck_assert_int_eq(eina_content_data_get(content).len, strlen(text_str) + 1);
+ ck_assert_str_eq(eina_content_data_get(content).mem, text_str);
+
+ eina_content_free(content);
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_as_file)
+{
+ const char *text_str = "TestAsDf";
+ Eina_Content *content = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(text_str), "text/plain");
+ Eina_File *f;
+ const char *file_path = eina_content_as_file(content);
+
+ f = eina_file_open(file_path, EINA_FALSE);
+ const char *file_content = eina_file_map_all(f, EINA_FILE_POPULATE);
+ ck_assert_str_eq(file_content, text_str);
+ eina_file_close(f);
+
+ eina_content_free(content);
+
+ const char *file_path2 = eina_content_as_file(content);
+ ck_assert_str_eq(file_path, file_path2);
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_convert_none_existing)
+{
+ const char *text_str = "TestAsDf";
+ Eina_Content *content = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(text_str), "text/plain");
+
+ EXPECT_ERROR_START;
+ ck_assert_ptr_eq(eina_content_convert(content, "ThisIsReallyNotHere"), NULL);
+ EXPECT_ERROR_END;
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_convert_ascii_to_utf8)
+{
+ const char *text_str = "TestAsDf";
+ Eina_Content *content = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(text_str), "text/plain");
+ Eina_Content *c = eina_content_convert(content, "text/plain;charset=utf-8");
+
+ ck_assert_str_eq(eina_content_type_get(c), "text/plain;charset=utf-8");
+ ck_assert_str_eq(eina_content_data_get(c).mem, text_str);
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_convert_ascii_to_latin)
+{
+ const char *text_str = "TestAsDf";
+ Eina_Content *content = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(text_str), "text/plain");
+ Eina_Content *c = eina_content_convert(content, "text/plain;charset=iso-8859-1");
+
+ ck_assert_str_eq(eina_content_type_get(c), "text/plain;charset=iso-8859-1");
+ ck_assert_str_eq(eina_content_data_get(c).mem, text_str);
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_convert_utf8_to_latin)
+{
+ //this means AÄÜÖß
+ const char text_str[] = {'A', 0xc3, 0x84, 0xc3, 0x9c, 0xc3, 0x96, 0xc3, 0x9f, 0};
+ const char text_str_latin[] = {'A', 0xC4, 0xDC, 0xD6, 0xDF, 0};
+ Eina_Content *content = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(text_str_latin), "text/plain;charset=iso-8859-1");
+ Eina_Content *c = eina_content_convert(content, "text/plain;charset=utf-8");
+
+ ck_assert_str_eq(eina_content_type_get(c), "text/plain;charset=utf-8");
+ ck_assert_int_eq(sizeof(text_str), eina_content_data_get(c).len);
+ for (unsigned int i = 0; i < eina_content_data_get(c).len; ++i)
+ {
+ ck_assert_int_eq(text_str[i], ((char*)eina_content_data_get(c).mem)[i]);
+ }
+ ck_assert_str_eq(eina_content_data_get(c).mem, text_str);
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_possible_converstions)
+{
+ ck_assert_int_eq(eina_content_converter_convert_can("text/plain", "text/plain;charset=utf-8"), 1);
+ ck_assert_int_eq(eina_content_converter_convert_can("text/plain", "ThisDoesNotExist"), 0);
+ ck_assert_int_eq(eina_content_converter_convert_can("ThisDoesNotExist", "text/plain;charset=utf-8"), 0);
+ Eina_Iterator *iterator = eina_content_converter_possible_conversions("text/plain");
+ char *text;
+ int i = 0, j = 0;
+
+ EINA_ITERATOR_FOREACH(iterator, text)
+ {
+ if (eina_streq(text, "text/plain;charset=utf-8"))
+ i ++;
+ if (eina_streq(text, "text/plain;charset=iso-8859-1"))
+ j ++;
+ }
+ ck_assert_int_eq(i, 1);
+ ck_assert_int_eq(j, 1);
+ eina_iterator_free(iterator);
+}
+EFL_END_TEST
+
+static Eina_Bool getting_called = EINA_FALSE;
+
+static Eina_Content*
+_test_cb(Eina_Content *content EINA_UNUSED, const char *type EINA_UNUSED)
+{
+ getting_called = EINA_TRUE;
+ return eina_content_new(eina_content_data_get(content), type);
+}
+
+EFL_START_TEST(eina_test_register_illegal)
+{
+ const char *test_str = "AbCdEfG";
+ eina_content_converter_conversion_register("Test", "Test2", _test_cb);
+ EXPECT_ERROR_START;
+ eina_content_converter_conversion_register("Test", "Test2", _test_cb);
+ EXPECT_ERROR_END;
+
+ Eina_Content *c = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(test_str), "Test");
+ Eina_Content *c2 = eina_content_convert(c, "Test2");
+ ck_assert_ptr_ne(c2, NULL);
+ ck_assert_int_eq(getting_called, EINA_TRUE);
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_value)
+{
+ const char *str_a = "All";
+ const char *str_b = "Out";
+ Eina_Content *a = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(str_a), "text/plain");
+ Eina_Content *b = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(str_b), "text/plain");
+ Eina_Content *c = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(str_a), "text/plain");
+ Eina_Content *d = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(str_a), "Not_Text");
+ Eina_Value *va = eina_value_content_new(a);
+ Eina_Value *vb = eina_value_content_new(b);
+ Eina_Value *vc = eina_value_content_new(c);
+ Eina_Value *vd = eina_value_content_new(d);
+ Eina_Value *vcopy = eina_value_new(EINA_VALUE_TYPE_CONTENT);
+ Eina_Content *content;
+
+ ck_assert_int_eq(eina_value_compare(va, vc), 0);
+ ck_assert_int_ne(eina_value_compare(va, vb), 0);
+ ck_assert_int_ne(eina_value_compare(va, vd), 0);
+ ck_assert_int_eq(eina_value_compare(vd, vd), 0);
+
+ ck_assert_int_eq(eina_value_copy(va, vcopy), 1);
+ ck_assert_int_eq(eina_value_compare(va, vcopy), 0);
+
+ content = eina_value_to_content(vcopy);
+ Eina_Slice slice = eina_content_data_get(content);
+ ck_assert_int_eq(slice.len, strlen(str_a) + 1);
+ ck_assert_str_eq(slice.mem, str_a);
+
+ ck_assert_str_eq(eina_content_type_get(content), "text/plain");
+ eina_content_free(content);
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_value_set)
+{
+ const char *str_a = "All";
+ Eina_Content *a = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(str_a), "text/plain");
+ Eina_Value *acopy = eina_value_new(EINA_VALUE_TYPE_CONTENT);
+ Eina_Content *content;
+
+ eina_value_set(acopy, a);
+ content = eina_value_to_content(acopy);
+ Eina_Slice slice = eina_content_data_get(content);
+ ck_assert_int_eq(slice.len, strlen(str_a) + 1);
+ ck_assert_str_eq(slice.mem, str_a);
+
+ ck_assert_str_eq(eina_content_type_get(content), "text/plain");
+ eina_content_free(content);
+}
+EFL_END_TEST
+
+EFL_START_TEST(eina_test_content_value_convertion)
+{
+ const char *str_a = "All";
+ const char *str_b = "Out";
+ const char *str_c = "Life";
+ Eina_Content *a = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(str_a), "text/plain;charset=utf-8");
+ Eina_Content *b = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(str_b), "text/plain");
+ Eina_Content *c = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(str_c), "application/x-elementary-markup");
+ Eina_Value *av = eina_value_content_new(a);
+ Eina_Value *bv = eina_value_content_new(b);
+ Eina_Value *cv = eina_value_content_new(c);
+
+ ck_assert_str_eq(eina_value_to_string(av), str_a);
+ ck_assert_str_eq(eina_value_to_string(bv), str_b);
+ ck_assert_str_ne(eina_value_to_string(cv), str_c);
+}
+EFL_END_TEST
+
+void
+eina_test_abstract_content(TCase *tc)
+{
+ tcase_add_test(tc, eina_test_content_create_destroy);
+ tcase_add_test(tc, eina_test_content_as_file);
+ tcase_add_test(tc, eina_test_content_convert_none_existing);
+ tcase_add_test(tc, eina_test_content_convert_ascii_to_utf8);
+ tcase_add_test(tc, eina_test_content_convert_ascii_to_latin);
+ tcase_add_test(tc, eina_test_content_convert_utf8_to_latin);
+ tcase_add_test(tc, eina_test_content_possible_converstions);
+ tcase_add_test(tc, eina_test_register_illegal);
+ tcase_add_test(tc, eina_test_content_value);
+ tcase_add_test(tc, eina_test_content_value_set);
+ tcase_add_test(tc, eina_test_content_value_convertion);
+}
'eina_test_slice.c',
'eina_test_freeq.c',
'eina_test_slstr.c',
-'eina_test_vpath.c'
+'eina_test_vpath.c',
+'eina_test_abstract_content.c',
)
projects / platform / upstream / efl.git / commitdiff