$(efl_ecore_evas_mono_files)
efl_mono_test_files = \
- tests/efl_mono/test_testing.eo \
- tests/efl_mono/test_child.eo \
- tests/efl_mono/test_numberwrapper.eo \
+ tests/efl_mono/dummy_test_object.eo \
+ tests/efl_mono/dummy_test_iface.eo \
+ tests/efl_mono/dummy_another_iface.eo \
+ tests/efl_mono/dummy_child.eo \
+ tests/efl_mono/dummy_numberwrapper.eo \
tests/efl_mono/mono_test_driver.sh
EXTRA_DIST2 += \
tests_efl_mono_libefl_mono_native_test_la_DEPENDENCIES = @USE_EINA_INTERNAL_LIBS@ @USE_EO_INTERNAL_LIBS@ @USE_ECORE_INTERNAL_LIBS@ @USE_ELDBUS_INTERNAL_LIBS@
tests_efl_mono_libefl_mono_native_test_la_LIBTOOLFLAGS = --tag=disable-static
-tests/efl_mono/libefl_mono_native_test.c: tests/efl_mono/test_testing.eo.h tests/efl_mono/test_testing.eo.c tests/efl_mono/test_child.eo.h tests/efl_mono/test_child.eo.c tests/efl_mono/test_numberwrapper.eo.h tests/efl_mono/test_numberwrapper.eo.c
+tests/efl_mono/libefl_mono_native_test.c: \
+ tests/efl_mono/dummy_test_object.eo.h \
+ tests/efl_mono/dummy_test_object.eo.c \
+ tests/efl_mono/dummy_test_iface.eo.h \
+ tests/efl_mono/dummy_test_iface.eo.c \
+ tests/efl_mono/dummy_another_iface.eo.h \
+ tests/efl_mono/dummy_another_iface.eo.c \
+ tests/efl_mono/dummy_child.eo.h \
+ tests/efl_mono/dummy_child.eo.c \
+ tests/efl_mono/dummy_numberwrapper.eo.h \
+ tests/efl_mono/dummy_numberwrapper.eo.c
# Intermediate C Sharp test DLL
-efl_mono_test_eolian_mono_files = tests/efl_mono/test_testing.eo.cs \
-tests/efl_mono/test_child.eo.cs \
-tests/efl_mono/test_numberwrapper.eo.cs
+efl_mono_test_eolian_mono_files = tests/efl_mono/dummy_test_object.eo.cs \
+tests/efl_mono/dummy_test_iface.eo.cs \
+tests/efl_mono/dummy_another_iface.eo.cs \
+tests/efl_mono/dummy_child.eo.cs \
+tests/efl_mono/dummy_numberwrapper.eo.cs
tests/efl_mono/libefl_mono_test.dll: $(efl_mono_test_eolian_mono_files) tests/efl_mono/$(am__dirstamp) lib/efl_mono/libefl_mono.dll tests/efl_mono/libefl_mono_native_test.la tests/efl_mono/libefl_mono_test.dll.config
@rm -f tests/efl_mono/libefl_mono_test.dll
$(MKDIR_P) $(dir $@); \
$(EOLIAN_MONO) $(EOLIAN_FLAGS) $(EOLIAN_MONO_FLAGS) --dllimport "@DLIB_PREFIX_MONO@efl_mono_native_test@DLIB_SUFFIX_MONO@" -o $@ $(ALL_EO_REFS) $<
-CLEANFILES += tests/efl_mono/libefl_mono_test.dll tests/efl_mono/test_testing.eo.cs tests/efl_mono/test_child.eo.cs tests/efl_mono/test_numberwrapper.eo.cs tests/efl_mono/test_testing.eo.c tests/efl_mono/test_child.eo.c tests/efl_mono/test_numberwrapper.eo.c tests/efl_mono/test_testing.eo.h tests/efl_mono/test_child.eo.h tests/efl_mono/test_numberwrapper.eo.h tests/efl_mono/efl_mono.config
+CLEANFILES += tests/efl_mono/libefl_mono_test.dll tests/efl_mono/dummy_test_object.eo.cs tests/efl_mono/dummy_child.eo.cs tests/efl_mono/dummy_numberwrapper.eo.cs tests/efl_mono/dummy_test_object.eo.c tests/efl_mono/dummy_child.eo.c tests/efl_mono/dummy_numberwrapper.eo.c tests/efl_mono/dummy_test_object.eo.h tests/efl_mono/dummy_child.eo.h tests/efl_mono/dummy_numberwrapper.eo.h tests/efl_mono/efl_mono.config
endif
return true;
if (!as_generator(
- scope_tab << "System.Threading.Tasks.Task<eina.Value> " << name_helpers::managed_async_method_name(f) << "(" << *(parameter << ",") <<
+ scope_tab << "System.Threading.Tasks.Task<Eina.Value> " << name_helpers::managed_async_method_name(f) << "(" << *(parameter << ",") <<
" System.Threading.CancellationToken token=default(System.Threading.CancellationToken));\n"
).generate(sink, f.parameters, context))
return false;
std::transform(f.parameters.begin(), f.parameters.end(), std::back_inserter(param_forwarding), parameter_forwarding);
if(!as_generator(
- scope_tab << "public System.Threading.Tasks.Task<eina.Value> " << name_helpers::managed_async_method_name(f) << "(" << *(parameter << ",") << " System.Threading.CancellationToken token)\n"
+ scope_tab << "public System.Threading.Tasks.Task<Eina.Value> " << name_helpers::managed_async_method_name(f) << "(" << *(parameter << ",") << " System.Threading.CancellationToken token=default(System.Threading.CancellationToken))\n"
<< scope_tab << "{\n"
- << scope_tab << scope_tab << "eina.Future future = " << name_helpers::managed_method_name(f) << "(" << (string % ",") << ");\n"
- << scope_tab << scope_tab << "return efl.eo.Globals.WrapAsync(future, token);\n"
+ << scope_tab << scope_tab << "Eina.Future future = " << name_helpers::managed_method_name(f) << "(" << (string % ",") << ");\n"
+ << scope_tab << scope_tab << "return Efl.Eo.Globals.WrapAsync(future, token);\n"
<< scope_tab << "}\n"
).generate(sink, std::make_tuple(f.parameters, param_forwarding), context))
return false;
|| full_name == "Eina.Slice"
|| full_name == "Eina.Rw_Slice"
|| full_name == "Eina.Promise"
+ || full_name == "Eina.Value"
+ || full_name == "Eina.Value_Type"
|| full_name == "Eina.Future";
}
(
"public enum " << string << "\n{\n"
)
- .generate(sink, name_helpers::enum_managed_name(enum_), context))
+ .generate(sink, name_helpers::typedecl_managed_name(enum_), context))
return false;
// iterate enum fiels
for(auto first = std::begin(enum_.fields)
, last = std::end(enum_.fields); first != last; ++first)
{
- auto name = (*first).name;
+ auto name = name_helpers::enum_field_managed_name((*first).name);
auto literal = (*first).value.literal;
- name[0] = std::toupper(name[0]); // Hack to allow 'static' as a field name
if (!as_generator
(
documentation << string << " = " << string << ",\n"
{"bool", [&arg] { return arg + " != IntPtr.Zero"; }}
, {"int", [&arg] { return arg + ".ToInt32()"; }}
, {"uint", [&arg] { return "(uint)" + arg + ".ToInt32()";}}
- , {"string", [&arg] { return "eina.StringConversion.NativeUtf8ToManagedString(" + arg + ")"; }}
- , {"Eina.Error", [&arg] { return "(eina.Error)Marshal.PtrToStructure(" + arg + ", typeof(eina.Error))"; }}
+ , {"string", [&arg] { return "Eina.StringConversion.NativeUtf8ToManagedString(" + arg + ")"; }}
+ , {"Eina.Error", [&arg] { return "(Eina.Error)Marshal.PtrToStructure(" + arg + ", typeof(Eina.Error))"; }}
};
std::string full_type_name = name_helpers::type_full_eolian_name(regular);
}
};
+/*
+ * Generates a struct wrapping the argument of a given event.
+ */
struct event_argument_wrapper_generator
{
template<typename OutputIterator, typename Context>
}
} const event_argument_wrapper {};
+/*
+ * Generates an event declaration as a C# Interface member.
+ * In regular/abstract classes they are declared directly in their
+ * implementation in event_definition_generator.
+ */
struct event_declaration_generator
{
template<typename OutputIterator, typename Context>
{
std::string wrapper_args_type;
std::string evt_name = name_helpers::managed_event_name(evt.name);
- std::string evt_args_name = name_helpers::managed_event_args_name(evt);
- efl::eina::optional<grammar::attributes::type_def> etype = evt.type;
- if (etype.is_engaged())
- wrapper_args_type = "<" + evt_args_name + ">";
+ if (evt.type.is_engaged())
+ wrapper_args_type = "<" + name_helpers::managed_event_args_name(evt) + ">";
if (!as_generator(
documentation(1)
struct event_registration_generator
{
- attributes::klass_def const* klass;
+ attributes::klass_def const& klass;
+ attributes::klass_def const& leaf_klass;
+ bool is_inherited_event;
+
template<typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::event_def const& evt, Context const& context) const
{
std::string wrapper_event_name;
- if (klass)
- wrapper_event_name = name_helpers::translate_inherited_event_name(evt, *klass);
+ if (is_inherited_event && !helpers::is_unique_event(evt, leaf_klass))
+ wrapper_event_name = name_helpers::translate_inherited_event_name(evt, klass);
else
wrapper_event_name = name_helpers::managed_event_name(evt.name);
return as_generator(scope_tab << scope_tab << "evt_" << wrapper_event_name << "_delegate = "
- << "new efl.Event_Cb(on_" << wrapper_event_name << "_NativeCallback);\n"
+ << "new Efl.EventCb(on_" << wrapper_event_name << "_NativeCallback);\n"
).generate(sink, attributes::unused, context);
}
};
struct event_registration_parameterized
{
- event_registration_generator operator()(attributes::klass_def const* klass=NULL) const
+ event_registration_generator operator()(attributes::klass_def const& klass, attributes::klass_def const& leaf_klass) const
{
- return {klass};
+ bool is_inherited_event = klass != leaf_klass;
+ return {klass, leaf_klass, is_inherited_event};
}
} const event_registration;
struct event_definition_generator
{
attributes::klass_def const& klass;
+ attributes::klass_def const& leaf_klass;
bool is_inherited_event;
template<typename OutputIterator, typename Context>
{
std::string managed_evt_name = name_helpers::managed_event_name(evt.name);
+ bool is_unique = helpers::is_unique_event(evt, leaf_klass);
+ bool use_explicit_impl = is_inherited_event && !is_unique;
+
+ // The name of the public event that goes in the public API.
std::string wrapper_evt_name;
- if (is_inherited_event)
+ if (use_explicit_impl)
wrapper_evt_name = name_helpers::translate_inherited_event_name(evt, klass);
else
wrapper_evt_name = managed_evt_name;
if (is_inherited_event)
klass_name = name_helpers::klass_full_interface_name(klass);
else
- klass_name = name_helpers::klass_interface_name(klass);
-
+ klass_name = name_helpers::klass_concrete_name(klass);
- std::string upper_c_name = utils::to_uppercase(evt.c_name);
std::string wrapper_args_type = "EventArgs";
std::string wrapper_args_template = "";
std::string event_args = "EventArgs args = EventArgs.Empty;\n";
- std::string visibility = is_inherit_context(context) ? "protected" : "private";
efl::eina::optional<grammar::attributes::type_def> etype = evt.type;
event_args = arg_initializer;
}
- // Wrapper event declaration
+ if(!as_generator("private static object " << wrapper_evt_name << "Key = new object();\n")
+ .generate(sink, attributes::unused, context))
+ return false;
+
if(!as_generator(documentation(1)).generate(sink, evt, context))
return false;
- if(!as_generator(
- scope_tab << visibility << " event EventHandler" << wrapper_args_template << " " << wrapper_evt_name << ";\n"
- << scope_tab << "///<summary>Method to raise event "<< wrapper_evt_name << ".</summary>\n"
- << scope_tab << visibility << " void On_" << wrapper_evt_name << "(" << wrapper_args_type << " e)\n"
- << scope_tab << "{\n"
- << scope_tab << scope_tab << "EventHandler" << wrapper_args_template << " evt;\n"
- << scope_tab << scope_tab << "lock (eventLock) {\n"
- << scope_tab << scope_tab << scope_tab << "evt = " << wrapper_evt_name << ";\n"
- << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << "if (evt != null) { evt(this, e); }\n"
- << scope_tab << "}\n"
- << scope_tab << "private void on_" << wrapper_evt_name << "_NativeCallback(System.IntPtr data, ref efl.Event_StructInternal evt)\n"
+ // Visible event declaration. Either a regular class member or an explicit interface implementation.
+ if (klass.type == attributes::class_type::interface_ || klass.type == attributes::class_type::mixin)
+ {
+ // Public event implementation.
+ if (!as_generator(
+ scope_tab << (!use_explicit_impl ? "public " : " ") << "event EventHandler" << wrapper_args_template << " " << (use_explicit_impl ? (klass_name + ".") : "") << managed_evt_name << "\n"
+ ).generate(sink, attributes::unused, context))
+ return false;
+ }
+ else // For inheritable classes event handling.
+ {
+ // We may have inherited an event with the same name as this concrete event, thus
+ // the concrete event would "hide" the interface one, requiring the new keyword.
+ std::string visibility = "public ";
+ if (!is_unique)
+ visibility += "new ";
+
+ if (!as_generator(
+ scope_tab << visibility << "event EventHandler" << wrapper_args_template << " " << wrapper_evt_name << "\n"
+ ).generate(sink, attributes::unused, context))
+ return false;
+ }
+
+ if (!generate_event_add_remove(sink, evt, wrapper_evt_name, context))
+ return false;
+
+ if (!generate_event_trigger(sink, wrapper_evt_name, wrapper_args_type, wrapper_args_template, context))
+ return false;
+
+ // Store the delegate for this event in this instance. This is initialized in register_event_proxies()
+ // We can't initialize them directly here as they depend on the member methods being valid (i.e.
+ // the constructor being called).
+ if (!as_generator(scope_tab << "Efl.EventCb evt_" << wrapper_evt_name << "_delegate;\n").generate(sink, attributes::unused, context))
+ return false;
+
+ // Callback to be given to C's callback_priority_add
+ if (!as_generator(
+ scope_tab << "private void on_" << wrapper_evt_name << "_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << event_args
<< scope_tab << scope_tab << "try {\n"
<< scope_tab << scope_tab << scope_tab << "On_" << wrapper_evt_name << "(args);\n"
<< scope_tab << scope_tab << "} catch (Exception e) {\n"
- << scope_tab << scope_tab << scope_tab << "eina.Log.Error(e.ToString());\n"
- << scope_tab << scope_tab << scope_tab << "eina.Error.Set(eina.Error.EFL_ERROR);\n"
+ << scope_tab << scope_tab << scope_tab << "Eina.Log.Error(e.ToString());\n"
+ << scope_tab << scope_tab << scope_tab << "Eina.Error.Set(Eina.Error.EFL_ERROR);\n"
<< scope_tab << scope_tab << "}\n"
- << scope_tab << "}\n"
- << scope_tab << "efl.Event_Cb evt_" << wrapper_evt_name << "_delegate;\n"
- << scope_tab << "event EventHandler" << wrapper_args_template << " " << klass_name << "." << managed_evt_name << "{\n")
- .generate(sink, NULL, context))
- return false;
-
- if (!as_generator(
- scope_tab << scope_tab << "add {\n"
- << scope_tab << scope_tab << scope_tab << "lock (eventLock) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "string key = \"_" << upper_c_name << "\";\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "if (add_cpp_event_handler(key, this.evt_" << wrapper_evt_name << "_delegate))\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << wrapper_evt_name << " += value;\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "else\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Error adding proxy for event {key}\");\n"
- << scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
- << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << "remove {\n"
- << scope_tab << scope_tab << scope_tab << "lock (eventLock) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "string key = \"_" << upper_c_name << "\";\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "if (remove_cpp_event_handler(key, this.evt_" << wrapper_evt_name << "_delegate))\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << wrapper_evt_name << " -= value;\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "else\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Error removing proxy for event {key}\");\n"
- << scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
- << scope_tab << scope_tab << "}\n"
- << scope_tab << "}\n")
- .generate(sink, NULL, context))
- return false;
+ << scope_tab << "}\n\n"
+ ).generate(sink, attributes::unused, context))
+ return false;
return true;
}
+
+ template<typename OutputIterator, typename Context>
+ bool generate_event_trigger(OutputIterator sink
+ , std::string const& event_name
+ , std::string const& event_args_type
+ , std::string const& event_template_args
+ , Context context) const
+ {
+ auto delegate_type = "EventHandler" + event_template_args;
+ if (!as_generator(
+ scope_tab << "///<summary>Method to raise event "<< event_name << ".</summary>\n"
+ << scope_tab << "public void On_" << event_name << "(" << event_args_type << " e)\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << delegate_type << " evt;\n"
+ << scope_tab << scope_tab << "lock (eventLock) {\n"
+ << scope_tab << scope_tab << "evt = (" << delegate_type << ")eventHandlers[" << event_name << "Key];\n"
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << "evt?.Invoke(this, e);\n"
+ << scope_tab << "}\n"
+ ).generate(sink, nullptr, context))
+ return false;
+
+ return true;
+ }
+
+ template<typename OutputIterator, typename Context>
+ bool generate_event_add_remove(OutputIterator sink, attributes::event_def const &evt, const std::string& event_name, Context context) const
+ {
+ std::string upper_c_name = utils::to_uppercase(evt.c_name);
+ return as_generator(
+ scope_tab << "{\n"
+ << scope_tab << scope_tab << "add {\n"
+ << scope_tab << scope_tab << scope_tab << "lock (eventLock) {\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "string key = \"_" << upper_c_name << "\";\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "if (add_cpp_event_handler(key, this.evt_" << event_name << "_delegate)) {\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "eventHandlers.AddHandler(" << event_name << "Key , value);\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "} else\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "Eina.Log.Error($\"Error adding proxy for event {key}\");\n"
+ << scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << "remove {\n"
+ << scope_tab << scope_tab << scope_tab << "lock (eventLock) {\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "string key = \"_" << upper_c_name << "\";\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "if (remove_cpp_event_handler(key, this.evt_" << event_name << "_delegate)) { \n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "eventHandlers.RemoveHandler(" << event_name << "Key , value);\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "} else\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "Eina.Log.Error($\"Error removing proxy for event {key}\");\n"
+ << scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << "}\n"
+ ).generate(sink, attributes::unused, context);
+ }
};
struct event_definition_parameterized
{
- event_definition_generator operator()(attributes::klass_def const& klass, bool is_inherited_event=false) const
+ event_definition_generator operator()(attributes::klass_def const& klass, attributes::klass_def const& leaf_klass) const
{
- return {klass, is_inherited_event};
+ bool is_inherited_event = klass != leaf_klass;
+ return {klass, leaf_klass, is_inherited_event};
}
} const event_definition;
<< ")\n"
<< scope_tab << "{\n"
/****/
- << scope_tab << scope_tab << "eina.Log.Debug(\"function " << string << " was called\");\n"
+ << scope_tab << scope_tab << "Eina.Log.Debug(\"function " << string << " was called\");\n"
/****/
- << scope_tab << scope_tab << "efl.eo.IWrapper wrapper = efl.eo.Globals.data_get(pd);\n"
+ << scope_tab << scope_tab << "Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);\n"
<< scope_tab << scope_tab << "if(wrapper != null) {\n"
<< scope_tab << scope_tab << scope_tab << eolian_mono::native_function_definition_preamble()
<< scope_tab << scope_tab << scope_tab << "try {\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << (return_type != " void" ? "_ret_var = " : "") << "((" << klass_inherit_name << ")wrapper)." << string
<< "(" << (native_argument_invocation % ", ") << ");\n"
<< scope_tab << scope_tab << scope_tab << "} catch (Exception e) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Warning($\"Callback error: {e.ToString()}\");\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Error.Set(eina.Error.EFL_ERROR);\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "Eina.Log.Warning($\"Callback error: {e.ToString()}\");\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "Eina.Error.Set(Eina.Error.EFL_ERROR);\n"
<< scope_tab << scope_tab << scope_tab << "}\n"
<< eolian_mono::native_function_definition_epilogue(*klass)
<< scope_tab << scope_tab << "} else {\n"
<< scope_tab << scope_tab << scope_tab << (return_type != " void" ? "return " : "") << string
- << "(efl.eo.Globals.efl_super(obj, " << klass_inherit_name << ".klass)" << *(", " << argument) << ");\n"
+ << "(Efl.Eo.Globals.efl_super(obj, " << klass_inherit_name << ".klass)" << *(", " << argument) << ");\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << "}\n"
)
bool generate(OutputIterator sink, attributes::function_def const& f, Context const& context) const
{
EINA_CXX_DOM_LOG_DBG(eolian_mono::domain) << "function_definition_generator: " << f.c_name << std::endl;
- if(do_super && f.is_static) // Static methods goes only on Concrete classes.
+ if(!do_super && f.is_static) // Static methods goes only on Concrete classes.
return true;
if(blacklist::is_function_blacklisted(f.c_name))
return true;
if(!as_generator
("\n\n" << scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(context).actual_library_name(f.filename) << ")]\n"
<< scope_tab << eolian_mono::marshall_annotation(true)
- << " private static extern "
+ << (do_super ? " protected " : " private ") << "static extern "
<< eolian_mono::marshall_type(true)
<< " " << string
<< "(System.IntPtr obj"
(documentation(1)).generate(sink, f, context))
return false;
+ std::string self = "this.NativeHandle";
+
+ // inherited is set in the constructor, true if this instance is from a pure C# class (not generated).
+ if (do_super && !f.is_static)
+ self = "(inherited ? Efl.Eo.Globals.efl_super(" + self + ", this.NativeClass) : " + self + ")";
+ else
+ self = name_helpers::klass_get_full_name(f.klass) + "()";
+
if(!as_generator
- (scope_tab << (do_super ? "virtual " : "") << "public " << (f.is_static ? "static " : "") << return_type << " " << string << "(" << (parameter % ", ")
+ (scope_tab << ((do_super && !f.is_static) ? "virtual " : "") << "public " << (f.is_static ? "static " : "") << return_type << " " << string << "(" << (parameter % ", ")
<< ") {\n "
<< eolian_mono::function_definition_preamble() << string << "("
- << (do_super ? "efl.eo.Globals.efl_super(" : "")
- << (f.is_static ? name_helpers::klass_get_full_name(f.klass) + "()": "this.raw_handle")
- << (do_super ? ", this.raw_klass)" : "")
+ << self
<< *(", " << argument_invocation ) << ");\n"
<< eolian_mono::function_definition_epilogue()
<< " }\n")
return false;
if (!as_generator(
- scope_tab << scope_tab << "//Placeholder in variables\n"
- << *(scope_tab << scope_tab << native_convert_in_variable << "\n")
- << scope_tab << scope_tab << "//Placeholder out variables\n"
- << *(scope_tab << scope_tab << native_convert_out_variable << "\n")
- << scope_tab << scope_tab << "//Function pointer wrappers\n"
- << *(scope_tab << scope_tab << native_convert_function_pointer << "\n")
- << scope_tab << scope_tab << "//Return variable and function call\n"
- << scope_tab << scope_tab << scope_tab << native_convert_return_variable << "\n"
+ *(scope_tab << scope_tab << native_convert_in_variable)
+ << *(scope_tab << scope_tab << native_convert_out_variable)
+ << *(scope_tab << scope_tab << native_convert_function_pointer)
+ << scope_tab << scope_tab << scope_tab << native_convert_return_variable
).generate(sink, std::make_tuple(f.parameters, f.parameters, f.parameters, f.return_type), context))
return false;
return false;
if (!as_generator(
- scope_tab << scope_tab << "//Placeholder in variables\n"
- << *(scope_tab << scope_tab << convert_in_variable << "\n")
- << scope_tab << scope_tab << "//Placeholder out variables\n"
- << *(scope_tab << scope_tab << convert_out_variable << "\n")
- << scope_tab << scope_tab << "//Function pointers handling\n"
- << *(scope_tab << scope_tab << convert_function_pointer << "\n")
- << scope_tab << scope_tab << "//Return variable and function call\n"
+ *(scope_tab << scope_tab << convert_in_variable)
+ << *(scope_tab << scope_tab << convert_out_variable)
+ << *(scope_tab << scope_tab << convert_function_pointer)
<< scope_tab << scope_tab << convert_return_variable
).generate(sink, std::make_tuple(f.parameters, f.parameters, f.parameters, f.return_type), context))
return false;
return false;
if (!as_generator(
- scope_tab << scope_tab << "//Assigning out variables\n"
- << *(scope_tab << scope_tab << native_convert_out_assign(*klass) << "\n")
- << scope_tab << scope_tab << "//Placeholder in ptr variables that need to be updated\n"
- << *(scope_tab << scope_tab << native_convert_in_ptr_assign << "\n")
- << scope_tab << scope_tab << "//Converting return variable\n"
+ *(scope_tab << scope_tab << native_convert_out_assign(*klass))
+ << *(scope_tab << scope_tab << native_convert_in_ptr_assign)
<< scope_tab << scope_tab << native_convert_return(*klass)
).generate(sink, std::make_tuple(f.parameters, f.parameters, f.return_type), context))
return false;
bool generate(OutputIterator sink, attributes::function_def const& f, Context const& context) const
{
if (!as_generator(
- scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
- << scope_tab << scope_tab << "//Assigning out variables\n"
- << *(scope_tab << scope_tab << convert_out_assign << "\n")
- << scope_tab << scope_tab << "//Placeholder in ptr variables that need to be updated\n"
- << *(scope_tab << scope_tab << convert_in_ptr_assign << "\n")
- << scope_tab << scope_tab << "//Converting return variable\n"
+ scope_tab << scope_tab << "Eina.Error.RaiseIfOccurred();\n"
+ << *(scope_tab << scope_tab << convert_out_assign)
+ << *(scope_tab << scope_tab << convert_in_ptr_assign)
<< scope_tab << scope_tab << convert_return
).generate(sink, std::make_tuple(f.parameters, f.parameters, f.return_type), context))
return false;
if (!name_helpers::open_namespaces(sink, f.namespaces, funcptr_ctx))
return false;
+ std::string f_name = name_helpers::typedecl_managed_name(f);
+
// C# visible delegate
if (!as_generator(documentation
<< "public delegate " << type << " " << string
<< "(" << (parameter % ", ") << ");\n")
- .generate(sink, std::make_tuple(f, f.return_type, name_helpers::escape_keyword(f.name), f.parameters), funcptr_ctx))
+ .generate(sink, std::make_tuple(f, f.return_type, f_name, f.parameters), funcptr_ctx))
return false;
// "Internal" delegate, 1-to-1 with the Unamaged function type
if (!as_generator(marshall_native_annotation(true)
- << "internal delegate " << marshall_type(true) << " " << string // public?
+ << "public delegate " << marshall_type(true) << " " << string // public?
<< "Internal(IntPtr data" << *grammar::attribute_reorder<-1, -1>((", " << marshall_native_annotation << " " << marshall_parameter)) << ");\n")
- .generate(sink, std::make_tuple(f.return_type, f.return_type, name_helpers::escape_keyword(f.name), f.parameters), funcptr_ctx))
+ .generate(sink, std::make_tuple(f.return_type, f.return_type, f_name, f.parameters), funcptr_ctx))
return false;
- std::string f_name = name_helpers::escape_keyword(f.name);
// Wrapper type, with callback matching the Unamanaged one
if (!as_generator("internal class " << f_name << "Wrapper\n"
<< "{\n\n"
<< scope_tab << "private " << f_name << "Internal _cb;\n"
<< scope_tab << "private IntPtr _cb_data;\n"
- << scope_tab << "private Eina_Free_Cb _cb_free_cb;\n\n"
+ << scope_tab << "private EinaFreeCb _cb_free_cb;\n\n"
- << scope_tab << "internal " << f_name << "Wrapper (" << f_name << "Internal _cb, IntPtr _cb_data, Eina_Free_Cb _cb_free_cb)\n"
+ << scope_tab << "internal " << f_name << "Wrapper (" << f_name << "Internal _cb, IntPtr _cb_data, EinaFreeCb _cb_free_cb)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "this._cb = _cb;\n"
<< scope_tab << scope_tab << "this._cb_data = _cb_data;\n"
<< scope_tab << scope_tab << "try {\n"
<< scope_tab << scope_tab << scope_tab << (return_type != " void" ? "_ret_var = " : "") << "cb(" << (native_argument_invocation % ", ") << ");\n"
<< scope_tab << scope_tab << "} catch (Exception e) {\n"
- << scope_tab << scope_tab << scope_tab << "eina.Log.Warning($\"Callback error: {e.ToString()}\");\n"
- << scope_tab << scope_tab << scope_tab << "eina.Error.Set(eina.Error.EFL_ERROR);\n"
+ << scope_tab << scope_tab << scope_tab << "Eina.Log.Warning($\"Callback error: {e.ToString()}\");\n"
+ << scope_tab << scope_tab << scope_tab << "Eina.Error.Set(Eina.Error.EFL_ERROR);\n"
<< scope_tab << scope_tab << "}\n"
<< native_function_definition_epilogue(nullptr)
<< scope_tab << "}\n"
#ifdef _WIN32
(scope_tab << scope_tab << "descs[" << index << "].api_func = Marshal.StringToHGlobalAnsi(\"" << string << "\");\n"
#else
- (scope_tab << scope_tab << "descs[" << index << "].api_func = efl.eo.Globals.dlsym(efl.eo.Globals.RTLD_DEFAULT, \"" << string << "\");\n"
+ (scope_tab << scope_tab << "descs[" << index << "].api_func = Efl.Eo.Globals.dlsym(Efl.Eo.Globals.RTLD_DEFAULT, \"" << string << "\");\n"
#endif
<< scope_tab << scope_tab << "descs[" << index << "].func = Marshal.GetFunctionPointerForDelegate(" << name_helpers::klass_native_inherit_name(*klass) << "." << string << "_static_delegate);\n"
)
return false;
}
+// While klass_def has immediate_inherits, we need a way to get all interfaces inherited by an interface
+// either directly or through another interface.
+std::set<attributes::klass_name, attributes::compare_klass_name_by_name> interface_inherits(attributes::klass_def const& cls)
+{
+ std::set<attributes::klass_name, attributes::compare_klass_name_by_name> inherits;
+
+ std::function<void(attributes::klass_name const&)> inherit_algo =
+ [&] (attributes::klass_name const& klass)
+ {
+ // TODO we could somehow cache klass_def instantiations
+ attributes::klass_def c(get_klass(klass, cls.unit), cls.unit);
+ for(auto&& inherit : c.immediate_inherits)
+ {
+ switch(inherit.type)
+ {
+ case attributes::class_type::mixin:
+ case attributes::class_type::interface_:
+ inherits.insert(inherit);
+ inherit_algo(inherit);
+ break;
+ case attributes::class_type::regular:
+ case attributes::class_type::abstract_:
+ inherit_algo(inherit);
+ default:
+ break;
+ }
+ }
+ };
+
+ inherit_algo(get_klass_name(cls));
+
+
+ return inherits;
+}
+
+// Returns the set of interfaces implemented by this type that haven't been implemented
+// by a regular parent class.
+std::set<attributes::klass_name, attributes::compare_klass_name_by_name> non_implemented_interfaces(attributes::klass_def const& cls)
+{
+ std::set<attributes::klass_name, attributes::compare_klass_name_by_name> implemented_interfaces;
+ std::set<attributes::klass_name, attributes::compare_klass_name_by_name> interfaces;
+
+ std::function<void(attributes::klass_name const&, bool)> inherit_algo =
+ [&] (attributes::klass_name const& klass, bool is_implemented)
+ {
+ // TODO we could somehow cache klass_def instantiations
+ attributes::klass_def c(get_klass(klass, cls.unit), cls.unit);
+ for(auto&& inherit : c.immediate_inherits)
+ {
+ switch(inherit.type)
+ {
+ case attributes::class_type::mixin:
+ case attributes::class_type::interface_:
+ interfaces.insert(inherit);
+ if (is_implemented)
+ implemented_interfaces.insert(inherit);
+ inherit_algo(inherit, is_implemented);
+ break;
+ case attributes::class_type::abstract_:
+ case attributes::class_type::regular:
+ inherit_algo(inherit, true);
+ default:
+ break;
+ }
+ }
+ };
+
+ inherit_algo(get_klass_name(cls), false);
+
+ for (auto&& inherit : implemented_interfaces)
+ interfaces.erase(inherit);
+
+
+ return interfaces;
+}
+
+
+/*
+ * Determines whether this class has any regular ancestor or not
+ */
+bool has_regular_ancestor(attributes::klass_def const& cls)
+{
+ auto inherits = cls.inherits;
+ std::function<bool(attributes::klass_name const&)> is_regular =
+ [&] (attributes::klass_name const& klass)
+ {
+ return klass.type == attributes::class_type::regular || klass.type == attributes::class_type::abstract_;
+ };
+
+ return std::any_of(inherits.begin(), inherits.end(), is_regular);
+}
+
+/*
+ * Gets all methods that this class should implement (i.e. that come from an unimplemented interface/mixin and the class itself)
+ */
+std::vector<attributes::function_def> get_all_implementable_methods(attributes::klass_def const& cls)
+{
+ std::vector<attributes::function_def> ret;
+
+ std::copy(cls.functions.begin(), cls.functions.end(), std::back_inserter(ret));
+
+ // Non implemented interfaces
+ std::set<attributes::klass_name, attributes::compare_klass_name_by_name> implemented_interfaces;
+ std::set<attributes::klass_name, attributes::compare_klass_name_by_name> interfaces;
+ std::function<void(attributes::klass_name const&, bool)> inherit_algo =
+ [&] (attributes::klass_name const &klass, bool is_implemented)
+ {
+ attributes::klass_def c(get_klass(klass, cls.unit), cls.unit);
+ for (auto&& inherit: c.immediate_inherits)
+ {
+ switch(inherit.type)
+ {
+ case attributes::class_type::mixin:
+ case attributes::class_type::interface_:
+ interfaces.insert(inherit);
+ if (is_implemented)
+ implemented_interfaces.insert(inherit);
+ inherit_algo(inherit, is_implemented);
+ break;
+ case attributes::class_type::abstract_:
+ case attributes::class_type::regular:
+ inherit_algo(inherit, true);
+ default:
+ break;
+ }
+ }
+ };
+
+ inherit_algo(attributes::get_klass_name(cls), false);
+
+ for (auto&& inherit : implemented_interfaces)
+ interfaces.erase(inherit);
+
+ for (auto&& inherit : interfaces)
+ {
+ attributes::klass_def klass(get_klass(inherit, cls.unit), cls.unit);
+ std::copy(klass.functions.cbegin(), klass.functions.cend(), std::back_inserter(ret));
+ }
+
+ return ret;
+}
+
+/*
+ * Checks whether the given is unique going up the inheritance tree from leaf_klass
+ */
+inline bool is_unique_event(attributes::event_def const& evt
+ , attributes::klass_def const& leaf_klass)
+{
+ auto events = leaf_klass.get_all_events();
+ int i = 1;
+ return !std::any_of(events.cbegin(), events.cend(),
+ [&evt, &i](const attributes::event_def &other) {
+ return evt.name == other.name && i++ == 2;
+ });
+}
+
+
} // namespace helpers
} // namespace eolian_mono
#include "grammar/integral.hpp"
#include "grammar/generator.hpp"
#include "grammar/klass_def.hpp"
+#include "grammar/attribute_conditional.hpp"
#include "blacklist.hh"
#include "grammar/indentation.hpp"
{
return as_generator(
scope_tab << "///<summary>Casts obj into an instance of this type.</summary>\n"
- << scope_tab << "public static " << name_helpers::klass_interface_name(cls) << " static_cast(efl.IObject obj)\n"
+ << scope_tab << "public " << (helpers::has_regular_ancestor(cls) ? "new " : "") <<"static " << name_helpers::klass_concrete_name(cls) << " static_cast(Efl.Object obj)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "if (obj == null)\n"
<< scope_tab << scope_tab << scope_tab << "throw new System.ArgumentNullException(\"obj\");\n"
- << scope_tab << scope_tab << "return new " << name_helpers::klass_concrete_name(cls) << "(obj.raw_handle);\n"
+ << scope_tab << scope_tab << "return new " << name_helpers::klass_concrete_name(cls) << "(obj.NativeHandle);\n"
<< scope_tab << "}\n"
).generate(sink, nullptr, context);
}
scope_tab << "///<summary>Verifies if the given object is equal to this one.</summary>\n"
<< scope_tab << "public override bool Equals(object obj)\n"
<< scope_tab << "{\n"
- << scope_tab << scope_tab << "var other = obj as efl.IObject;\n"
+ << scope_tab << scope_tab << "var other = obj as Efl.Object;\n"
<< scope_tab << scope_tab << "if (other == null)\n"
<< scope_tab << scope_tab << scope_tab << "return false;\n"
- << scope_tab << scope_tab << "return this.raw_handle == other.raw_handle;\n"
+ << scope_tab << scope_tab << "return this.NativeHandle == other.NativeHandle;\n"
<< scope_tab << "}\n"
<< scope_tab << "///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>\n"
<< scope_tab << "public override int GetHashCode()\n"
<< scope_tab << "{\n"
- << scope_tab << scope_tab << "return this.raw_handle.ToInt32();\n"
+ << scope_tab << scope_tab << "return this.NativeHandle.ToInt32();\n"
<< scope_tab << "}\n"
<< scope_tab << "///<summary>Turns the native pointer into a string representation.</summary>\n"
<< scope_tab << "public override String ToString()\n"
<< scope_tab << "{\n"
- << scope_tab << scope_tab << "return $\"{this.GetType().Name}@[{this.raw_handle.ToInt32():x}]\";\n"
+ << scope_tab << scope_tab << "return $\"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]\";\n"
<< scope_tab << "}\n"
).generate(sink, nullptr, context);
}
/* Get the actual number of functions of a class, checking for blacklisted ones */
static std::size_t
-get_inheritable_function_count(grammar::attributes::klass_def const& cls)
+get_implementable_function_count(grammar::attributes::klass_def const& cls)
{
- auto methods = cls.get_all_methods();
+ auto methods = helpers::get_all_implementable_methods(cls);
return std::count_if(methods.cbegin(), methods.cend(), [](grammar::attributes::function_def const& func)
{
return !blacklist::is_function_blacklisted(func.c_name) && !func.is_static;
switch(cls.type)
{
case attributes::class_type::regular:
+ class_type = "class";
+ suffix = "CLASS";
+ break;
case attributes::class_type::abstract_:
class_type = "class";
suffix = "CLASS";
auto methods = cls.get_all_methods();
// Interface class
+ if(class_type == "interface")
{
auto iface_cxt = context_add_tag(class_context{class_context::interface}, context);
for(auto first = std::begin(cls.immediate_inherits)
, last = std::end(cls.immediate_inherits); first != last; ++first)
{
- if(!as_generator("\n" << scope_tab << string << " ,").generate(sink, name_helpers::klass_full_interface_name(*first), iface_cxt))
- return false;
+ if(first->type != attributes::class_type::regular && first->type != attributes::class_type::abstract_)
+ if(!as_generator("\n" << scope_tab << string << " ,").generate(sink, name_helpers::klass_full_interface_name(*first), iface_cxt))
+ return false;
}
- if(!as_generator("\n" << scope_tab << "efl.eo.IWrapper, IDisposable").generate(sink, attributes::unused, iface_cxt))
+ if(!as_generator("\n" << scope_tab << "Efl.Eo.IWrapper, IDisposable").generate(sink, attributes::unused, iface_cxt))
return false;
if(!as_generator("\n{\n").generate(sink, attributes::unused, iface_cxt))
for (auto &&p : cls.parts)
if (!as_generator(
documentation(1)
- << name_helpers::klass_full_interface_name(p.klass) << " " << utils::capitalize(p.name) << "{ get;}\n"
+ << name_helpers::klass_full_concrete_or_interface_name(p.klass) << " " << utils::capitalize(p.name) << "{ get;}\n"
).generate(sink, p, iface_cxt))
return false;
// End of interface declaration
if(!as_generator("}\n").generate(sink, attributes::unused, iface_cxt)) return false;
+
}
- // Concrete class
- // if(class_type == "class")
+ // Events arguments go in the top namespace to avoid the Concrete suffix clutter in interface events.
+ // Regular/abstract class events go here too for consistency.
+ if(!as_generator(*(event_argument_wrapper)).generate(sink, cls.events, context))
+ return false;
+
+ bool root = !helpers::has_regular_ancestor(cls);
+ std::set<attributes::klass_name, attributes::compare_klass_name_by_name> inherit_interfaces = helpers::non_implemented_interfaces(cls);
+ std::vector<attributes::klass_name> inherit_classes;
+ std::copy_if(cls.immediate_inherits.begin(), cls.immediate_inherits.end()
+ , std::back_inserter(inherit_classes)
+ , [] (attributes::klass_name const& klass)
+ {
+ switch (klass.type)
+ {
+ case attributes::class_type::regular:
+ case attributes::class_type::abstract_:
+ return true;
+ default:
+ return false;
+ };
+ });
+
+ // Concrete class for interfaces, mixins, etc.
+ if(class_type != "class")
{
auto concrete_cxt = context_add_tag(class_context{class_context::concrete}, context);
auto concrete_name = name_helpers::klass_concrete_name(cls);
auto interface_name = name_helpers::klass_interface_name(cls);
+
if(!as_generator
(
documentation
- << "sealed public class " << concrete_name << " : " << interface_name << "\n{\n"
- << scope_tab << "System.IntPtr handle;\n"
- << scope_tab << "///<summary>Pointer to the native instance.</summary>\n"
- << scope_tab << "public System.IntPtr raw_handle {\n"
- << scope_tab << scope_tab << "get { return handle; }\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Pointer to the native class description.</summary>\n"
- << scope_tab << "public System.IntPtr raw_klass {\n"
- << scope_tab << scope_tab << "get { return efl.eo.Globals.efl_class_get(handle); }\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Delegate for function to be called from inside the native constructor.</summary>\n"
- << scope_tab << "public delegate void ConstructingMethod(" << interface_name << " obj);\n"
- << scope_tab << "///<summary>Returns the pointer the underlying Eo class object. Used internally on class methods.</summary>\n"
- << scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(concrete_cxt).actual_library_name(cls.filename)
- << ")] public static extern System.IntPtr\n"
+ << "sealed public class " << concrete_name << " : " << "\n"
+ << (klass_full_concrete_or_interface_name % ",") << "\n"
+ << (inherit_classes.size() > 0 ? ", " : "" ) << interface_name << "\n"
+ << scope_tab << *(", " << name_helpers::klass_full_concrete_or_interface_name) << "\n"
+ << "{\n"
+ ).generate(sink, std::make_tuple(cls, inherit_classes, inherit_interfaces), concrete_cxt))
+ return false;
+
+ if (!generate_fields(sink, cls, concrete_cxt))
+ return false;
+
+ if (!as_generator
+ (
+ scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(concrete_cxt).actual_library_name(cls.filename)
+ << ")] internal static extern System.IntPtr\n"
<< scope_tab << scope_tab << name_helpers::klass_get_name(cls) << "();\n"
- << (class_type == "class" ? "" : "/*")
- << scope_tab << "///<summary>Creates a new instance.</summary>\n"
- << scope_tab << "///<param>Parent instance.</param>\n"
- << scope_tab << "///<param>Delegate to call constructing methods that should be run inside the constructor.</param>\n"
- << scope_tab << "public " << concrete_name << "(efl.IObject parent = null, ConstructingMethod init_cb=null)\n"
- << scope_tab << "{\n"
- << scope_tab << scope_tab << "System.IntPtr klass = " << name_helpers::klass_get_name(cls) << "();\n"
- << scope_tab << scope_tab << "System.IntPtr parent_ptr = System.IntPtr.Zero;\n"
- << scope_tab << scope_tab << "if(parent != null)\n"
- << scope_tab << scope_tab << scope_tab << "parent_ptr = parent.raw_handle;\n"
- << scope_tab << scope_tab << "handle = efl.eo.Globals._efl_add_internal_start(\"file\", 0, klass, parent_ptr, 1, 0);\n"
- << scope_tab << scope_tab << "register_event_proxies();\n"
- << scope_tab << scope_tab << "if (init_cb != null) {\n"
- << scope_tab << scope_tab << scope_tab << "init_cb(this);\n"
- << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << "handle = efl.eo.Globals._efl_add_end(handle, 1, 0);\n" // replace handle with the actual final handle
- << scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
- << scope_tab << "}\n"
- << (class_type == "class" ? "" : "*/")
<< scope_tab << "///<summary>Constructs an instance from a native pointer.</summary>\n"
<< scope_tab << "public " << concrete_name << "(System.IntPtr raw)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "handle = raw;\n"
<< scope_tab << scope_tab << "register_event_proxies();\n"
<< scope_tab << "}\n"
- << scope_tab << "///<summary>Destructor.</summary>\n"
- << scope_tab << "~" << concrete_name << "()\n"
- << scope_tab << "{\n"
- << scope_tab << scope_tab << "Dispose(false);\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
- << scope_tab << "internal void Dispose(bool disposing)\n"
- << scope_tab << "{\n"
- << scope_tab << scope_tab << "if (handle != System.IntPtr.Zero) {\n"
- << scope_tab << scope_tab << scope_tab << "efl.eo.Globals.efl_unref(handle);\n"
- << scope_tab << scope_tab << scope_tab << "handle = System.IntPtr.Zero;\n"
- << scope_tab << scope_tab << "}\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
- << scope_tab << "public void Dispose()\n"
- << scope_tab << "{\n"
- << scope_tab << scope_tab << "Dispose(true);\n"
- << scope_tab << scope_tab << "GC.SuppressFinalize(this);\n"
- << scope_tab << "}\n"
)
- .generate(sink, cls, concrete_cxt))
+ .generate(sink, attributes::unused, concrete_cxt))
+ return false;
+
+ if (!generate_dispose_methods(sink, cls, concrete_cxt))
return false;
if (!generate_static_cast_method(sink, cls, concrete_cxt))
// Parts
if(!as_generator(*(part_definition))
- .generate(sink, cls.get_all_parts(), concrete_cxt)) return false;
+ .generate(sink, cls.parts, concrete_cxt)) return false;
// Concrete function definitions
+ auto implemented_methods = helpers::get_all_implementable_methods(cls);
if(!as_generator(*(function_definition))
- .generate(sink, methods, concrete_cxt)) return false;
+ .generate(sink, implemented_methods, concrete_cxt)) return false;
// Async wrappers
- if(!as_generator(*(async_function_definition)).generate(sink, methods, concrete_cxt))
- return false;
-
- if(!as_generator(*(event_argument_wrapper)).generate(sink, cls.events, context))
+ if(!as_generator(*(async_function_definition)).generate(sink, implemented_methods, concrete_cxt))
return false;
if(!as_generator("}\n").generate(sink, attributes::unused, concrete_cxt)) return false;
+
}
- // Inherit class
+ // Inheritable class
if(class_type == "class")
{
auto inherit_cxt = context_add_tag(class_context{class_context::inherit}, context);
- bool cls_has_string_return = has_string_return(cls);
- bool cls_has_stringshare_return = has_stringshare_return(cls);
-
- auto interface_name = name_helpers::klass_interface_name(cls);
- auto inherit_name = name_helpers::klass_inherit_name(cls);
- auto native_inherit_name = name_helpers::klass_native_inherit_name(cls);
-
- if(!as_generator
+ // Class header
+ if(!as_generator
(
documentation
- << "public " << class_type << " " << inherit_name << " : " << interface_name << "\n{\n"
- << scope_tab << "System.IntPtr handle;\n"
- << scope_tab << "internal static System.IntPtr klass = System.IntPtr.Zero;\n"
- << scope_tab << "private static readonly object klassAllocLock = new object();\n"
- << scope_tab << (cls_has_string_return ? ("internal Dictionary<String, IntPtr> cached_strings = new Dictionary<String, IntPtr>();") : "") << "\n"
- << scope_tab << (cls_has_stringshare_return ? ("internal Dictionary<String, IntPtr> cached_stringshares = new Dictionary<String, IntPtr>();") : "") << "\n"
- << scope_tab << "///<summary>Pointer to the native instance.</summary>\n"
- << scope_tab << "public System.IntPtr raw_handle {\n"
- << scope_tab << scope_tab << "get { return handle; }\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Pointer to the native class description.</summary>\n"
- << scope_tab << "public System.IntPtr raw_klass {\n"
- << scope_tab << scope_tab << "get { return klass; }\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Delegate for function to be called from inside the native constructor.</summary>\n"
- << scope_tab << "public delegate void ConstructingMethod(" << interface_name << " obj);\n"
- << scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(inherit_cxt).actual_library_name(cls.filename)
- << ")] private static extern System.IntPtr\n"
- << scope_tab << scope_tab << name_helpers::klass_get_name(cls) << "();\n"
- << scope_tab << "///<summary>Creates a new instance.</summary>\n"
- << scope_tab << "///<param>Parent instance.</param>\n"
- << scope_tab << "///<param>Delegate to call constructing methods that should be run inside the constructor.</param>\n"
- << scope_tab << "public " << inherit_name << "(efl.IObject parent = null, ConstructingMethod init_cb=null)\n"
- << scope_tab << "{\n"
- << scope_tab << scope_tab << "if (klass == System.IntPtr.Zero) {\n"
- << scope_tab << scope_tab << scope_tab << "lock (klassAllocLock) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "if (klass == System.IntPtr.Zero) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "klass = efl.eo.Globals.register_class(new efl.eo.Globals.class_initializer(" << native_inherit_name << ".class_initializer), \"" << cls.eolian_name << "\", " << name_helpers::klass_get_name(cls) << "());\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << "handle = efl.eo.Globals.instantiate_start(klass, parent);\n"
- << scope_tab << scope_tab << "register_event_proxies();\n"
- << scope_tab << scope_tab << "if (init_cb != null) {\n"
- << scope_tab << scope_tab << scope_tab << "init_cb(this);\n"
- << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << "efl.eo.Globals.data_set(this);\n"
- << scope_tab << scope_tab << "handle = efl.eo.Globals.instantiate_end(handle);\n"
- << scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Destructor.</summary>\n"
- << scope_tab << "~" << inherit_name << "()\n"
- << scope_tab << "{\n"
- << scope_tab << scope_tab << "Dispose(false);\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
- << scope_tab << "protected virtual void Dispose(bool disposing)\n"
- << scope_tab << "{\n"
- << scope_tab << scope_tab << "if (handle != System.IntPtr.Zero) {\n"
- << scope_tab << scope_tab << scope_tab << "efl.eo.Globals.efl_unref(handle);\n"
- << scope_tab << scope_tab << scope_tab << "handle = System.IntPtr.Zero;\n"
- << scope_tab << scope_tab << "}\n"
- << scope_tab << "}\n"
- << scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
- << scope_tab << "public void Dispose()\n"
- << scope_tab << "{\n"
- << scope_tab << (cls_has_string_return ? "efl.eo.Globals.free_dict_values(cached_strings);" : "") << "\n"
- << scope_tab << (cls_has_stringshare_return ? "efl.eo.Globals.free_stringshare_values(cached_stringshares);" : "") << "\n"
- << scope_tab << scope_tab << "Dispose(true);\n"
- << scope_tab << scope_tab << "GC.SuppressFinalize(this);\n"
- << scope_tab << "}\n"
- )
- .generate(sink, cls, inherit_cxt))
+ << "public " << class_type << " " << name_helpers::klass_concrete_name(cls) << " : "
+ << (klass_full_concrete_or_interface_name % ",") // classes
+ << (inherit_classes.empty() ? "" : ",")
+ << " Efl.Eo.IWrapper" << (root ? ", IDisposable" : "")
+ << (inherit_interfaces.empty() ? "" : ",")
+ << (klass_full_concrete_or_interface_name % ",") // interfaces
+ << "\n{\n"
+ )
+ .generate(sink, std::make_tuple(cls, inherit_classes, inherit_interfaces), inherit_cxt))
+ return false;
+
+
+ // Class body
+ if(!generate_fields(sink, cls, inherit_cxt))
+ return false;
+
+ if (!generate_constructors(sink, cls, inherit_cxt))
+ return false;
+
+ if (!generate_dispose_methods(sink, cls, inherit_cxt))
+ return false;
+
+ if (!generate_static_cast_method(sink, cls, inherit_cxt))
return false;
if (!generate_equals_method(sink, inherit_cxt))
// Parts
if(!as_generator(*(part_definition))
- .generate(sink, cls.get_all_parts(), inherit_cxt)) return false;
+ .generate(sink, cls.parts, inherit_cxt)) return false;
// Inherit function definitions
+ auto implemented_methods = helpers::get_all_implementable_methods(cls);
if(!as_generator(*(function_definition(true)))
- .generate(sink, methods, inherit_cxt)) return false;
+ .generate(sink, implemented_methods, inherit_cxt)) return false;
// Async wrappers
- if(!as_generator(*(async_function_definition(true))).generate(sink, methods, inherit_cxt))
+ if(!as_generator(*(async_function_definition(true))).generate(sink, implemented_methods, inherit_cxt))
return false;
if(!as_generator("}\n").generate(sink, attributes::unused, inherit_cxt)) return false;
}
- std::size_t function_count = get_inheritable_function_count(cls);
+ std::size_t function_count = get_implementable_function_count(cls);
int function_registration_index = 0;
auto index_generator = [&function_registration_index]
// Native wrapper registration
if(!as_generator(*(function_registration(index_generator, cls)))
- .generate(sink, methods, inative_cxt)) return false;
+ .generate(sink, helpers::get_all_implementable_methods(cls), inative_cxt)) return false;
if(!as_generator
( scope_tab << scope_tab << "IntPtr descs_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(descs[0])*" << function_count << ");\n"
<< scope_tab << scope_tab << "ops.count = (UIntPtr)" << function_count << ";\n"
<< scope_tab << scope_tab << "IntPtr ops_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(ops));\n"
<< scope_tab << scope_tab << "Marshal.StructureToPtr(ops, ops_ptr, false);\n"
- << scope_tab << scope_tab << "efl.eo.Globals.efl_class_functions_set(klass, ops_ptr, IntPtr.Zero);\n"
+ << scope_tab << scope_tab << "Efl.Eo.Globals.efl_class_functions_set(klass, ops_ptr, IntPtr.Zero);\n"
).generate(sink, attributes::unused, inative_cxt)) return false;
//
// Native method definitions
if(!as_generator(*(native_function_definition(cls)))
- .generate(sink, methods, inative_cxt)) return false;
+ .generate(sink, helpers::get_all_implementable_methods(cls), inative_cxt)) return false;
if(!as_generator("}\n").generate(sink, attributes::unused, inative_cxt)) return false;
}
}
template <typename OutputIterator, typename Context>
+ bool generate_fields(OutputIterator sink, attributes::klass_def const& cls, Context const& context) const
+ {
+ std::string visibility = is_inherit_context(context) ? "protected " : "private ";
+ bool root = !helpers::has_regular_ancestor(cls);
+ bool is_inherit = is_inherit_context(context);
+
+ std::string class_getter = "return Efl.Eo.Globals.efl_class_get(handle);";
+
+ // The klass field is static but there is no problem if multiple C# classes inherit from this generated one
+ // as it is just a simple wrapper, forwarding the Eo calls either to the user API (where C#'s virtual method
+ // resolution kicks in) or to the base implementation (efl_super).
+ if (is_inherit)
+ {
+ if(!as_generator(
+ scope_tab << "public " << (root ? "" : "new ") << "static System.IntPtr klass = System.IntPtr.Zero;\n"
+ ).generate(sink, attributes::unused, context))
+ return false;
+ class_getter = "return klass;";
+ }
+
+ std::string raw_klass_modifier;
+ if (!root)
+ raw_klass_modifier = "override ";
+ else if (is_inherit)
+ raw_klass_modifier = "virtual ";
+
+ if(!as_generator(
+ scope_tab << "///<summary>Pointer to the native class description.</summary>\n"
+ << scope_tab << "public " << raw_klass_modifier << "System.IntPtr NativeClass {\n"
+ << scope_tab << scope_tab << "get {\n"
+ << scope_tab << scope_tab << scope_tab << class_getter << "\n" //return klass; }\n"
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << "}\n"
+ ).generate(sink, attributes::unused, context))
+ return false;
+
+ // The remaining fields aren't needed in children classes.
+ if (!root)
+ return true;
+
+ if (cls.get_all_events().size() > 0)
+ if (!as_generator(scope_tab << (is_inherit ? "protected " : "private ") << "EventHandlerList eventHandlers = new EventHandlerList();\n").generate(sink, attributes::unused, context))
+ return false;
+
+ if (is_inherit)
+ {
+ if (!as_generator(
+ scope_tab << "private static readonly object klassAllocLock = new object();\n"
+ << scope_tab << "protected bool inherited;\n"
+ ).generate(sink, attributes::unused, context))
+ return false;
+ }
+
+ return as_generator(
+ scope_tab << visibility << " System.IntPtr handle;\n"
+ << scope_tab << "public Dictionary<String, IntPtr> cached_strings = new Dictionary<String, IntPtr>();" << "\n"
+ << scope_tab << "public Dictionary<String, IntPtr> cached_stringshares = new Dictionary<String, IntPtr>();" << "\n"
+ << scope_tab << "///<summary>Pointer to the native instance.</summary>\n"
+ << scope_tab << "public System.IntPtr NativeHandle {\n"
+ << scope_tab << scope_tab << "get { return handle; }\n"
+ << scope_tab << "}\n"
+ ).generate(sink, attributes::unused, context);
+ }
+
+ template <typename OutputIterator, typename Context>
+ bool generate_constructors(OutputIterator sink, attributes::klass_def const& cls, Context const& context) const
+ {
+ bool root = !helpers::has_regular_ancestor(cls);
+ auto inherit_name = name_helpers::klass_concrete_name(cls);
+ auto native_inherit_name = name_helpers::klass_native_inherit_name(cls);
+
+ if(!as_generator(
+ scope_tab << "///<summary>Delegate for function to be called from inside the native constructor.</summary>\n"
+ << scope_tab << "public" << (root ? "" : " new") << " delegate void ConstructingMethod(" << inherit_name << " obj);\n"
+ << scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(context).actual_library_name(cls.filename)
+ << ")] internal static extern System.IntPtr\n"
+ << scope_tab << scope_tab << name_helpers::klass_get_name(cls) << "();\n"
+ ).generate(sink, attributes::unused, context))
+ return false;
+
+
+ if (!root)
+ {
+ return as_generator(
+ scope_tab << "///<summary>Creates a new instance.</summary>\n"
+ << scope_tab << "///<param name=\"parent\">Parent instance.</param>\n"
+ << scope_tab << "///<param name=\"init_cb\">Delegate to call constructing methods that should be run inside the constructor.</param>\n"
+ << scope_tab << "public " << inherit_name << "(Efl.Object parent = null, ConstructingMethod init_cb=null) : base(" << native_inherit_name << ".class_initializer, \"" << inherit_name << "\", " << name_helpers::klass_get_name(cls) << "(), typeof(" << inherit_name << "), parent, ref klass)\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << "if (init_cb != null) {\n"
+ << scope_tab << scope_tab << scope_tab << "init_cb(this);\n"
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << "FinishInstantiation();\n"
+ << scope_tab << "}\n"
+
+ << scope_tab << "///<summary>Internal constructor to forward the wrapper initialization to the root class.</summary>\n"
+ << scope_tab << "protected " << inherit_name << "(Efl.Eo.Globals.class_initializer class_initializer, String klass_name, IntPtr base_klass, Type managed_type, Efl.Object parent, ref IntPtr target_klass) : base(class_initializer, klass_name, base_klass, managed_type, parent, ref target_klass) {}\n"
+
+ << scope_tab << "///<summary>Constructs an instance from a native pointer.</summary>\n"
+ << scope_tab << "public " << inherit_name << "(System.IntPtr raw)" << (root ? "" : " : base(raw)") << "\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << (root ? "handle = raw;\n" : "")
+ << scope_tab << scope_tab << "register_event_proxies();\n"
+ << scope_tab << "}\n"
+ ).generate(sink, attributes::unused, context);
+ }
+
+ // Detailed constructors go only in root classes.
+ return as_generator(
+ scope_tab << "///<summary>Creates a new instance.</summary>\n"
+ << scope_tab << "///<param name=\"parent\">Parent instance.</param>\n"
+ << scope_tab << "///<param name=\"init_cb\">Delegate to call constructing methods that should be run inside the constructor.</param>\n"
+ << scope_tab << "public " << inherit_name << "(Efl.Object parent = null, ConstructingMethod init_cb=null) : this(" << native_inherit_name << ".class_initializer, \"" << inherit_name << "\", " << name_helpers::klass_get_name(cls) << "(), typeof(" << inherit_name << "), parent, ref klass)\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << "if (init_cb != null) {\n"
+ << scope_tab << scope_tab << scope_tab << "init_cb(this);\n"
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << "FinishInstantiation();\n"
+ << scope_tab << "}\n"
+
+ << scope_tab << "protected " << inherit_name << "(Efl.Eo.Globals.class_initializer class_initializer, String klass_name, IntPtr base_klass, Type managed_type, Efl.Object parent, ref IntPtr target_klass)\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << "inherited = this.GetType() != managed_type;\n"
+ << scope_tab << scope_tab << "IntPtr actual_klass = base_klass;\n"
+ << scope_tab << scope_tab << "if (inherited) {\n"
+ << scope_tab << scope_tab << scope_tab << "if (target_klass == System.IntPtr.Zero) {\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "lock (klassAllocLock) {\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "if (target_klass == System.IntPtr.Zero) {\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "target_klass = Efl.Eo.Globals.register_class(class_initializer, klass_name, base_klass);\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "if (target_klass == System.IntPtr.Zero) {\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "throw new System.InvalidOperationException(\"Failed to initialize class '" << inherit_name << "'\");\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << scope_tab << "actual_klass = target_klass;\n"
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << "handle = Efl.Eo.Globals.instantiate_start(actual_klass, parent);\n"
+ << scope_tab << scope_tab << "register_event_proxies();\n"
+ << scope_tab << "}\n"
+
+ << scope_tab << "protected void FinishInstantiation()\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << "if (inherited) {\n"
+ << scope_tab << scope_tab << scope_tab << "Efl.Eo.Globals.data_set(this);\n"
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << scope_tab << "handle = Efl.Eo.Globals.instantiate_end(handle);\n"
+ << scope_tab << scope_tab << "Eina.Error.RaiseIfOccurred();\n"
+ << scope_tab << "}\n"
+
+ << scope_tab << "///<summary>Constructs an instance from a native pointer.</summary>\n"
+ << scope_tab << "public " << inherit_name << "(System.IntPtr raw)\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << "handle = raw;\n"
+ << scope_tab << scope_tab << "register_event_proxies();\n"
+ << scope_tab << "}\n"
+ ).generate(sink, attributes::unused, context);
+ }
+
+
+ template <typename OutputIterator, typename Context>
+ bool generate_dispose_methods(OutputIterator sink, attributes::klass_def const& cls, Context const& context) const
+ {
+ std::string name = join_namespaces(cls.namespaces, '.') + cls.eolian_name;
+ if (helpers::has_regular_ancestor(cls))
+ return true;
+
+ std::string visibility = is_inherit_context(context) ? "protected virtual " : "";
+
+ auto inherit_name = name_helpers::klass_concrete_name(cls);
+
+ return as_generator(
+
+ scope_tab << "///<summary>Destructor.</summary>\n"
+ << scope_tab << "~" << inherit_name << "()\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << "Dispose(false);\n"
+ << scope_tab << "}\n"
+
+ << scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
+ << scope_tab << visibility << "void Dispose(bool disposing)\n"
+ << scope_tab << "{\n"
+ << scope_tab << scope_tab << "if (handle != System.IntPtr.Zero) {\n"
+ << scope_tab << scope_tab << scope_tab << "Efl.Eo.Globals.efl_unref(handle);\n"
+ << scope_tab << scope_tab << scope_tab << "handle = System.IntPtr.Zero;\n"
+ << scope_tab << scope_tab << "}\n"
+ << scope_tab << "}\n"
+
+ << scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
+ << scope_tab << "public void Dispose()\n"
+ << scope_tab << "{\n"
+ << scope_tab << "Efl.Eo.Globals.free_dict_values(cached_strings);" << "\n"
+ << scope_tab << "Efl.Eo.Globals.free_stringshare_values(cached_stringshares);" << "\n"
+ << scope_tab << scope_tab << "Dispose(true);\n"
+ << scope_tab << scope_tab << "GC.SuppressFinalize(this);\n"
+ << scope_tab << "}\n"
+ ).generate(sink, attributes::unused, context);
+ }
+
+ template <typename OutputIterator, typename Context>
bool generate_events_registration(OutputIterator sink, attributes::klass_def const& cls, Context const& context) const
{
+ bool root = !helpers::has_regular_ancestor(cls);
+ std::string virtual_modifier = " ";
+
+ if (!root)
+ virtual_modifier = "override ";
+ else
+ {
+ if (is_inherit_context(context))
+ virtual_modifier = "virtual ";
+ }
+
// Event proxy registration
if (!as_generator(
- scope_tab << "private void register_event_proxies()\n"
+ scope_tab << (is_inherit_context(context) || !root ? "protected " : "") << virtual_modifier << "void register_event_proxies()\n"
<< scope_tab << "{\n"
)
.generate(sink, NULL, context))
// Generate event registrations here
+ if (!root)
+ if (!as_generator(scope_tab << scope_tab << "base.register_event_proxies();\n").generate(sink, NULL, context))
+ return false;
+
// Assigning the delegates
- if (!as_generator(*(event_registration())).generate(sink, cls.events, context))
+ if (!as_generator(*(event_registration(cls, cls))).generate(sink, cls.events, context))
return false;
- for (auto&& c : cls.inherits)
+ for (auto&& c : helpers::non_implemented_interfaces(cls))
{
+ // Only non-regular types (which declare events through interfaces) need to register them.
+ if (c.type == attributes::class_type::regular)
+ continue;
+
attributes::klass_def klass(get_klass(c, cls.unit), cls.unit);
- if (!as_generator(*(event_registration(&klass))).generate(sink, klass.events, context))
+ if (!as_generator(*(event_registration(klass, cls))).generate(sink, klass.events, context))
return false;
}
if (!has_events(cls))
return true;
- std::string visibility = is_inherit_context(context) ? "protected" : "private";
+ std::string visibility = is_inherit_context(context) ? "protected " : "private ";
- if (!as_generator(scope_tab << "private readonly object eventLock = new object();\n"
- << scope_tab << "private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();\n")
- .generate(sink, NULL, context))
- return false;
+ if (!helpers::has_regular_ancestor(cls))
+ {
+ if (!as_generator(scope_tab << visibility << "readonly object eventLock = new object();\n"
+ << scope_tab << visibility << "Dictionary<string, int> event_cb_count = new Dictionary<string, int>();\n")
+ .generate(sink, NULL, context))
+ return false;
// Callback registration functions
if (!as_generator(
- scope_tab << "private bool add_cpp_event_handler(string key, efl.Event_Cb evt_delegate) {\n"
+ scope_tab << visibility << "bool add_cpp_event_handler(string key, Efl.EventCb evt_delegate) {\n"
<< scope_tab << scope_tab << "int event_count = 0;\n"
<< scope_tab << scope_tab << "if (!event_cb_count.TryGetValue(key, out event_count))\n"
<< scope_tab << scope_tab << scope_tab << "event_cb_count[key] = event_count;\n"
<< scope_tab << scope_tab << "if (event_count == 0) {\n"
- << scope_tab << scope_tab << scope_tab << "IntPtr desc = efl.Event_Description.GetNative(key);\n"
+
+ << scope_tab << scope_tab << scope_tab << "IntPtr desc = Efl.EventDescription.GetNative(key);\n"
<< scope_tab << scope_tab << scope_tab << "if (desc == IntPtr.Zero) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Failed to get native event {key}\");\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "Eina.Log.Error($\"Failed to get native event {key}\");\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << scope_tab << "bool result = efl.eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);\n"
+
+ << scope_tab << scope_tab << scope_tab << " bool result = Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);\n"
<< scope_tab << scope_tab << scope_tab << "if (!result) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Failed to add event proxy for event {key}\");\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "Eina.Log.Error($\"Failed to add event proxy for event {key}\");\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
+ << scope_tab << scope_tab << scope_tab << "Eina.Error.RaiseIfOccurred();\n"
<< scope_tab << scope_tab << "} \n"
<< scope_tab << scope_tab << "event_cb_count[key]++;\n"
<< scope_tab << scope_tab << "return true;\n"
<< scope_tab << "}\n"
- << scope_tab << "private bool remove_cpp_event_handler(string key, efl.Event_Cb evt_delegate) {\n"
+ << scope_tab << visibility << "bool remove_cpp_event_handler(string key, Efl.EventCb evt_delegate) {\n"
<< scope_tab << scope_tab << "int event_count = 0;\n"
<< scope_tab << scope_tab << "if (!event_cb_count.TryGetValue(key, out event_count))\n"
<< scope_tab << scope_tab << scope_tab << "event_cb_count[key] = event_count;\n"
<< scope_tab << scope_tab << "if (event_count == 1) {\n"
- << scope_tab << scope_tab << scope_tab << "IntPtr desc = efl.Event_Description.GetNative(key);\n"
+
+ << scope_tab << scope_tab << scope_tab << "IntPtr desc = Efl.EventDescription.GetNative(key);\n"
<< scope_tab << scope_tab << scope_tab << "if (desc == IntPtr.Zero) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Failed to get native event {key}\");\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "Eina.Log.Error($\"Failed to get native event {key}\");\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << scope_tab << "bool result = efl.eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);\n"
+
+ << scope_tab << scope_tab << scope_tab << "bool result = Efl.Eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);\n"
<< scope_tab << scope_tab << scope_tab << "if (!result) {\n"
- << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Failed to remove event proxy for event {key}\");\n"
+ << scope_tab << scope_tab << scope_tab << scope_tab << "Eina.Log.Error($\"Failed to remove event proxy for event {key}\");\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << scope_tab << "}\n"
- << scope_tab << scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
+ << scope_tab << scope_tab << scope_tab << "Eina.Error.RaiseIfOccurred();\n"
<< scope_tab << scope_tab << "} else if (event_count == 0) {\n"
- << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Trying to remove proxy for event {key} when there is nothing registered.\");\n"
+ << scope_tab << scope_tab << scope_tab << "Eina.Log.Error($\"Trying to remove proxy for event {key} when there is nothing registered.\");\n"
<< scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << "} \n"
<< scope_tab << scope_tab << "event_cb_count[key]--;\n"
)
.generate(sink, NULL, context))
return false;
+ }
// Self events
- if (!as_generator(*(event_definition(cls))).generate(sink, cls.events, context))
+ if (!as_generator(*(event_definition(cls, cls))).generate(sink, cls.events, context))
return false;
// Inherited events
- for (auto&& c : cls.inherits)
+
+ // For now, as mixins can inherit from regular classes, we can't filter out inherited events.
+ auto inherits = helpers::non_implemented_interfaces(cls);
+ for (auto&& c : inherits)
{
attributes::klass_def klass(get_klass(c, cls.unit), cls.unit);
- if (!as_generator(*(event_definition(klass, true))).generate(sink, klass.events, context))
+ if (!as_generator(*(event_definition(klass, cls))).generate(sink, klass.events, context))
return false;
}
return true;
// signed primitives
{"bool", nullptr, [&] { return " [MarshalAs(UnmanagedType.U1)]"; }},
{"string", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringPassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]";
}},
{"string", false, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]";
}},
{"mstring", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringPassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]";
}},
{"mstring", false, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]";
}},
{"stringshare", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringsharePassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringsharePassOwnershipMarshaler))]";
}},
{"stringshare", false, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringshareKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringshareKeepOwnershipMarshaler))]";
}},
{"any_value_ptr", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(eina.ValueMarshalerOwn))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshalerOwn))]";
}},
{"any_value_ptr", false, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(eina.ValueMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))]";
}},
{"strbuf", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StrbufPassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufPassOwnershipMarshaler))]";
}},
{"strbuf", false, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StrbufKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))]";
}},
};
match const return_match_table[] =
// signed primitives
{"bool", nullptr, [&] { return " [return: MarshalAs(UnmanagedType.U1)]"; }},
{"string", true, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringPassOwnershipMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]";
}},
{"string", false, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringKeepOwnershipMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]";
}},
{"mstring", true, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringPassOwnershipMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]";
}},
{"mstring", false, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringKeepOwnershipMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]";
}},
{"stringshare", true, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringsharePassOwnershipMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringsharePassOwnershipMarshaler))]";
}},
{"stringshare", false, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringshareKeepOwnershipMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringshareKeepOwnershipMarshaler))]";
}},
{"any_value_ptr", true, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(eina.ValueMarshalerOwn))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshalerOwn))]";
}},
{"any_value_ptr", false, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(eina.ValueMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.ValueMarshaler))]";
}},
{"strbuf", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StrbufPassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufPassOwnershipMarshaler))]";
}},
{"strbuf", false, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StrbufKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))]";
}},
};
}
bool operator()(attributes::klass_name const& klass_name) const
{
- const char no_return_prefix[] = "[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(efl.eo.MarshalTest<";
- const char return_prefix[] = "[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(efl.eo.MarshalTest<";
+ const char no_return_prefix[] = "[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Efl.Eo.MarshalTest<";
+ const char return_prefix[] = "[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Efl.Eo.MarshalTest<";
return as_generator
((is_return ? return_prefix : no_return_prefix)
- << string << ", efl.eo." << (klass_name.base_qualifier & qualifier_info::is_own ? "OwnTag" : "NonOwnTag") << ">))]"
+ << string << ", Efl.Eo." << (klass_name.base_qualifier & qualifier_info::is_own ? "OwnTag" : "NonOwnTag") << ">))]"
).generate(sink, name_helpers::klass_full_concrete_name(klass_name), *context);
}
bool operator()(attributes::complex_type_def const& c) const
if (c.outer.base_type == "future")
{
std::string prefix = is_return ? "return: " : "";
- return as_generator("[" << prefix << "MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(eina.FutureMarshaler))]").generate(sink, nullptr, *context);
+ return as_generator("[" << prefix << "MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]").generate(sink, nullptr, *context);
}
return true;
}
// signed primitives
{"bool", nullptr, [&] { return " [MarshalAs(UnmanagedType.U1)]"; }},
{"string", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringPassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]";
}},
{"string", false, [&] {
if (is_out)
return "";
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]";
}},
{"stringshare", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringsharePassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringsharePassOwnershipMarshaler))]";
}},
{"stringshare", false, [&] {
if (is_out)
return "";
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringshareKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringshareKeepOwnershipMarshaler))]";
}},
{"strbuf", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StrbufPassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufPassOwnershipMarshaler))]";
}},
{"strbuf", false, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StrbufKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))]";
}},
};
match const return_match_table[] =
// signed primitives
{"bool", nullptr, [&] { return " [return: MarshalAs(UnmanagedType.U1)]"; }},
{"string", true, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringPassOwnershipMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringPassOwnershipMarshaler))]";
}},
{"string", false, [&] { return ""; }},
{"stringshare", true, [&] {
- return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StringsharePassOwnershipMarshaler))]";
+ return " [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringsharePassOwnershipMarshaler))]";
}},
{"stringshare", false, [&] { return ""; }},
{"strbuf", true, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StrbufPassOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufPassOwnershipMarshaler))]";
}},
{"strbuf", false, [&] {
- return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(efl.eo.StrbufKeepOwnershipMarshaler))]";
+ return " [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))]";
}},
};
}
bool operator()(attributes::klass_name const& klass_name) const
{
- const char no_return_prefix[] = "[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(efl.eo.MarshalTest<";
- const char return_prefix[] = "[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(efl.eo.MarshalTest<";
+ const char no_return_prefix[] = "[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Efl.Eo.MarshalTest<";
+ const char return_prefix[] = "[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Efl.Eo.MarshalTest<";
return as_generator
((is_return ? return_prefix : no_return_prefix)
- << string << ", efl.eo." << (klass_name.base_qualifier & qualifier_info::is_own ? "OwnTag" : "NonOwnTag") << ">))]"
+ << string << ", Efl.Eo." << (klass_name.base_qualifier & qualifier_info::is_own ? "OwnTag" : "NonOwnTag") << ">))]"
).generate(sink, name_helpers::klass_full_concrete_name(klass_name), *context);
}
bool operator()(attributes::complex_type_def const& c) const
if (c.outer.base_type == "future")
{
std::string prefix = is_return ? "return: " : "";
- return as_generator("[" << prefix << "MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(eina.FutureMarshaler))]").generate(sink, nullptr, *context);
+ return as_generator("[" << prefix << "MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))]").generate(sink, nullptr, *context);
}
return true;
}
*
* For example, Eina.Value can be marshaled either as an eina.Value instance through
* CustomMarshallers if we have a ptr(Eina.Value) or through the intermediate
- * eina.Value_Native blittable struct if it is passed by value.
+ * eina.ValueNative blittable struct if it is passed by value.
*
* For details, check marshall_type_impl.h with the actual conversion rules.
*/
{
regular_type_def r = regular;
r.base_qualifier.qualifier ^= qualifier_info::is_ref;
- return replace_base_type(r, " eina.Strbuf");
+ return replace_base_type(r, " Eina.Strbuf");
}}
, {"Binbuf", true, [&]
{
regular_type_def r = regular;
r.namespaces.clear();
if (is_ptr)
- r.base_type = " eina.Value";
+ r.base_type = " Eina.Value";
else
- r.base_type = " eina.Value_Native";
+ r.base_type = " Eina.ValueNative";
return r;
}}
, {"any_value", false, [&]
regular_type_def r = regular;
r.namespaces.clear();
if (is_ptr)
- r.base_type = " eina.Value";
+ r.base_type = " Eina.Value";
else
- r.base_type = " eina.Value_Native";
+ r.base_type = " Eina.ValueNative";
return r;
}}
, {"any_value_ptr", true, [&]
{
regular_type_def r = regular;
r.namespaces.clear();
- r.base_type = " eina.Value";
+ r.base_type = " Eina.Value";
return r;
}}
, {"any_value_ptr", false, [&]
{
regular_type_def r = regular;
r.namespaces.clear();
- r.base_type = " eina.Value";
+ r.base_type = " Eina.Value";
return r;
}}
, {"void", nullptr, [&]
{
return strcasecmp(lhs.c_str(), rhs.c_str()) == 0;
}
+inline bool is_equal(std::string const& lhs, std::string const& rhs)
+{
+ return lhs == rhs;
+}
}
inline std::string identity(std::string const& str)
inline std::string escape_keyword(std::string const& name)
{
- using detail::is_iequal;
- if(is_iequal(name, "delete")
- || is_iequal(name, "do")
- || is_iequal(name, "lock")
- || is_iequal(name, "event")
- || is_iequal(name, "in")
- || is_iequal(name, "object")
- || is_iequal(name, "interface")
- || is_iequal(name, "string")
- || is_iequal(name, "internal")
- || is_iequal(name, "fixed")
- || is_iequal(name, "base"))
+ using detail::is_equal;
+ if(is_equal(name, "delete")
+ || is_equal(name, "do")
+ || is_equal(name, "lock")
+ || is_equal(name, "event")
+ || is_equal(name, "in")
+ || is_equal(name, "object")
+ || is_equal(name, "interface")
+ || is_equal(name, "string")
+ || is_equal(name, "internal")
+ || is_equal(name, "fixed")
+ || is_equal(name, "base"))
return "kw_" + name;
- if (is_iequal(name, "Finalize"))
+ if (is_equal(name, "Finalize"))
return name + "Add"; // Eo's Finalize is actually the end of efl_add.
return name;
}
inline std::string managed_namespace(std::string const& ns)
{
- return utils::to_lowercase(escape_keyword(ns));
+ return escape_keyword(utils::remove_all(ns, '_'));
}
inline std::string managed_method_name(attributes::function_def const& f)
inline std::string type_full_managed_name(attributes::regular_type_def const& type)
{
- return join_namespaces(type.namespaces, '.', managed_namespace) + type.base_type;
+ return join_namespaces(type.namespaces, '.', managed_namespace) + utils::remove_all(type.base_type, '_');
}
inline std::string struct_full_eolian_name(attributes::struct_def const& struct_)
return join_namespaces(struct_.namespaces, '.') + struct_.cxx_name;
}
-inline std::string enum_managed_name(attributes::enum_def const& enum_)
+template<typename T>
+inline std::string typedecl_managed_name(T const& item)
+{
+ return utils::remove_all(item.cxx_name, '_');
+}
+
+inline std::string typedecl_managed_name(attributes::function_def const& func)
{
- return enum_.cxx_name;
+ return utils::remove_all(func.name, '_');
+}
+
+
+inline std::string enum_field_managed_name(std::string name)
+{
+ std::vector<std::string> names = utils::split(name, '_');
+ return utils::to_pascal_case(names);
}
inline std::string to_field_name(std::string const& in)
return utils::capitalize(in);
}
-// Class name translation (interface/concrete/inherit/etc)
-template<typename T>
-inline std::string klass_interface_name(T const& klass)
+inline std::string managed_part_name(attributes::part_def const& part)
{
- return "I" + klass.eolian_name;
+ std::vector<std::string> names = utils::split(part.name, '_');
+ return utils::to_pascal_case(names);
}
-template<typename T>
-inline std::string klass_full_interface_name(T const& klass)
+// Class name translation (interface/concrete/inherit/etc)
+struct klass_interface_name_generator
{
- return join_namespaces(klass.namespaces, '.', managed_namespace) + klass_interface_name(klass);
-}
+
+ template <typename T>
+ std::string operator()(T const& klass) const
+ {
+ return utils::remove_all(klass.eolian_name, '_');
+ }
+
+ template <typename OutputIterator, typename Attr, typename Context>
+ bool generate(OutputIterator sink, Attr const& attribute, Context const& context) const
+ {
+ return as_generator((*this).operator()<Attr>(attribute)).generate(sink, attributes::unused, context);
+ }
+} klass_interface_name;
+
+struct klass_full_interface_name_generator
+{
+ template <typename T>
+ std::string operator()(T const& klass) const
+ {
+ return join_namespaces(klass.namespaces, '.', managed_namespace) + klass_interface_name(klass);
+ }
+
+ template <typename OutputIterator, typename Attr, typename Context>
+ bool generate(OutputIterator sink, Attr const& attribute, Context const& context) const
+ {
+ return as_generator((*this).operator()<Attr>(attribute)).generate(sink, attributes::unused, context);
+ }
+} klass_full_interface_name;
template<typename T>
inline std::string klass_concrete_name(T const& klass)
{
- return klass.eolian_name;
+ std::string name = utils::remove_all(klass.eolian_name, '_');
+ if (klass.type == attributes::class_type::regular || klass.type == attributes::class_type::abstract_)
+ return name;
+ return name + "Concrete";
}
-template<typename T>
-inline std::string klass_full_concrete_name(T const& klass)
+struct klass_full_concrete_name_generator
{
- return join_namespaces(klass.namespaces, '.', managed_namespace) + klass_concrete_name(klass);
-}
+ template <typename T>
+ std::string operator()(T const& klass) const
+ {
+ return join_namespaces(klass.namespaces, '.', managed_namespace) + klass_concrete_name(klass);
+ }
+
+ template <typename OutputIterator, typename Attr, typename Context>
+ bool generate(OutputIterator sink, Attr const& attribute, Context const& context) const
+ {
+ return as_generator((*this).operator()<Attr>(attribute)).generate(sink, attributes::unused, context);
+ }
+} klass_full_concrete_name;
+
+struct klass_full_concrete_or_interface_name_generator
+{
+ template <typename T>
+ std::string operator()(T const& klass) const
+ {
+ switch(klass.type)
+ {
+ case attributes::class_type::abstract_:
+ case attributes::class_type::regular:
+ return klass_full_concrete_name(klass);
+ }
+ return klass_full_interface_name(klass);
+
+ }
+
+ template <typename OutputIterator, typename Context>
+ bool generate(OutputIterator, attributes::unused_type, Context const&) const
+ {
+ return true;
+ }
+
+ template <typename OutputIterator, typename Attr, typename Context>
+ bool generate(OutputIterator sink, Attr const& attribute, Context const& context) const
+ {
+ return as_generator((*this).operator()<Attr>(attribute)).generate(sink, attributes::unused, context);
+ }
+} klass_full_concrete_or_interface_name;
template<typename T>
inline std::string klass_inherit_name(T const& klass)
{
- return klass.eolian_name + "Inherit";
+ return klass_concrete_name(klass);
}
template<typename T>
inline std::string klass_native_inherit_name(T const& klass)
{
- return klass.eolian_name + "NativeInherit";
+ return klass_concrete_name(klass) + "NativeInherit";
}
template<typename T>
inline std::string managed_event_args_short_name(attributes::event_def const& evt)
{
- return name_helpers::managed_event_name(evt.name) + "_Args";
+ std::string ret;
+ ret = klass_interface_name(evt.klass);
+ return ret + name_helpers::managed_event_name(evt.name) + "_Args";
}
inline std::string managed_event_args_name(attributes::event_def evt)
{
- return klass_full_concrete_name(evt.klass) + "." + managed_event_args_short_name(evt);
+ return join_namespaces(evt.klass.namespaces, '.', managed_namespace) +
+ managed_event_args_short_name(evt);
}
inline std::string translate_inherited_event_name(const attributes::event_def &evt, const attributes::klass_def &klass)
{
- return join_namespaces(klass.namespaces, '_') + klass.cxx_name + "_" + managed_event_name(evt.name);
+ return join_namespaces(klass.namespaces, '_') + klass_interface_name(klass) + "_" + managed_event_name(evt.name);
}
// Open/close namespaces
} // namespace eolian_mono
+
+namespace efl { namespace eolian { namespace grammar {
+
+template <>
+struct is_eager_generator<eolian_mono::name_helpers::klass_interface_name_generator> : std::true_type {};
+template <>
+struct is_generator<eolian_mono::name_helpers::klass_interface_name_generator> : std::true_type {};
+
+template <>
+struct is_eager_generator<eolian_mono::name_helpers::klass_full_interface_name_generator> : std::true_type {};
+template <>
+struct is_generator<eolian_mono::name_helpers::klass_full_interface_name_generator> : std::true_type {};
+
+template <>
+struct is_eager_generator<eolian_mono::name_helpers::klass_full_concrete_or_interface_name_generator> : std::true_type {};
+template <>
+struct is_generator<eolian_mono::name_helpers::klass_full_concrete_or_interface_name_generator> : std::true_type {};
+
+template <>
+struct is_eager_generator<eolian_mono::name_helpers::klass_full_concrete_name_generator> : std::true_type {};
+template <>
+struct is_generator<eolian_mono::name_helpers::klass_full_concrete_name_generator> : std::true_type {};
+
+namespace type_traits {
+template <>
+struct attributes_needed<struct ::eolian_mono::name_helpers::klass_full_concrete_or_interface_name_generator> : std::integral_constant<int, 1> {};
+}
+
+} } }
+
#endif
).generate(sink, std::make_tuple(param, param_name), context);
return as_generator(
- "IntPtr " << param_name << "_data, " << type << "Internal " << param_name << ", Eina_Free_Cb "
+ "IntPtr " << param_name << "_data, " << type << "Internal " << param_name << ", EinaFreeCb "
<< param_name << "_free_cb"
).generate(sink, param, context);
}
else if (param.type.original_type.visit(is_fp_visitor{}))
{
std::string param_name = escape_keyword(param.param_name);
- return as_generator("GCHandle.ToIntPtr(" << param_name << "_handle), " << type << "Wrapper.Cb, efl.eo.Globals.free_gchandle")
+ return as_generator("GCHandle.ToIntPtr(" << param_name << "_handle), " << type << "Wrapper.Cb, Efl.Eo.Globals.free_gchandle")
.generate(sink, param.type, context);
}
else
if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(param, regular))
{
return as_generator(
- "var " << string << " = eina.PrimitiveConversion.PointerToManaged<" << type << ">(" << escape_keyword(param.param_name) << ");\n"
+ "var " << string << " = Eina.PrimitiveConversion.PointerToManaged<" << type << ">(" << escape_keyword(param.param_name) << ");\n"
).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
}
else if (helpers::need_struct_conversion(regular))
else if (param.type.c_type == "Eina_Binbuf *" || param.type.c_type == "const Eina_Binbuf *")
{
return as_generator(
- "var " << string << " = new eina.Binbuf(" << escape_keyword(param.param_name) << ", " << (param.type.has_own ? "true" : "false") << ");\n"
+ "var " << string << " = new Eina.Binbuf(" << escape_keyword(param.param_name) << ", " << (param.type.has_own ? "true" : "false") << ");\n"
).generate(sink, in_variable_name(param.param_name), context);
}
else if (param.type.c_type == "Eina_Hash *" || param.type.c_type == "const Eina_Hash *")
if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(param, regular))
{
return as_generator(
- "var " << string << " = eina.PrimitiveConversion.ManagedToPointerAlloc(" << escape_keyword(param.param_name) << ");\n"
+ "var " << string << " = Eina.PrimitiveConversion.ManagedToPointerAlloc(" << escape_keyword(param.param_name) << ");\n"
).generate(sink, in_variable_name(param.param_name), context);
}
else if (helpers::need_struct_conversion(regular))
)
{
return as_generator(
- "eina.Binbuf " << string << " = default(eina.Binbuf);\n"
+ "Eina.Binbuf " << string << " = default(Eina.Binbuf);\n"
).generate(sink, out_variable_name(param.param_name), context);
}
else if (param_is_acceptable(param, "Eina_Array *", WANT_OWN, WANT_OUT)
if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(param.type, param.direction))
{
bool ret = as_generator(
- string << " = eina.PrimitiveConversion.PointerToManaged<" << type << ">(" << out_variable_name(param.param_name) << ");\n"
+ string << " = Eina.PrimitiveConversion.PointerToManaged<" << type << ">(" << out_variable_name(param.param_name) << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type), context);
if (param.type.has_own)
)
{
return as_generator(
- string << " = new eina.Binbuf(" << string << ", " << (param.type.has_own ? "true" : "false") << ");\n"
+ string << " = new Eina.Binbuf(" << string << ", " << (param.type.has_own ? "true" : "false") << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), out_variable_name(param.param_name)), context);
}
else if (param_is_acceptable(param, "Eina_Hash *", WANT_OWN, WANT_OUT)
if (ret_type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(ret_type, attributes::parameter_direction::unknown))
{
return as_generator(
- "var __ret_tmp = eina.PrimitiveConversion.PointerToManaged<" << type << ">(_ret_var);\n"
+ "var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<" << type << ">(_ret_var);\n"
<< scope_tab << scope_tab << (ret_type.has_own ? ("Marshal.FreeHGlobal(_ret_var);\n"): "\n")
<< scope_tab << scope_tab << "return __ret_tmp;\n"
).generate(sink, ret_type, context);
}
else if (ret_type.c_type == "Eina_Binbuf *" || ret_type.c_type == "const Eina_Binbuf *")
{
- if (!as_generator("var _binbuf_ret = new eina.Binbuf(_ret_var, " << std::string{ret_type.has_own ? "true" : "false"} << ");\n"
+ if (!as_generator("var _binbuf_ret = new Eina.Binbuf(_ret_var, " << std::string{ret_type.has_own ? "true" : "false"} << ");\n"
<< scope_tab << scope_tab << "return _binbuf_ret;\n")
.generate(sink, attributes::unused, context))
return false;
if (param.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(param.type, param.direction))
{
return as_generator(
- string << " = eina.PrimitiveConversion.ManagedToPointerAlloc(" << string << ");\n"
+ string << " = Eina.PrimitiveConversion.ManagedToPointerAlloc(" << string << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), out_variable_name(param.param_name)), context);
}
else if (helpers::need_struct_conversion(regular))
return false;
}
return as_generator(
- string << "= efl.eo.Globals.cached_stringshare_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_stringshares, " << string << ");\n"
+ string << "= Efl.Eo.Globals.cached_stringshare_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_stringshares, " << string << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), out_variable_name(param.param_name)), context);
}
else if (param_is_acceptable(param, "const char *", !WANT_OWN, WANT_OUT))
return false;
}
return as_generator(
- string << "= efl.eo.Globals.cached_string_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_strings, " << string << ");\n"
+ string << "= Efl.Eo.Globals.cached_string_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_strings, " << string << ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), out_variable_name(param.param_name)), context);
}
else if (param_is_acceptable(param, "Eina_Binbuf *", WANT_OWN, WANT_OUT)
if (ret_type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(ret_type, attributes::parameter_direction::unknown) )
{
return as_generator(
- "return eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);\n"
+ "return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);\n"
).generate(sink, attributes::unused, context);
}
else if (helpers::need_struct_conversion(regular))
return false;
}
return as_generator(
- "return efl.eo.Globals.cached_string_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_strings, _ret_var);\n"
+ "return Efl.Eo.Globals.cached_string_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_strings, _ret_var);\n"
).generate(sink, attributes::unused, context);
}
else
return false;
}
return as_generator(
- "return efl.eo.Globals.cached_stringshare_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_stringshares, _ret_var);\n"
+ "return Efl.Eo.Globals.cached_stringshare_to_intptr(((" << name_helpers::klass_inherit_name(*klass) << ")wrapper).cached_stringshares, _ret_var);\n"
).generate(sink, attributes::unused, context);
}
else
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::part_def const& part, Context const& context) const
{
- auto part_interface_name = name_helpers::klass_full_interface_name(part.klass);
- auto part_klass_name = name_helpers::klass_full_concrete_name(part.klass);
+ auto part_klass_name = name_helpers::klass_full_concrete_or_interface_name(part.klass);
return as_generator(scope_tab << documentation
- << scope_tab << "public " << part_interface_name << " " << utils::capitalize(part.name) << "\n"
+ << scope_tab << "public " << part_klass_name << " " << name_helpers::managed_part_name(part) << "\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "get\n"
<< scope_tab << scope_tab << "{\n"
- << scope_tab << scope_tab << scope_tab << "efl.IObject obj = efl_part_get(raw_handle, \"" << part.name << "\");\n"
+ << scope_tab << scope_tab << scope_tab << "Efl.Object obj = efl_part_get(NativeHandle, \"" << part.name << "\");\n"
<< scope_tab << scope_tab << scope_tab << "return " << part_klass_name << ".static_cast(obj);\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << "}\n"
inline std::string binding_struct_name(attributes::struct_def const& struct_)
{
- return struct_.cxx_name;
+ return name_helpers::typedecl_managed_name(struct_);
}
inline std::string binding_struct_internal_name(attributes::struct_def const& struct_)
{
- return struct_.cxx_name + "_StructInternal";
+ return binding_struct_name(struct_) + "_StructInternal";
}
struct struct_definition_generator
if (klass)
{
if (!as_generator(
- scope_tab << scope_tab << "_internal_struct." << string << " = _external_struct." << string << ".raw_handle;\n")
+ scope_tab << scope_tab << "_internal_struct." << string << " = _external_struct." << string << ".NativeHandle;\n")
.generate(sink, std::make_tuple(field_name, field_name), context))
return false;
}
else if (field.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(regular))
{
if (!as_generator(
- scope_tab << scope_tab << "_internal_struct." << string << " = eina.PrimitiveConversion.ManagedToPointerAlloc(_external_struct." << string << ");\n")
+ scope_tab << scope_tab << "_internal_struct." << string << " = Eina.PrimitiveConversion.ManagedToPointerAlloc(_external_struct." << string << ");\n")
.generate(sink, std::make_tuple(field_name, field_name), context))
return false;
}
else if (regular && (regular->base_type == "string" || regular->base_type == "mstring"))
{
if (!as_generator(
- scope_tab << scope_tab << "_internal_struct." << string << " = eina.MemoryNative.StrDup(_external_struct." << string << ");\n")
+ scope_tab << scope_tab << "_internal_struct." << string << " = Eina.MemoryNative.StrDup(_external_struct." << string << ");\n")
.generate(sink, std::make_tuple(field_name, field_name), context))
return false;
}
else if (regular && regular->base_type == "stringshare")
{
if (!as_generator(
- scope_tab << scope_tab << "_internal_struct." << string << " = eina.Stringshare.eina_stringshare_add(_external_struct." << string << ");\n")
+ scope_tab << scope_tab << "_internal_struct." << string << " = Eina.Stringshare.eina_stringshare_add(_external_struct." << string << ");\n")
.generate(sink, std::make_tuple(field_name, field_name), context))
return false;
}
if (!as_generator(
"\n"
<< scope_tab << scope_tab << "_external_struct." << string
- << " = (" << interface_name << ") System.Activator.CreateInstance(typeof("
+ << " = (" << concrete_name << ") System.Activator.CreateInstance(typeof("
<< concrete_name << "), new System.Object[] {_internal_struct." << string << "});\n"
- << scope_tab << scope_tab << "efl.eo.Globals.efl_ref(_internal_struct." << string << ");\n\n")
+ << scope_tab << scope_tab << "Efl.Eo.Globals.efl_ref(_internal_struct." << string << ");\n\n")
.generate(sink, std::make_tuple(field_name, field_name, field_name), context))
return false;
}
else if (field.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(regular))
{
if (!as_generator(
- scope_tab << scope_tab << "_external_struct." << string << " = eina.PrimitiveConversion.PointerToManaged<" << type << ">(_internal_struct." << string << ");\n")
+ scope_tab << scope_tab << "_external_struct." << string << " = Eina.PrimitiveConversion.PointerToManaged<" << type << ">(_internal_struct." << string << ");\n")
.generate(sink, std::make_tuple(field_name, field.type, field_name), context))
return false;
}
else if (regular && (regular->base_type == "string" || regular->base_type == "mstring" || regular->base_type == "stringshare"))
{
if (!as_generator(
- scope_tab << scope_tab << "_external_struct." << string << " = eina.StringConversion.NativeUtf8ToManagedString(_internal_struct." << string << ");\n")
+ scope_tab << scope_tab << "_external_struct." << string << " = Eina.StringConversion.NativeUtf8ToManagedString(_internal_struct." << string << ");\n")
.generate(sink, std::make_tuple(field_name, field_name), context))
return false;
}
else if (field.type.c_type == "Eina_Value" || field.type.c_type == "const Eina_Value")
{
if (!as_generator(
- scope_tab << scope_tab << "_external_struct." << string << " = new eina.Value(_internal_struct." << string << ");\n"
+ scope_tab << scope_tab << "_external_struct." << string << " = new Eina.Value(_internal_struct." << string << ");\n"
).generate(sink, std::make_tuple(field_name, field_name), context))
return false;
}
else if (field.type.c_type == "Eina_Value *" || field.type.c_type == "const Eina_Value *")
{
if (!as_generator(
- scope_tab << scope_tab << "_external_struct." << string << " = new eina.Value(_internal_struct." << string << ", eina.Ownership.Unmanaged);\n"
+ scope_tab << scope_tab << "_external_struct." << string << " = new Eina.Value(_internal_struct." << string << ", Eina.Ownership.Unmanaged);\n"
).generate(sink, std::make_tuple(field_name, field_name), context))
return false;
}
// Open conversion class
if (!as_generator
(
- "/// <summary>Conversion class for struct " << struct_.cxx_name << "</summary>\n"
- "public static class " << struct_.cxx_name << "_StructConversion\n{\n"
+ "/// <summary>Conversion class for struct " << name_helpers::typedecl_managed_name(struct_) << "</summary>\n"
+ "public static class " << name_helpers::typedecl_managed_name(struct_) << "_StructConversion\n{\n"
)
.generate(sink, nullptr, context))
return false;
}}
, {"Eina.Error", nullptr, [&] // Eina.Error
{
- return regular_type_def{" eina.Error", regular.base_qualifier, {}};
+ return regular_type_def{" Eina.Error", regular.base_qualifier, {}};
}} // TODO
, {"string", nullptr, [&]
{
}}
, {"strbuf", nullptr, [&]
{
- return regular_type_def{" eina.Strbuf", regular.base_qualifier, {}};
+ return regular_type_def{" Eina.Strbuf", regular.base_qualifier, {}};
}}
, {"any_value", true, [&]
- { return regular_type_def{" eina.Value", regular.base_qualifier, {}};
+ { return regular_type_def{" Eina.Value", regular.base_qualifier, {}};
}}
, {"any_value", false, [&]
- { return regular_type_def{" eina.Value", regular.base_qualifier, {}};
+ { return regular_type_def{" Eina.Value", regular.base_qualifier, {}};
}}
, {"any_value_ptr", nullptr, [&]
- { return regular_type_def{" eina.Value", regular.base_qualifier, {}};
+ { return regular_type_def{" Eina.Value", regular.base_qualifier, {}};
}} // FIXME add proper support for any_value_ptr
};
std::string full_type_name = name_helpers::type_full_eolian_name(regular);
}
bool operator()(attributes::klass_name klass) const
{
- return as_generator(string).generate(sink, name_helpers::klass_full_interface_name(klass), *context);
+ if(klass.type == attributes::class_type::regular || klass.type == attributes::class_type::abstract_)
+ return as_generator(string).generate(sink, name_helpers::klass_full_concrete_name(klass), *context);
+ else
+ return as_generator(string).generate(sink, name_helpers::klass_full_interface_name(klass), *context);
}
bool operator()(attributes::complex_type_def const& complex) const
{
{"list", nullptr, nullptr, [&]
{
complex_type_def c = complex;
- c.outer.base_type = "eina.List";
+ c.outer.base_type = "Eina.List";
return c;
}}
, {"inlist", nullptr, nullptr, [&]
{
complex_type_def c = complex;
- c.outer.base_type = "eina.Inlist";
+ c.outer.base_type = "Eina.Inlist";
return c;
}}
, {"array", nullptr, nullptr, [&]
{
complex_type_def c = complex;
- c.outer.base_type = "eina.Array";
+ c.outer.base_type = "Eina.Array";
return c;
}}
, {"inarray", nullptr, nullptr, [&]
{
complex_type_def c = complex;
- c.outer.base_type = "eina.Inarray";
+ c.outer.base_type = "Eina.Inarray";
return c;
}}
, {"hash", nullptr, nullptr
, [&]
{
complex_type_def c = complex;
- c.outer.base_type = "eina.Hash";
+ c.outer.base_type = "Eina.Hash";
return c;
}}
, {"future", nullptr, nullptr, [&]
{
- (*this)(regular_type_def{" eina.Future", complex.outer.base_qualifier, {}});
+ (*this)(regular_type_def{" Eina.Future", complex.outer.base_qualifier, {}});
return attributes::type_def::variant_type();
}
}
, {"iterator", nullptr, nullptr, [&]
{
complex_type_def c = complex;
- c.outer.base_type = "eina.Iterator";
+ c.outer.base_type = "Eina.Iterator";
return c;
}
}
, {"accessor", nullptr, nullptr, [&]
{
complex_type_def c = complex;
- c.outer.base_type = "eina.Accessor";
+ c.outer.base_type = "Eina.Accessor";
return c;
}
}
namespace eolian_mono {
namespace grammar = efl::eolian::grammar;
-using efl::eolian::grammar::as_generator;
-using efl::eolian::grammar::string;
-using efl::eolian::grammar::html_escaped_string;
-using efl::eolian::grammar::operator<<;
-using efl::eolian::grammar::operator%;
-using efl::eolian::grammar::operator*;
-using efl::eolian::grammar::scope_tab;
-using efl::eolian::grammar::lower_case;
-using efl::eolian::grammar::upper_case;
-using efl::eolian::grammar::lit;
-using efl::eolian::grammar::qualifier_info;
-using efl::eolian::grammar::context_find_tag;
+using grammar::as_generator;
+using grammar::string;
+using grammar::html_escaped_string;
+using grammar::operator<<;
+using grammar::operator%;
+using grammar::operator*;
+using grammar::scope_tab;
+using grammar::lower_case;
+using grammar::upper_case;
+using grammar::lit;
+using grammar::qualifier_info;
+using grammar::context_find_tag;
+using grammar::attribute_conditional;
}
#define EOLIAN_MONO_UTILS_HPP
#include <string>
+#include <vector>
#include <sstream>
#include <iterator>
#include <algorithm>
return ret;
}
+
+ inline std::string remove_all(std::string name, char target)
+ {
+ name.erase(std::remove(name.begin(), name.end(), target), name.end());
+ return name;
+ }
} }
#endif
if (!as_generator("#pragma warning disable CS1591\n").generate(iterator, efl::eolian::grammar::attributes::unused, efl::eolian::grammar::context_null()))
throw std::runtime_error("Failed to generate pragma to disable missing docs");
- if (!as_generator("using System;\nusing System.Runtime.InteropServices;\nusing System.Collections.Generic;\n")
+ if (!as_generator("using System;\n"
+ "using System.Runtime.InteropServices;\n"
+ "using System.Collections.Generic;\n"
+ "using System.ComponentModel;\n")
.generate(iterator, efl::eolian::grammar::attributes::unused, efl::eolian::grammar::context_null()))
{
throw std::runtime_error("Failed to generate file preamble");
ecore_evas_show(handle);
}
- public efl.canvas.IObject canvas
+ public Efl.Canvas.Object canvas
{
- get { return new efl.canvas.Object(ecore_evas_get(handle)); }
+ get { return new Efl.Canvas.Object(ecore_evas_get(handle)); }
}
}
using System.Runtime.InteropServices;
using System.Threading;
-using static efl.UnsafeNativeMethods;
+using static Efl.UnsafeNativeMethods;
-namespace efl {
+namespace Efl {
static class UnsafeNativeMethods {
[DllImport(efl.Libs.Ecore)] public static extern void ecore_init();
public static class All {
private static bool InitializedUi = false;
- public static void Init(efl.Components components=Components.Basic) {
- eina.Config.Init();
- efl.eo.Config.Init();
+ public static void Init(Efl.Components components=Components.Basic) {
+ Eina.Config.Init();
+ Efl.Eo.Config.Init();
ecore_init();
evas_init();
eldbus.Config.Init();
if (components == Components.Ui) {
- efl.ui.Config.Init();
+ Efl.Ui.Config.Init();
InitializedUi = true;
}
}
System.GC.WaitForPendingFinalizers();
if (InitializedUi)
- efl.ui.Config.Shutdown();
+ Efl.Ui.Config.Shutdown();
eldbus.Config.Shutdown();
evas_shutdown();
ecore_shutdown();
- efl.eo.Config.Shutdown();
- eina.Config.Shutdown();
+ Efl.Eo.Config.Shutdown();
+ Eina.Config.Shutdown();
}
}
// Placeholder. Will move to elm_config.cs later
-namespace ui {
+namespace Ui {
public static class Config {
public static void Init() {
#endif
elm_init(0, IntPtr.Zero);
- elm_policy_set((int)elm.Policy.Quit, (int)elm.Policy_Quit.Last_window_hidden);
+ elm_policy_set((int)Elm.Policy.Quit, (int)Elm.PolicyQuit.LastWindowHidden);
}
public static void Shutdown() {
elm_shutdown();
using System.Collections.Generic;
using System.Runtime.InteropServices;
-using static eina.TraitFunctions;
+using static Eina.TraitFunctions;
-using static eina.AccessorNativeFunctions;
+using static Eina.AccessorNativeFunctions;
-namespace eina {
+namespace Eina {
internal class AccessorNativeFunctions
{
using System.Runtime.InteropServices;
using System.Collections.Generic;
-using static eina.TraitFunctions;
-using static eina.ArrayNativeFunctions;
+using static Eina.TraitFunctions;
+using static Eina.ArrayNativeFunctions;
-namespace eina {
+namespace Eina {
public static class ArrayNativeFunctions
{
}
- public eina.Iterator<T> GetIterator()
+ public Eina.Iterator<T> GetIterator()
{
- return new eina.Iterator<T>(eina_array_iterator_new(Handle), true, false);
+ return new Eina.Iterator<T>(eina_array_iterator_new(Handle), true, false);
}
public IEnumerator<T> GetEnumerator()
}
/// <summary> Gets an Accessor for this Array.</summary>
- public eina.Accessor<T> GetAccessor()
+ public Eina.Accessor<T> GetAccessor()
{
- return new eina.Accessor<T>(eina_array_accessor_new(Handle), Ownership.Managed);
+ return new Eina.Accessor<T>(eina_array_accessor_new(Handle), Ownership.Managed);
}
}
using System;
using System.Runtime.InteropServices;
-namespace eina {
+namespace Eina {
public class Binbuf : IDisposable
{
[DllImport(efl.Libs.Eina)] public static extern byte
eina_binbuf_append_length(IntPtr buf, byte[] str, UIntPtr length);
[DllImport(efl.Libs.Eina)] public static extern byte
- eina_binbuf_append_slice(IntPtr buf, eina.Slice slice);
+ eina_binbuf_append_slice(IntPtr buf, Eina.Slice slice);
[DllImport(efl.Libs.Eina)] public static extern byte
eina_binbuf_append_buffer(IntPtr buf, IntPtr data);
[DllImport(efl.Libs.Eina)] public static extern byte
[DllImport(efl.Libs.Eina)] public static extern byte
eina_binbuf_insert_length(IntPtr buf, byte[] str, UIntPtr length, UIntPtr pos);
[DllImport(efl.Libs.Eina)] public static extern byte
- eina_binbuf_insert_slice(IntPtr buf, eina.Slice slice, UIntPtr pos);
+ eina_binbuf_insert_slice(IntPtr buf, Eina.Slice slice, UIntPtr pos);
[DllImport(efl.Libs.Eina)] public static extern byte
eina_binbuf_insert_char(IntPtr buf, byte c, UIntPtr pos);
[DllImport(efl.Libs.Eina)] public static extern byte
eina_binbuf_string_free(IntPtr buf);
[DllImport(efl.Libs.Eina)] public static extern UIntPtr
eina_binbuf_length_get(IntPtr buf);
- [DllImport(efl.Libs.Eina)] public static extern eina.Slice
+ [DllImport(efl.Libs.Eina)] public static extern Eina.Slice
eina_binbuf_slice_get(IntPtr buf);
public IntPtr Handle {get;set;} = IntPtr.Zero;
return 0 != eina_binbuf_append_char(Handle, c);
}
- public bool Append(eina.Slice slice)
+ public bool Append(Eina.Slice slice)
{
return 0 != eina_binbuf_append_slice(Handle, slice);
}
return 0 != eina_binbuf_insert_char(Handle, c, (UIntPtr)pos);
}
- public bool Insert(eina.Slice slice, uint pos)
+ public bool Insert(Eina.Slice slice, uint pos)
{
return 0 != eina_binbuf_insert_slice(Handle, slice, (UIntPtr)pos);
}
return eina_binbuf_length_get(Handle);
}
- eina.Slice GetSlice()
+ Eina.Slice GetSlice()
{
return eina_binbuf_slice_get(Handle);
}
using System.Text;
using System.Runtime.InteropServices;
-namespace eina
+namespace Eina
{
namespace Callbacks
{
-public delegate int Eina_Compare_Cb(IntPtr data1, IntPtr data2);
-public delegate void Eina_Free_Cb(IntPtr data);
+public delegate int EinaCompareCb(IntPtr data1, IntPtr data2);
+public delegate void EinaFreeCb(IntPtr data);
}
{
if (nat == IntPtr.Zero)
{
- eina.Log.Error("Null pointer for primitive type.");
+ Eina.Log.Error("Null pointer for primitive type.");
return default(T);
}
- var w = Marshal.PtrToStructure<eina.ConvertWrapper<T> >(nat);
+ var w = Marshal.PtrToStructure<Eina.ConvertWrapper<T> >(nat);
return w.val;
}
using System;
using System.Runtime.InteropServices;
-namespace eina {
+namespace Eina {
public class Config {
[DllImport(efl.Libs.Eina)] private static extern int eina_init();
public static void Init() {
if (eina_init() == 0)
- throw (new efl.EflException("Failed to initialize Eina"));
+ throw (new Efl.EflException("Failed to initialize Eina"));
// Initialize the submodules here
- eina.Log.Init();
- eina.Error.Init();
+ Eina.Log.Init();
+ Eina.Error.Init();
}
public static int Shutdown() {
using System.Runtime.InteropServices;
using System.Collections.Generic;
-using eina.Callbacks;
-using static eina.HashNativeFunctions;
-using static eina.InarrayNativeFunctions;
-using static eina.InlistNativeFunctions;
-using static eina.NativeCustomExportFunctions;
-using static eina.ContainerCommonData;
+using Eina.Callbacks;
+using static Eina.HashNativeFunctions;
+using static Eina.InarrayNativeFunctions;
+using static Eina.InlistNativeFunctions;
+using static Eina.NativeCustomExportFunctions;
+using static Eina.ContainerCommonData;
-namespace eina {
+namespace Eina {
public enum ElementType { NumericType, StringType, ObjectType };
{
if (nat == IntPtr.Zero)
{
- eina.Log.Error("Null pointer for Inlist node.");
+ Eina.Log.Error("Null pointer for Inlist node.");
return default(T);
}
var w = Marshal.PtrToStructure< InlistNode<IntPtr> >(nat);
public IntPtr ManagedToNativeAlloc(T man)
{
- IntPtr h = ((efl.eo.IWrapper)man).raw_handle;
+ IntPtr h = ((Efl.Eo.IWrapper)man).NativeHandle;
if (h == IntPtr.Zero)
return h;
- return efl.eo.Globals.efl_ref(h);
+ return Efl.Eo.Globals.efl_ref(h);
}
public IntPtr ManagedToNativeAllocRef(T man, bool refs)
{
- IntPtr h = refs ? ManagedToNativeAlloc(man) : ((efl.eo.IWrapper)man).raw_handle;
+ IntPtr h = refs ? ManagedToNativeAlloc(man) : ((Efl.Eo.IWrapper)man).NativeHandle;
return intPtrTraits.ManagedToNativeAlloc(h);
}
public void NativeFree(IntPtr nat)
{
if (nat != IntPtr.Zero)
- efl.eo.Globals.efl_unref(nat);
+ Efl.Eo.Globals.efl_unref(nat);
}
public void NativeFreeRef(IntPtr nat, bool unrefs)
{
if (nat == IntPtr.Zero)
return default(T);
- return (T) Activator.CreateInstance(concreteType, efl.eo.Globals.efl_ref(nat));
+ return (T) Activator.CreateInstance(concreteType, Efl.Eo.Globals.efl_ref(nat));
}
public T NativeToManagedRef(IntPtr nat)
{
if (nat == IntPtr.Zero)
{
- eina.Log.Error("Null pointer for Inlist node.");
+ Eina.Log.Error("Null pointer for Inlist node.");
return default(T);
}
var w = Marshal.PtrToStructure< InlistNode<IntPtr> >(nat);
{
if (nat == IntPtr.Zero)
{
- eina.Log.Error("Null pointer on primitive/struct container.");
+ Eina.Log.Error("Null pointer on primitive/struct container.");
return default(T);
}
return PrimitiveConversion.PointerToManaged<T>(nat);
{
if (nat == IntPtr.Zero)
{
- eina.Log.Error("Null pointer for Inlist node.");
+ Eina.Log.Error("Null pointer for Inlist node.");
return default(T);
}
var w = Marshal.PtrToStructure< InlistNode<T> >(nat);
{
public static bool IsEflObject(System.Type type)
{
- return typeof(efl.eo.IWrapper).IsAssignableFrom(type);
+ return typeof(Efl.Eo.IWrapper).IsAssignableFrom(type);
}
public static bool IsString(System.Type type)
return type == typeof(string);
}
- public static eina.ElementType GetElementTypeCode(System.Type type)
+ public static Eina.ElementType GetElementTypeCode(System.Type type)
{
if (IsEflObject(type))
return ElementType.ObjectType;
using System;
using System.Runtime.InteropServices;
-namespace eina {
+namespace Eina {
public struct Error : IComparable<Error>
{
}
public override string ToString()
{
- return "eina.Error(" + code + ")";
+ return "Eina.Error(" + code + ")";
}
internal static void Init()
public static String MsgGet(Error error)
{
IntPtr cstr = eina_error_msg_get(error);
- return eina.StringConversion.NativeUtf8ToManagedString(cstr);
+ return Eina.StringConversion.NativeUtf8ToManagedString(cstr);
}
public static void RaiseIfOccurred()
public static void Raise(Error e)
{
if (e != 0)
- throw (new efl.EflException(MsgGet(e)));
+ throw (new Efl.EflException(MsgGet(e)));
}
public static void Clear()
using System.Runtime.InteropServices;
using System.Collections.Generic;
-using static eina.TraitFunctions;
-using static eina.IteratorNativeFunctions;
-using static eina.HashNativeFunctions;
-using eina.Callbacks;
+using static Eina.TraitFunctions;
+using static Eina.IteratorNativeFunctions;
+using static Eina.HashNativeFunctions;
+using Eina.Callbacks;
-namespace eina
+namespace Eina
{
[StructLayout(LayoutKind.Sequential)]
return eina_hash_population(Handle);
}
- public eina.Iterator<TKey> Keys()
+ public Eina.Iterator<TKey> Keys()
{
- return new eina.Iterator<TKey>(EinaHashIteratorKeyNew<TKey>(Handle), true, false);
+ return new Eina.Iterator<TKey>(EinaHashIteratorKeyNew<TKey>(Handle), true, false);
}
- public eina.Iterator<TValue> Values()
+ public Eina.Iterator<TValue> Values()
{
- return new eina.Iterator<TValue>(eina_hash_iterator_data_new(Handle), true, false);
+ return new Eina.Iterator<TValue>(eina_hash_iterator_data_new(Handle), true, false);
}
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
{
for (IntPtr tuplePtr; eina_iterator_next(itr, out tuplePtr);)
{
- var tuple = Marshal.PtrToStructure<eina.HashTupleNative>(tuplePtr);
+ var tuple = Marshal.PtrToStructure<Eina.HashTupleNative>(tuplePtr);
var key = NativeToManagedRef<TKey>(tuple.key);
var val = NativeToManaged<TValue>(tuple.data);
yield return new KeyValuePair<TKey, TValue>(key, val);
using System.Runtime.InteropServices;
using System.Collections.Generic;
-using static eina.TraitFunctions;
-using static eina.InarrayNativeFunctions;
+using static Eina.TraitFunctions;
+using static Eina.InarrayNativeFunctions;
-namespace eina {
+namespace Eina {
public static class InarrayNativeFunctions
{
return true;
}
- public eina.Iterator<T> GetIterator()
+ public Eina.Iterator<T> GetIterator()
{
- return new eina.Iterator<T>(eina_inarray_iterator_new(Handle), true, false);
+ return new Eina.Iterator<T>(eina_inarray_iterator_new(Handle), true, false);
}
- public eina.Iterator<T> GetReversedIterator()
+ public Eina.Iterator<T> GetReversedIterator()
{
- return new eina.Iterator<T>(eina_inarray_iterator_reversed_new(Handle), true, false);
+ return new Eina.Iterator<T>(eina_inarray_iterator_reversed_new(Handle), true, false);
}
public IEnumerator<T> GetEnumerator()
}
/// <summary> Gets an Accessor for this Array.</summary>
- public eina.Accessor<T> GetAccessor()
+ public Eina.Accessor<T> GetAccessor()
{
- return new eina.AccessorInArray<T>(eina_inarray_accessor_new(Handle), Ownership.Managed);
+ return new Eina.AccessorInArray<T>(eina_inarray_accessor_new(Handle), Ownership.Managed);
}
}
using System.Runtime.InteropServices;
using System.Collections.Generic;
-using static eina.TraitFunctions;
-using static eina.InlistNativeFunctions;
-using eina.Callbacks;
+using static Eina.TraitFunctions;
+using static Eina.InlistNativeFunctions;
+using Eina.Callbacks;
-namespace eina {
+namespace Eina {
public static class InlistNativeFunctions
{
}
- public eina.Iterator<T> GetIterator()
+ public Eina.Iterator<T> GetIterator()
{
- return new eina.Iterator<T>(eina_inlist_iterator_wrapper_new_custom_export_mono(Handle), true, false);
+ return new Eina.Iterator<T>(eina_inlist_iterator_wrapper_new_custom_export_mono(Handle), true, false);
}
public IEnumerator<T> GetEnumerator()
}
/// <summary> Gets an Accessor for this List.</summary>
- public eina.Accessor<T> GetAccessor()
+ public Eina.Accessor<T> GetAccessor()
{
- return new eina.AccessorInList<T>(eina_inlist_accessor_new(Handle), Ownership.Managed);
+ return new Eina.AccessorInList<T>(eina_inlist_accessor_new(Handle), Ownership.Managed);
}
}
using System.Runtime.InteropServices;
using System.Collections.Generic;
-using static eina.TraitFunctions;
-using static eina.IteratorNativeFunctions;
+using static Eina.TraitFunctions;
+using static Eina.IteratorNativeFunctions;
-namespace eina {
+namespace Eina {
public static class IteratorNativeFunctions
{
using System.Runtime.InteropServices;
using System.Collections.Generic;
-using static eina.TraitFunctions;
-using static eina.ListNativeFunctions;
-using eina.Callbacks;
+using static Eina.TraitFunctions;
+using static Eina.ListNativeFunctions;
+using Eina.Callbacks;
-namespace eina {
+namespace Eina {
public static class ListNativeFunctions
{
}
- public eina.Iterator<T> GetIterator()
+ public Eina.Iterator<T> GetIterator()
{
- return new eina.Iterator<T>(eina_list_iterator_new(Handle), true, false);
+ return new Eina.Iterator<T>(eina_list_iterator_new(Handle), true, false);
}
- public eina.Iterator<T> GetReversedIterator()
+ public Eina.Iterator<T> GetReversedIterator()
{
- return new eina.Iterator<T>(eina_list_iterator_reversed_new(Handle), true, false);
+ return new Eina.Iterator<T>(eina_list_iterator_reversed_new(Handle), true, false);
}
public IEnumerator<T> GetEnumerator()
}
/// <summary> Gets an Accessor for this List.</summary>
- public eina.Accessor<T> GetAccessor()
+ public Eina.Accessor<T> GetAccessor()
{
- return new eina.Accessor<T>(eina_list_accessor_new(Handle), Ownership.Managed);
+ return new Eina.Accessor<T>(eina_list_accessor_new(Handle), Ownership.Managed);
}
}
using System.Runtime.CompilerServices;
using System.Diagnostics.Contracts;
-namespace eina { // Manual wrappers around eina functions
+namespace Eina { // Manual wrappers around eina functions
public class Log
{
using System.Linq;
-using static eina.EinaNative.PromiseNativeMethods;
+using static Eina.EinaNative.PromiseNativeMethods;
-namespace eina {
+namespace Eina {
namespace EinaNative {
internal static extern IntPtr eina_promise_new(IntPtr scheduler, Promise_Cancel_Cb cancel_cb, IntPtr data);
[DllImport(efl.Libs.Eina)]
- internal static extern void eina_promise_resolve(IntPtr scheduler, eina.Value_Native value);
+ internal static extern void eina_promise_resolve(IntPtr scheduler, Eina.ValueNative value);
[DllImport(efl.Libs.Eina)]
- internal static extern void eina_promise_reject(IntPtr scheduler, eina.Error reason);
+ internal static extern void eina_promise_reject(IntPtr scheduler, Eina.Error reason);
[DllImport(efl.Libs.Eina)]
internal static extern IntPtr eina_future_new(IntPtr promise);
[DllImport(efl.Libs.Eina)]
internal static extern IntPtr eina_future_chain_array(IntPtr prev, FutureDesc[] desc);
- internal delegate eina.Value_Native FutureCb(IntPtr data, eina.Value_Native value, IntPtr dead_future);
+ internal delegate Eina.ValueNative FutureCb(IntPtr data, Eina.ValueNative value, IntPtr dead_future);
[StructLayout(LayoutKind.Sequential)]
internal struct FutureDesc
/// </summary>
public Promise(CancelCb cancelCb=null)
{
- efl.ILoop loop = efl.App.GetLoopMain();
+ Efl.Loop loop = Efl.App.GetLoopMain();
// Should we be able to pass different schedulers?
- IntPtr scheduler = efl_loop_future_scheduler_get(loop.raw_handle);
+ IntPtr scheduler = efl_loop_future_scheduler_get(loop.NativeHandle);
IntPtr cb_data = IntPtr.Zero;
if (cb != null)
cb();
else
- eina.Log.Info("Null promise CancelCb found");
+ Eina.Log.Info("Null promise CancelCb found");
handle.Free();
}
{
if (Handle != IntPtr.Zero)
{
- eina_promise_reject(Handle, eina.Error.ECANCELED);
+ eina_promise_reject(Handle, Eina.Error.ECANCELED);
Handle = IntPtr.Zero;
}
}
///
/// This will make all futures attached to it to be called with the given value as payload.
/// </summary>
- public void Resolve(eina.Value value)
+ public void Resolve(Eina.Value value)
{
SanityChecks();
eina_promise_resolve(this.Handle, value);
/// <summary>
/// Rejects a promise.
///
- /// The future chain attached to this promise will be called with an eina.Value of type
- /// eina.ValueType.Error and payload eina.Error.ECANCELED.
+ /// The future chain attached to this promise will be called with an Eina.Value of type
+ /// Eina.ValueType.Error and payload Eina.Error.ECANCELED.
/// </summary>
- public void Reject(eina.Error reason)
+ public void Reject(Eina.Error reason)
{
SanityChecks();
eina_promise_reject(this.Handle, reason);
/// <summary>
/// Callback attached to a future and to be called when resolving/rejecting a promise.
///
- /// The eina.Value as argument can come with an eina.Error.ECANCELED as payload if the
+ /// The Eina.Value as argument can come with an Eina.Error.ECANCELED as payload if the
/// promise/future was rejected/cancelled.
///
/// The return value usually is same as the argument, forwarded, but can be changed in
/// case were the chain act as a transforming pipeline.
/// </summary>
- public delegate eina.Value ResolvedCb(eina.Value value);
+ public delegate Eina.Value ResolvedCb(Eina.Value value);
public IntPtr Handle { get; internal set; }
/// </summary>
public Future(IntPtr handle)
{
- Handle = ThenRaw(handle, (eina.Value value) => {
+ Handle = ThenRaw(handle, (Eina.Value value) => {
Handle = IntPtr.Zero;
return value;
});
public Future(Promise promise, ResolvedCb cb=null)
{
IntPtr intermediate = eina_future_new(promise.Handle);
- Handle = ThenRaw(intermediate, (eina.Value value) => {
+ Handle = ThenRaw(intermediate, (Eina.Value value) => {
if (cb != null)
value = cb(value);
Handle = IntPtr.Zero;
/// <summary>
/// Cancels this future and the chain it belongs to, along with the promise linked against it.
///
- /// The callbacks will still be called with eina.Error.ECANCELED as payload. The promise cancellation
+ /// The callbacks will still be called with Eina.Error.ECANCELED as payload. The promise cancellation
/// callback will also be called if present.
/// </summary>
public void Cancel()
desc.data = GCHandle.ToIntPtr(handle);
return eina_future_then_from_desc(previous, desc);
}
- private static eina.Value_Native NativeResolvedCb(IntPtr data, eina.Value_Native value, IntPtr dead_future)
+ private static Eina.ValueNative NativeResolvedCb(IntPtr data, Eina.ValueNative value, IntPtr dead_future)
{
GCHandle handle = GCHandle.FromIntPtr(data);
ResolvedCb cb = handle.Target as ResolvedCb;
if (cb != null)
value = cb(value);
else
- eina.Log.Warning("Failed to get future callback.");
+ Eina.Log.Warning("Failed to get future callback.");
handle.Free();
return value;
}
GCHandle handle = GCHandle.FromIntPtr(descs[i].data);
handle.Free();
}
- eina.Log.Error($"Failed to create native future description for callbacks. Error: {e.ToString()}");
+ Eina.Log.Error($"Failed to create native future description for callbacks. Error: {e.ToString()}");
return null;
}
return new Future(eina_future_chain_array(Handle, descs));
using System;
using System.Runtime.InteropServices;
-namespace eina {
+namespace Eina {
public interface ISliceBase
{
}
[StructLayout(LayoutKind.Sequential)]
-public struct Rw_Slice : ISliceBase
+public struct RwSlice : ISliceBase
{
public UIntPtr Len {get;set;}
public IntPtr Mem {get;set;}
set { Len = (UIntPtr) value; }
}
- public Rw_Slice(IntPtr mem, UIntPtr len)
+ public RwSlice(IntPtr mem, UIntPtr len)
{
Mem = mem;
Len = len;
}
- public Rw_Slice PinnedDataSet(IntPtr mem, UIntPtr len)
+ public RwSlice PinnedDataSet(IntPtr mem, UIntPtr len)
{
Mem = mem;
Len = len;
public static class Eina_SliceUtils
{
- public static byte[] GetBytes(this eina.ISliceBase slc)
+ public static byte[] GetBytes(this Eina.ISliceBase slc)
{
var size = (int)(slc.Len);
byte[] mArray = new byte[size];
using System;
using System.Runtime.InteropServices;
-using static eina.EinaNative.StrbufNativeMethods;
+using static Eina.EinaNative.StrbufNativeMethods;
-namespace eina
+namespace Eina
{
namespace EinaNative
{
using System.Runtime.InteropServices;
-namespace eina {
+namespace Eina {
public class Stringshare {
[DllImport(efl.Libs.Eina)] public static extern System.IntPtr
using System.Diagnostics.CodeAnalysis;
using System.Runtime.Serialization;
-using static eina.EinaNative.UnsafeNativeMethods;
-using static eina.TraitFunctions;
+using static Eina.EinaNative.UnsafeNativeMethods;
+using static Eina.TraitFunctions;
-namespace eina {
+namespace Eina {
namespace EinaNative {
[DllImport(efl.Libs.Eina)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
- internal static extern bool eina_value_optional_pget(IntPtr handle, out eina.EinaNative.Value_Array output);
+ internal static extern bool eina_value_optional_pget(IntPtr handle, out Eina.EinaNative.Value_Array output);
[DllImport(efl.Libs.Eina)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
- internal static extern bool eina_value_optional_pget(IntPtr handle, out eina.EinaNative.Value_List output);
+ internal static extern bool eina_value_optional_pget(IntPtr handle, out Eina.EinaNative.Value_List output);
[DllImport(efl.Libs.Eina)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
[DllImport(efl.Libs.CustomExports)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
- internal static extern bool eina_value_pset_wrapper(IntPtr handle, ref eina.EinaNative.Value_Array ptr);
+ internal static extern bool eina_value_pset_wrapper(IntPtr handle, ref Eina.EinaNative.Value_Array ptr);
[DllImport(efl.Libs.CustomExports)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
- internal static extern bool eina_value_pset_wrapper(IntPtr handle, ref eina.EinaNative.Value_List ptr);
+ internal static extern bool eina_value_pset_wrapper(IntPtr handle, ref Eina.EinaNative.Value_List ptr);
[DllImport(efl.Libs.Eina)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
/// <summary>Struct for passing Values by value to Unmanaged functions.</summary>
[StructLayout(LayoutKind.Sequential)]
-public struct Value_Native
+public struct ValueNative
{
public IntPtr Type;
public IntPtr Value; // Atually an Eina_Value_Union, but it is padded to 8 bytes.
public override string ToString()
{
- return $"Value_Native<Type:0x{Type.ToInt64():x}, Value:0x{Value.ToInt64():x}>";
+ return $"ValueNative<Type:0x{Type.ToInt64():x}, Value:0x{Value.ToInt64():x}>";
}
}
private static void LoadTypes()
{
- eina.Config.Init(); // Make sure eina is initialized.
+ Eina.Config.Init(); // Make sure eina is initialized.
ManagedToNative.Add(ValueType.SByte, type_sbyte());
NativeToManaged.Add(type_sbyte(), ValueType.SByte);
// Ok EINA_VALUE_TYPE_DOUBLE: double -- double
// EINA_VALUE_TYPE_STRINGSHARE: const char * -- string
// Ok EINA_VALUE_TYPE_STRING: const char * -- string
- // Ok EINA_VALUE_TYPE_ARRAY: Eina_Value_Array -- eina.Array?
- // Ok EINA_VALUE_TYPE_LIST: Eina_Value_List -- eina.List?
- // EINA_VALUE_TYPE_HASH: Eina_Value_Hash -- eina.Hash?
+ // Ok EINA_VALUE_TYPE_ARRAY: Eina_Value_Array -- Eina.Array?
+ // Ok EINA_VALUE_TYPE_LIST: Eina_Value_List -- Eina.List?
+ // EINA_VALUE_TYPE_HASH: Eina_Value_Hash -- Eina.Hash?
// EINA_VALUE_TYPE_TIMEVAL: struct timeval -- FIXME
// EINA_VALUE_TYPE_BLOB: Eina_Value_Blob -- FIXME
// EINA_VALUE_TYPE_STRUCT: Eina_Value_Struct -- FIXME
/// <summary> Whether this is an Optional value (meaning it can have a value or not). </summary>
public bool Optional {
get {
- return GetValueType() == eina.ValueType.Optional;
+ return GetValueType() == Eina.ValueType.Optional;
}
/* protected set {
// Should we expose this?
public bool Empty {
get {
SanityChecks();
- return GetValueType() == eina.ValueType.Empty;
+ return GetValueType() == Eina.ValueType.Empty;
}
}
this.Handle = Alloc();
if (this.Handle == IntPtr.Zero)
- throw new OutOfMemoryException("Failed to allocate memory for eina.Value");
+ throw new OutOfMemoryException("Failed to allocate memory for Eina.Value");
// Initialize to EINA_VALUE_EMPTY before performing any other operation on this value.
MemoryNative.Memset(this.Handle, 0, eina_value_sizeof());
}
/// <summary>Constructor to build value from Values_Natives passed by value from C.</summary>
- public Value(Value_Native value)
+ public Value(ValueNative value)
{
IntPtr tmp = IntPtr.Zero;
try {
this.Handle = Alloc();
if (value.Type == IntPtr.Zero) // Got an EINA_VALUE_EMPTY by value.
- MemoryNative.Memset(this.Handle, 0, Marshal.SizeOf(typeof(Value_Native)));
+ MemoryNative.Memset(this.Handle, 0, Marshal.SizeOf(typeof(ValueNative)));
else
{
- // We allocate this intermediate Value_Native using malloc to allow freeing with
+ // We allocate this intermediate ValueNative using malloc to allow freeing with
// free(), avoiding a call to eina_value_flush that would wipe the underlying value contents
// for pointer types like string.
- tmp = MemoryNative.Alloc(Marshal.SizeOf(typeof(Value_Native)));
+ tmp = MemoryNative.Alloc(Marshal.SizeOf(typeof(ValueNative)));
Marshal.StructureToPtr(value, tmp, false); // Can't get the address of a struct directly.
this.Handle = Alloc();
}
/// <summary>Implicit conversion from managed value to native struct representation.</summary>
- public static implicit operator Value_Native(Value v)
+ public static implicit operator ValueNative(Value v)
{
return v.GetNative();
}
/// <summary>Implicit conversion from native struct representation to managed wrapper.</summary>
- public static implicit operator Value(Value_Native v)
+ public static implicit operator Value(ValueNative v)
{
return new Value(v);
}
/// <summary>Creates an Value instance from a given array description.</summary>
- private static Value FromArrayDesc(eina.EinaNative.Value_Array arrayDesc)
+ private static Value FromArrayDesc(Eina.EinaNative.Value_Array arrayDesc)
{
Value value = new Value();
value.Setup(ValueType.Array, ValueType.String); // Placeholder values to be overwritten by the following pset call.
}
/// <summary>Creates an Value instance from a given array description.</summary>
- private static Value FromListDesc(eina.EinaNative.Value_List listDesc)
+ private static Value FromListDesc(Eina.EinaNative.Value_List listDesc)
{
Value value = new Value();
value.Setup(ValueType.List, ValueType.String); // Placeholder values to be overwritten by the following pset call.
throw new ObjectDisposedException(base.GetType().Name);
// Can't call setup with Empty value type (would give an eina error)
- if (type == eina.ValueType.Empty)
+ if (type == Eina.ValueType.Empty)
{
// Need to cleanup as it may point to payload outside the underlying Eina_Value (like arrays and strings).
if (!Empty)
Flushed = true;
}
- /// <summary>Get a Value_Native struct with the *value* pointed by this eina.Value.</summary>
- public Value_Native GetNative()
+ /// <summary>Get a ValueNative struct with the *value* pointed by this Eina.Value.</summary>
+ public ValueNative GetNative()
{
- Value_Native value = (Value_Native)Marshal.PtrToStructure(this.Handle, typeof(Value_Native));
+ ValueNative value = (ValueNative)Marshal.PtrToStructure(this.Handle, typeof(ValueNative));
return value;
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_uchar(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_char(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_short(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_ushort(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_uint(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_int(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_ulong(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_long(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_float(this.Handle, value);
}
if (!GetValueType().IsNumeric())
throw (new ArgumentException(
- "Trying to set numeric value on a non-numeric eina.Value"));
+ "Trying to set numeric value on a non-numeric Eina.Value"));
return eina_value_set_wrapper_double(this.Handle, value);
}
if (!GetValueType().IsString())
throw (new ArgumentException(
- "Trying to set non-string value on a string eina.Value"));
+ "Trying to set non-string value on a string Eina.Value"));
// No need to worry about ownership as eina_value_set will copy the passed string.
return eina_value_set_wrapper_string(this.Handle, value);
}
/// <summary>Stores the given error value.</summary>
- public bool Set(eina.Error value)
+ public bool Set(Eina.Error value)
{
SanityChecks();
Marshal.StructureToPtr(value_list, ptr_val, false);
break;
default:
- throw new InvalidValueTypeException("Only containers can be passed as raw eina.Values");
+ throw new InvalidValueTypeException("Only containers can be passed as raw Eina.Values");
}
return eina_value_optional_pset(this.Handle, native_type, ptr_val);
return true;
}
- /// <summary>Gets the currently stored value as an eina.Error.</summary>
- public bool Get(out eina.Error value)
+ /// <summary>Gets the currently stored value as an Eina.Error.</summary>
+ public bool Get(out Eina.Error value)
{
SanityChecks();
bool ret;
return ret;
}
- /// <summary>Gets the currently stored value as an complex (e.g. container) eina.Value.</summary>
+ /// <summary>Gets the currently stored value as an complex (e.g. container) Eina.Value.</summary>
public bool Get(out Value value)
{
SanityChecks();
switch (managedType) {
case ValueType.Array:
- eina.EinaNative.Value_Array array_desc;
+ Eina.EinaNative.Value_Array array_desc;
if (!eina_value_optional_pget(this.Handle, out array_desc))
return false;
value = Value.FromArrayDesc(array_desc);
break;
case ValueType.List:
- eina.EinaNative.Value_List list_desc;
+ Eina.EinaNative.Value_List list_desc;
if (!eina_value_optional_pget(this.Handle, out list_desc))
return false;
return str;
}
- /// <summary>Empties an optional eina.Value, freeing what was previously contained.</summary>
+ /// <summary>Empties an optional Eina.Value, freeing what was previously contained.</summary>
public bool Reset()
{
OptionalSanityChecks();
{
if (!InternalAppendTo(msg))
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not append basic type to eldbus.Message");
}
}
{
if (!InternalAppendTo(iter))
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not append basic type to eldbus.MessageIterator");
}
}
public static void RaiseNullHandle()
{
if (NullHandleError == 0)
- NullHandleError = eina.Error.Register("Eldbus: null handle");
- eina.Error.Raise(NullHandleError);
+ NullHandleError = Eina.Error.Register("Eldbus: null handle");
+ Eina.Error.Raise(NullHandleError);
}
public delegate void Eldbus_Message_Cb(IntPtr data, IntPtr msg, IntPtr pending);
MessageDelegate dlgt = Marshal.GetDelegateForFunctionPointer(data, typeof(MessageDelegate)) as MessageDelegate;
if (dlgt == null)
{
- eina.Log.Error("Eldbus: invalid delegate pointer from Eldbus_Message_Cb");
+ Eina.Log.Error("Eldbus: invalid delegate pointer from Eldbus_Message_Cb");
return;
}
}
catch(Exception e)
{
- eina.Log.Error("Eldbus: could not convert Eldbus_Message_Cb parameters. Exception: " + e.ToString());
+ Eina.Log.Error("Eldbus: could not convert Eldbus_Message_Cb parameters. Exception: " + e.ToString());
return;
}
}
catch(Exception e)
{
- eina.Log.Error("Eldbus: Eldbus_Message_Cb delegate error. Exception: " + e.ToString());
+ Eina.Log.Error("Eldbus: Eldbus_Message_Cb delegate error. Exception: " + e.ToString());
}
}
private static Eldbus_Message_Cb message_cb_wrapper = null;
- private static eina.Error NullHandleError = 0;
+ private static Eina.Error NullHandleError = 0;
}
}
public static void Init()
{
if (eldbus_init() == 0)
- throw new efl.EflException("Failed to initialize Eldbus");
+ throw new Efl.EflException("Failed to initialize Eldbus");
}
public static void Shutdown()
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_connection_send");
}
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_name_request");
}
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_name_release");
}
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_name_owner_get");
}
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_name_owner_has");
}
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_names_list");
}
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_names_activatable_list");
}
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_hello");
}
if(pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_name_start");
}
var ptr = eldbus_message_method_call_new(dest, path, iface, method);
if (ptr == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Message' object from eldbus_message_method_call_new");
}
return new eldbus.Message(ptr, true);
var ptr = eldbus_message_signal_new(path, _interface, name);
if (ptr == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Message' object from eldbus_message_signal_new");
}
return new eldbus.Message(ptr, true);
var ptr = eldbus_message_error_new(Handle, error_name, error_msg);
if (ptr == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Message' object from eldbus_message_error_new");
}
return new eldbus.Message(ptr, false);
var ptr = eldbus_message_method_return_new(Handle);
if (ptr == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Message' object from eldbus_message_method_return_new");
}
return new eldbus.Message(ptr, false);
var ptr = eldbus_message_iter_get(Handle);
if (ptr == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `MessageIterator' object from eldbus_message_iter_get");
}
return new eldbus.MessageIterator(ptr, IntPtr.Zero);
}
else if (!eldbus_message_iter_arguments_append(Handle, signature, out new_iter))
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not append container type");
}
if (new_iter == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `MessageIterator' object from eldbus_message_iter_arguments_append");
}
if (new_iter == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `MessageIterator' object from eldbus_message_iter_container_new");
}
if (!eldbus_message_iter_container_close(Parent, Handle))
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not close MessageIterator");
}
bool r = eldbus_message_iter_get_and_next(Handle, typecode, out hdl);
if (hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get argument");
}
iter = new eldbus.MessageIterator(hdl, Handle);
IntPtr hdl = IntPtr.Zero;
if (!eldbus_message_iter_arguments_get(Handle, signatue, out hdl) || hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get argument");
}
iter = new eldbus.MessageIterator(hdl, Handle);
IntPtr hdl = IntPtr.Zero;
if (!eldbus_message_iter_arguments_get(Handle, signatue, out hdl) || hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get argument");
}
iter = new eldbus.MessageIterator(hdl, Handle);
if (!eldbus_message_iter_fixed_array_get(Handle, type_code, out value, out n_elements))
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get fixed array");
}
}
if (handle == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Object' object from eldbus_object_get");
}
if (conn == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Connection' object from eldbus_object_connection_get");
}
if (pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_object_send");
}
if (hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Message' object from eldbus_object_method_call_new");
}
if (pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_object_peer_ping");
}
if (pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_object_peer_machine_id_get");
}
if (pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_object_introspect");
}
if (pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_object_managed_objects_get");
}
var ptr = eldbus_proxy_object_get(Handle);
if (ptr == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Object' object from eldbus_proxy_object_get");
}
return new eldbus.Object(ptr, false);
var ptr = eldbus_proxy_method_call_new(Handle, member);
if (ptr == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Message' object from eldbus_proxy_method_call_new");
}
return new eldbus.Message(ptr, false);
if (pending_hdl == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Pending' object from eldbus_proxy_send");
}
var ptr = eldbus_proxy_send_and_block(Handle, msg.Handle, timeout);
if (ptr == IntPtr.Zero)
{
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
throw new SEHException("Eldbus: could not get `Message' object from eldbus_proxy_send_and_block");
}
return new eldbus.Message(ptr, true);
using System.Diagnostics;
using System.Threading;
-using static eina.NativeCustomExportFunctions;
+using static Eina.NativeCustomExportFunctions;
-namespace efl { namespace eo {
+namespace Efl { namespace Eo {
public class Globals {
[DllImport(efl.Libs.Eo)] public static extern void efl_object_init();
_efl_add_end(IntPtr eo, byte is_ref, byte is_fallback);
[DllImport(efl.Libs.Eo)] public static extern IntPtr
efl_ref(IntPtr eo);
- [DllImport(efl.Libs.Eo)] public static extern void
+ [DllImport(efl.Libs.CustomExports)] public static extern void
efl_unref(IntPtr eo);
+ [DllImport(efl.Libs.Eo)] public static extern int
+ efl_ref_count(IntPtr eo);
[DllImport(efl.Libs.Eo)] public static extern IntPtr
efl_class_new(IntPtr class_description, IntPtr base0);
[DllImport(efl.Libs.Eo)] public static extern IntPtr
System.IntPtr obj,
IntPtr desc,
short priority,
- efl.Event_Cb cb,
+ Efl.EventCb cb,
System.IntPtr data);
[DllImport(efl.Libs.Eo)] public static extern bool efl_event_callback_del(
System.IntPtr obj,
IntPtr desc,
- efl.Event_Cb cb,
+ Efl.EventCb cb,
System.IntPtr data);
[DllImport(efl.Libs.Eo)] public static extern IntPtr
efl_object_legacy_only_event_description_get([MarshalAs(UnmanagedType.LPStr)] String name);
if(initializer != null)
description.class_initializer = Marshal.GetFunctionPointerForDelegate(initializer);
- IntPtr description_ptr = eina.MemoryNative.Alloc(Marshal.SizeOf(description));
+ IntPtr description_ptr = Eina.MemoryNative.Alloc(Marshal.SizeOf(description));
Marshal.StructureToPtr(description, description_ptr, false);
- eina.Log.Debug("Going to register!");
- IntPtr klass = efl.eo.Globals.efl_class_new(description_ptr, base_klass, IntPtr.Zero);
+ Eina.Log.Debug("Going to register!");
+ IntPtr klass = Efl.Eo.Globals.efl_class_new(description_ptr, base_klass, IntPtr.Zero);
if(klass == IntPtr.Zero)
- eina.Log.Error("klass was not registered");
- eina.Log.Debug("Registered?");
+ Eina.Log.Error("klass was not registered");
+ else
+ Eina.Log.Debug("Registered class successfully");
return klass;
}
- public static IntPtr instantiate_start(IntPtr klass, efl.IObject parent)
+ public static IntPtr instantiate_start(IntPtr klass, Efl.Object parent)
{
- eina.Log.Debug("Instantiating");
+ Eina.Log.Debug($"Instantiating from klass 0x{klass.ToInt64():x}");
System.IntPtr parent_ptr = System.IntPtr.Zero;
if(parent != null)
- parent_ptr = parent.raw_handle;
+ parent_ptr = parent.NativeHandle;
- System.IntPtr eo = efl.eo.Globals._efl_add_internal_start("file", 0, klass, parent_ptr, 1, 0);
+ System.IntPtr eo = Efl.Eo.Globals._efl_add_internal_start("file", 0, klass, parent_ptr, 1, 0);
+ Console.WriteLine($"Eo instance right after internal_start 0x{eo.ToInt64():x} with refcount {Efl.Eo.Globals.efl_ref_count(eo)}");
+ Console.WriteLine($"Parent was 0x{parent_ptr.ToInt64()}");
return eo;
}
public static IntPtr instantiate_end(IntPtr eo) {
- eina.Log.Debug("efl_add_internal_start returned");
- eo = efl.eo.Globals._efl_add_end(eo, 1, 0);
- eina.Log.Debug("efl_add_end returned");
+ Eina.Log.Debug("calling efl_add_internal_end");
+ eo = Efl.Eo.Globals._efl_add_end(eo, 1, 0);
+ Eina.Log.Debug($"efl_add_end returned eo 0x{eo.ToInt64():x}");
return eo;
}
- public static void data_set(efl.eo.IWrapper obj)
+ public static void data_set(Efl.Eo.IWrapper obj)
{
- IntPtr pd = efl.eo.Globals.efl_data_scope_get(obj.raw_handle, obj.raw_klass);
+ Eina.Log.Debug($"Calling data_scope_get with obj {obj.NativeHandle.ToInt64():x} and klass {obj.NativeClass.ToInt64():x}");
+ IntPtr pd = Efl.Eo.Globals.efl_data_scope_get(obj.NativeHandle, obj.NativeClass);
{
GCHandle gch = GCHandle.Alloc(obj);
EolianPD epd;
Marshal.StructureToPtr(epd, pd, false);
}
}
- public static efl.eo.IWrapper data_get(IntPtr pd)
+ public static Efl.Eo.IWrapper data_get(IntPtr pd)
{
EolianPD epd = (EolianPD)Marshal.PtrToStructure(pd, typeof(EolianPD));
if(epd.pointer != IntPtr.Zero)
{
GCHandle gch = GCHandle.FromIntPtr(epd.pointer);
- return (efl.eo.IWrapper)gch.Target;
+ return (Efl.Eo.IWrapper)gch.Target;
}
else
return null;
IntPtr ptr = IntPtr.Zero;
if (!dict.TryGetValue(str, out ptr))
{
- ptr = eina.StringConversion.ManagedStringToNativeUtf8Alloc(str);
+ ptr = Eina.StringConversion.ManagedStringToNativeUtf8Alloc(str);
dict[str] = ptr;
}
IntPtr ptr = IntPtr.Zero;
if (!dict.TryGetValue(str, out ptr))
{
- ptr = eina.Stringshare.eina_stringshare_add(str);
+ ptr = Eina.Stringshare.eina_stringshare_add(str);
dict[str] = ptr;
}
{
foreach(IntPtr ptr in dict.Values)
{
- eina.MemoryNative.Free(ptr);
+ Eina.MemoryNative.Free(ptr);
}
}
{
foreach(IntPtr ptr in dict.Values)
{
- eina.Stringshare.eina_stringshare_del(ptr);
+ Eina.Stringshare.eina_stringshare_del(ptr);
}
}
handle.Free();
}
- public static System.Threading.Tasks.Task<eina.Value> WrapAsync(eina.Future future, CancellationToken token)
+ public static System.Threading.Tasks.Task<Eina.Value> WrapAsync(Eina.Future future, CancellationToken token)
{
// Creates a task that will wait for SetResult for completion.
// TaskCompletionSource is used to create tasks for 'external' Task sources.
- var tcs = new System.Threading.Tasks.TaskCompletionSource<eina.Value>();
+ var tcs = new System.Threading.Tasks.TaskCompletionSource<Eina.Value>();
// Flag to be passed to the cancell callback
bool fulfilled = false;
- future.Then((eina.Value received) => {
+ future.Then((Eina.Value received) => {
lock (future)
{
// Convert an failed Future to a failed Task.
- if (received.GetValueType() == eina.ValueType.Error)
+ if (received.GetValueType() == Eina.ValueType.Error)
{
- eina.Error err;
+ Eina.Error err;
received.Get(out err);
- if (err == eina.Error.ECANCELED)
+ if (err == Eina.Error.ECANCELED)
tcs.SetCanceled();
else
- tcs.TrySetException(new efl.FutureException(received));
+ tcs.TrySetException(new Efl.FutureException(received));
}
else
{
token.Register(() => {
lock (future)
{
- // Will trigger the Then callback above with an eina.Error
+ // Will trigger the Then callback above with an Eina.Error
if (!fulfilled)
future.Cancel();
}
public interface IWrapper
{
- IntPtr raw_handle
+ /// <summary>Pointer to internal Eo instance.</summary>
+ IntPtr NativeHandle
{
get;
}
- IntPtr raw_klass
+ /// <summary>Pointer to internal Eo class.</summary>
+ IntPtr NativeClass
{
get;
}
{
public static ICustomMarshaler GetInstance(string cookie)
{
- eina.Log.Debug("MarshalTest.GetInstace cookie " + cookie);
+ Eina.Log.Debug("MarshalTest.GetInstace cookie " + cookie);
return new MarshalTest<T, U>();
}
public void CleanUpManagedData(object ManagedObj)
{
- //eina.Log.Warning("MarshalTest.CleanUpManagedData not implemented");
+ //Eina.Log.Warning("MarshalTest.CleanUpManagedData not implemented");
//throw new NotImplementedException();
}
public void CleanUpNativeData(IntPtr pNativeData)
{
- //eina.Log.Warning("MarshalTest.CleanUpNativeData not implemented");
+ //Eina.Log.Warning("MarshalTest.CleanUpNativeData not implemented");
//throw new NotImplementedException();
}
public int GetNativeDataSize()
{
- eina.Log.Debug("MarshalTest.GetNativeDataSize");
+ Eina.Log.Debug("MarshalTest.GetNativeDataSize");
return 0;
//return 8;
}
public IntPtr MarshalManagedToNative(object ManagedObj)
{
- eina.Log.Debug("MarshalTest.MarshallManagedToNative");
- var r = ((IWrapper)ManagedObj).raw_handle;
+ Eina.Log.Debug("MarshalTest.MarshallManagedToNative");
+ var r = ((IWrapper)ManagedObj).NativeHandle;
if (typeof(U) == typeof(OwnTag))
- efl.eo.Globals.efl_ref(r);
+ Efl.Eo.Globals.efl_ref(r);
return r;
}
public object MarshalNativeToManaged(IntPtr pNativeData)
{
- eina.Log.Debug("MarshalTest.MarshalNativeToManaged");
+ Eina.Log.Debug("MarshalTest.MarshalNativeToManaged");
if (typeof(U) != typeof(OwnTag))
- efl.eo.Globals.efl_ref(pNativeData);
+ Efl.Eo.Globals.efl_ref(pNativeData);
return Activator.CreateInstance(typeof(T), new System.Object[] {pNativeData});
// return null;
}
public class StringPassOwnershipMarshaler : ICustomMarshaler {
public object MarshalNativeToManaged(IntPtr pNativeData) {
- var ret = eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
- eina.MemoryNative.Free(pNativeData);
+ var ret = Eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
+ Eina.MemoryNative.Free(pNativeData);
return ret;
}
public IntPtr MarshalManagedToNative(object managedObj) {
- return eina.MemoryNative.StrDup((string)managedObj);
+ return Eina.MemoryNative.StrDup((string)managedObj);
}
public void CleanUpNativeData(IntPtr pNativeData) {
public class StringKeepOwnershipMarshaler: ICustomMarshaler {
public object MarshalNativeToManaged(IntPtr pNativeData) {
- return eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
+ return Eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
}
public IntPtr MarshalManagedToNative(object managedObj) {
- return eina.StringConversion.ManagedStringToNativeUtf8Alloc((string)managedObj);
+ return Eina.StringConversion.ManagedStringToNativeUtf8Alloc((string)managedObj);
}
public void CleanUpNativeData(IntPtr pNativeData) {
public class StringsharePassOwnershipMarshaler : ICustomMarshaler {
public object MarshalNativeToManaged(IntPtr pNativeData) {
- var ret = eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
- eina.Stringshare.eina_stringshare_del(pNativeData);
+ var ret = Eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
+ Eina.Stringshare.eina_stringshare_del(pNativeData);
return ret;
}
public IntPtr MarshalManagedToNative(object managedObj) {
- return eina.Stringshare.eina_stringshare_add((string)managedObj);
+ return Eina.Stringshare.eina_stringshare_add((string)managedObj);
}
public void CleanUpNativeData(IntPtr pNativeData) {
public class StringshareKeepOwnershipMarshaler : ICustomMarshaler {
public object MarshalNativeToManaged(IntPtr pNativeData) {
- return eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
+ return Eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
}
public IntPtr MarshalManagedToNative(object managedObj) {
- return eina.Stringshare.eina_stringshare_add((string)managedObj);
+ return Eina.Stringshare.eina_stringshare_add((string)managedObj);
}
public void CleanUpNativeData(IntPtr pNativeData) {
public class StrbufPassOwnershipMarshaler : ICustomMarshaler {
public object MarshalNativeToManaged(IntPtr pNativeData) {
- return new eina.Strbuf(pNativeData, eina.Ownership.Managed);
+ return new Eina.Strbuf(pNativeData, Eina.Ownership.Managed);
}
public IntPtr MarshalManagedToNative(object managedObj) {
- eina.Strbuf buf = managedObj as eina.Strbuf;
+ Eina.Strbuf buf = managedObj as Eina.Strbuf;
buf.ReleaseOwnership();
return buf.Handle;
}
public class StrbufKeepOwnershipMarshaler: ICustomMarshaler {
public object MarshalNativeToManaged(IntPtr pNativeData) {
- return new eina.Strbuf(pNativeData, eina.Ownership.Unmanaged);
+ return new Eina.Strbuf(pNativeData, Eina.Ownership.Unmanaged);
}
public IntPtr MarshalManagedToNative(object managedObj) {
- eina.Strbuf buf = managedObj as eina.Strbuf;
+ Eina.Strbuf buf = managedObj as Eina.Strbuf;
return buf.Handle;
}
}
}
-/// <summary>Exception to be raised when a Task fails due to a failed eina.Future.</summary>
+/// <summary>Exception to be raised when a Task fails due to a failed Eina.Future.</summary>
public class FutureException : EflException
{
- /// <summary>The error code returned by the failed eina.Future.</summary>
- public eina.Error Error { get; private set; }
+ /// <summary>The error code returned by the failed Eina.Future.</summary>
+ public Eina.Error Error { get; private set; }
- /// <summary>Construct a new exception from the eina.Error stored in the given eina.Value.</summary>
- public FutureException(eina.Value value) : base("Future failed.")
+ /// <summary>Construct a new exception from the Eina.Error stored in the given Eina.Value.</summary>
+ public FutureException(Eina.Value value) : base("Future failed.")
{
- if (value.GetValueType() != eina.ValueType.Error)
- throw new ArgumentException("FutureException must receive an eina.Value with eina.Error.");
- eina.Error err;
+ if (value.GetValueType() != Eina.ValueType.Error)
+ throw new ArgumentException("FutureException must receive an Eina.Value with Eina.Error.");
+ Eina.Error err;
value.Get(out err);
Error = err;
}
}
#pragma warning disable 0169
-public struct Evas_Object_Box_Layout
+public struct EvasObjectBoxLayout
{
IntPtr o;
IntPtr priv;
IntPtr user_data;
};
[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi)]
-public struct Evas_Object_Box_Data
+public struct EvasObjectBoxData
{
}
-public delegate void Eina_Free_Cb(IntPtr data);
-public struct Evas_Object_Box_Option {
+public struct EvasObjectBoxOption {
IntPtr obj;
[MarshalAsAttribute(UnmanagedType.U1)] bool max_reached;
[MarshalAsAttribute(UnmanagedType.U1)] bool min_reached;
- evas.Coord alloc_size;
+ Evas.Coord alloc_size;
};
#pragma warning restore 0169
-namespace efl {
+namespace Efl {
[StructLayout(LayoutKind.Sequential)]
-public struct Event_Description {
+public struct EventDescription {
public IntPtr Name;
[MarshalAs(UnmanagedType.U1)] public bool Unfreezable;
[MarshalAs(UnmanagedType.U1)] public bool Legacy_is;
private static Dictionary<string, IntPtr> descriptions = new Dictionary<string, IntPtr>();
- public Event_Description(string name)
+ public EventDescription(string name)
{
this.Name = GetNative(name);
this.Unfreezable = false;
{
if (!descriptions.ContainsKey(name))
{
- IntPtr data = efl.eo.Globals.dlsym(efl.eo.Globals.RTLD_DEFAULT, name);
+ IntPtr data = Efl.Eo.Globals.dlsym(Efl.Eo.Globals.RTLD_DEFAULT, name);
if (data == IntPtr.Zero) {
- string error = eina.StringConversion.NativeUtf8ToManagedString(efl.eo.Globals.dlerror());
+ string error = Eina.StringConversion.NativeUtf8ToManagedString(Efl.Eo.Globals.dlerror());
throw new Exception(error);
}
descriptions.Add(name, data);
}
};
-
-public delegate void Event_Cb(System.IntPtr data, ref Event_StructInternal evt);
-#pragma warning disable 0169
-public struct Dbg_Info {
- IntPtr name;
- IntPtr value;
-};
-#pragma warning restore 0169
+public delegate void EventCb(System.IntPtr data, ref Event_StructInternal evt);
[StructLayout(LayoutKind.Sequential)]
-public struct Text_Cursor_Cursor {
+public struct TextCursorCursor {
IntPtr obj;
UIntPtr pos; // UIntPtr to automatically change size_t between 32/64
IntPtr node;
}
[StructLayout(LayoutKind.Sequential)]
-public struct Text_Annotate_Annotation {
+public struct TextAnnotateAnnotation {
IntPtr list;
IntPtr obj;
IntPtr start_node;
[MarshalAsAttribute(UnmanagedType.U1)]bool is_item;
}
-public delegate void Signal_Cb(IntPtr data, IntPtr obj, IntPtr emission, IntPtr source);
+public delegate void SignalCb(IntPtr data, IntPtr obj, IntPtr emission, IntPtr source);
-namespace access {
+namespace Access {
-public struct Action_Data {
+public struct ActionData {
public IntPtr name;
public IntPtr action;
public IntPtr param;
public IntPtr func;
}
-} // namespace access
-
-} // namespace efl
-
-namespace evas { namespace font {
-
-}
-
-
-// C# does not allow typedefs, so we use these implicit conversions.
-public struct Modifier_Mask {
- private ulong mask;
+public struct StateSet {
+ private ulong val;
- public static implicit operator Modifier_Mask(ulong x)
+ public static implicit operator StateSet(ulong x)
{
- return new Modifier_Mask{mask=x};
+ return new StateSet{val=x};
}
- public static implicit operator ulong(Modifier_Mask x)
+ public static implicit operator ulong(StateSet x)
{
- return x.mask;
+ return x.val;
}
}
+} // namespace Access
+
+} // namespace Efl
+
+namespace Evas {
+
public struct Coord {
int val;
}
}
-
-}
-
-public struct Efl_Font_Size {
- int val;
-
- public Efl_Font_Size(int value) { val = value; }
- static public implicit operator Efl_Font_Size(int val) {
- return new Efl_Font_Size(val);
- }
- static public implicit operator int(Efl_Font_Size coord) {
- return coord.val;
- }
-}
-
-namespace eina {
-
-[StructLayout(LayoutKind.Sequential)]
-public struct Rectangle {
- public int x;
- public int y;
- public int w;
- public int h;
-}
-
-}
-
-namespace evas {
-
/* Copied from Evas_Legacy.h */
-public enum Text_Style_Type
+public enum TextStyleType
{
///<summary> plain, standard text.</summary>
Plain = 0,
ShadowDirectionRight = 112 /* 7 >> 4 */
};
-// Copied from Evas_Common.h
-//
-//
-//
-
-public enum Callback_Type
-{
- ///<summary> Mouse In Event.</summary>
- EVAS_CALLBACK_MOUSE_IN = 0,
- ///<summary> Mouse Out Event.</summary>
- EVAS_CALLBACK_MOUSE_OUT,
- ///<summary> Mouse Button Down Event.</summary>
- EVAS_CALLBACK_MOUSE_DOWN,
- ///<summary> Mouse Button Up Event.</summary>
- EVAS_CALLBACK_MOUSE_UP,
- ///<summary> Mouse Move Event.</summary>
- EVAS_CALLBACK_MOUSE_MOVE,
- ///<summary> Mouse Wheel Event.</summary>
- EVAS_CALLBACK_MOUSE_WHEEL,
- ///<summary> Multi-touch Down Event.</summary>
- EVAS_CALLBACK_MULTI_DOWN,
- ///<summary> Multi-touch Up Event.</summary>
- EVAS_CALLBACK_MULTI_UP,
- ///<summary> Multi-touch Move Event.</summary>
- EVAS_CALLBACK_MULTI_MOVE,
- ///<summary> Object Being Freed (Called after Del).</summary>
- EVAS_CALLBACK_FREE,
- ///<summary> Key Press Event.</summary>
- EVAS_CALLBACK_KEY_DOWN,
- ///<summary> Key Release Event.</summary>
- EVAS_CALLBACK_KEY_UP,
- ///<summary> Focus In Event.</summary>
- EVAS_CALLBACK_FOCUS_IN,
- ///<summary> Focus Out Event.</summary>
- EVAS_CALLBACK_FOCUS_OUT,
- ///<summary> Show Event.</summary>
- EVAS_CALLBACK_SHOW,
- ///<summary> Hide Event.</summary>
- EVAS_CALLBACK_HIDE,
- ///<summary> Move Event.</summary>
- EVAS_CALLBACK_MOVE,
- ///<summary> Resize Event.</summary>
- EVAS_CALLBACK_RESIZE,
- ///<summary> Restack Event.</summary>
- EVAS_CALLBACK_RESTACK,
- ///<summary> Object Being Deleted (called before Free).</summary>
- EVAS_CALLBACK_DEL,
- ///<summary> Events go on/off hold.</summary>
- EVAS_CALLBACK_HOLD,
- ///<summary> Size hints changed event.</summary>
- EVAS_CALLBACK_CHANGED_SIZE_HINTS,
- ///<summary> Image has been preloaded.</summary>
- EVAS_CALLBACK_IMAGE_PRELOADED,
- ///<summary> Canvas got focus as a whole.</summary>
- EVAS_CALLBACK_CANVAS_FOCUS_IN,
- ///<summary> Canvas lost focus as a whole.</summary>
- EVAS_CALLBACK_CANVAS_FOCUS_OUT,
- ///<summary>Called after render update regions have been calculated,
- /// but only if update regions exist.</summary>
- EVAS_CALLBACK_RENDER_FLUSH_PRE,
- ///<summary>Called after render update regions have
- /// been sent to the display server, but only
- /// if update regions existed for the most recent frame.</summary>
- EVAS_CALLBACK_RENDER_FLUSH_POST,
- ///<summary> Canvas object got focus.</summary>
- EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_IN,
- ///<summary> Canvas object lost focus.</summary>
- EVAS_CALLBACK_CANVAS_OBJECT_FOCUS_OUT,
- ///<summary> Image data has been unloaded (by some mechanism in Evas that throw out original image data).</summary>
- EVAS_CALLBACK_IMAGE_UNLOADED,
- ///<summary> Called just before rendering starts on the canvas target. @since 1.2.</summary>
- EVAS_CALLBACK_RENDER_PRE,
- ///<summary> Called just after rendering stops on the canvas target. @since 1.2.</summary>
- EVAS_CALLBACK_RENDER_POST,
- ///<summary> Image size is changed. @since 1.8.</summary>
- EVAS_CALLBACK_IMAGE_RESIZE,
- ///<summary> Devices added, removed or changed on canvas. @since 1.8.</summary>
- EVAS_CALLBACK_DEVICE_CHANGED,
- ///<summary> Input device changed value on some axis. @since 1.13.</summary>
- EVAS_CALLBACK_AXIS_UPDATE,
- ///<summary> Canvas viewport resized. @since 1.15.</summary>
- EVAS_CALLBACK_CANVAS_VIEWPORT_RESIZE,
- ///<summary>Sentinel value to indicate last enum field during iteration.</summary>
- EVAS_CALLBACK_LAST
-};
-
-}
-
-namespace elm {
-
-namespace atspi {
-public struct State_Set {
- private ulong val;
-
- public static implicit operator State_Set(ulong x)
- {
- return new State_Set{val=x};
- }
- public static implicit operator ulong(State_Set x)
- {
- return x.val;
- }
-}
-
-[StructLayout(LayoutKind.Sequential)]
-public struct Relation_Set
-{
- public IntPtr pointer; // list<ptr(elm.atspi.Relation)>
-}
-} // namespace atspi
-
-namespace gengrid { namespace item {
-[StructLayout(LayoutKind.Sequential)]
-public struct Class
-{
- int version;
- uint refcount;
- [MarshalAsAttribute(UnmanagedType.U1)]bool delete_me;
- IntPtr item_style;
- IntPtr decorate_item_style;
- IntPtr decorate_all_item_style;
-
- // Delegates inside Elm_Gen_Item_Class_Functions
- IntPtr text_get;
- IntPtr content_get;
- IntPtr state_get;
- IntPtr del;
- IntPtr filter_get;
- IntPtr reusable_content_get;
-}
-} // namespace item
-} // namespace gengrid
-
-namespace genlist { namespace item {
-[StructLayout(LayoutKind.Sequential)]
-public struct Class
-{
- int version;
- uint refcount;
- [MarshalAsAttribute(UnmanagedType.U1)]bool delete_me;
- IntPtr item_style;
- IntPtr decorate_item_style;
- IntPtr decorate_all_item_style;
-
- // Delegates inside Elm_Gen_Item_Class_Functions
- IntPtr text_get;
- IntPtr content_get;
- IntPtr state_get;
- IntPtr del;
- IntPtr filter_get;
- IntPtr reusable_content_get;
-}
-} // namespace item
-} // namespace genlist
-
-} // namespace elm
+} // namespace Evas
// Global delegates
-public delegate IntPtr list_data_get_func_type(IntPtr l);
-public delegate void region_hook_func_type(IntPtr data, IntPtr obj);
-public delegate void slider_freefunc_type(IntPtr data);
-public delegate void slider_func_type(double val);
-
public delegate int Eina_Compare_Cb(IntPtr a, IntPtr b);
-public delegate void Elm_Interface_Scrollable_Cb(IntPtr obj, IntPtr data);
-public delegate void Elm_Interface_Scrollable_Min_Limit_Cb(IntPtr obj,
+public delegate void ElmInterfaceScrollableCb(IntPtr obj, IntPtr data);
+public delegate void ElmInterfaceScrollableMinLimitCb(IntPtr obj,
[MarshalAsAttribute(UnmanagedType.U1)]bool w,
[MarshalAsAttribute(UnmanagedType.U1)]bool h);
-public delegate void Elm_Interface_Scrollable_Resize_Cb(IntPtr obj, evas.Coord w, evas.Coord h);
-public delegate void Elm_Entry_Item_Provider_Cb(IntPtr data, IntPtr obj, IntPtr item);
-public delegate void Elm_Entry_Filter_Cb(IntPtr data, IntPtr obj, IntPtr text);
-[return: MarshalAsAttribute(UnmanagedType.U1)]
-public delegate bool Elm_Multibuttonentry_Item_Filter_Cb(IntPtr obj, IntPtr item_label, IntPtr item_data, IntPtr data);
-public delegate IntPtr Elm_Multibuttonentry_Format_Cb(int count, IntPtr data);
+public delegate void ElmInterfaceScrollableResizeCb(IntPtr obj, Evas.Coord w, Evas.Coord h);
[return: MarshalAsAttribute(UnmanagedType.U1)]
-public delegate bool Elm_Fileselector_Filter_Func(IntPtr path, [MarshalAsAttribute(UnmanagedType.U1)]bool dir, IntPtr data);
-public delegate void Evas_Smart_Cb(IntPtr data, IntPtr obj, IntPtr event_info);
-public delegate void Elm_Gesture_Event_Cb(IntPtr data, IntPtr event_info);
-public delegate void Elm_Object_Item_Signal_Cb(IntPtr data, IntPtr item, IntPtr emission, IntPtr source);
-public delegate void Elm_Tooltip_Item_Content_Cb(IntPtr data, IntPtr obj, IntPtr tooltip, IntPtr item);
-public delegate void Elm_Sys_Notify_Send_Cb(IntPtr data, uint id);
-public delegate IntPtr Elm_Calendar_Format_Cb(IntPtr format);
-
-namespace edje {
-
-public delegate void Signal_Cb(IntPtr data, IntPtr obj, IntPtr emission, IntPtr source);
-public delegate void Markup_Filter_Cb(IntPtr data, IntPtr obj, IntPtr part, IntPtr text );
-public delegate void Item_Provider_Cb(IntPtr data, IntPtr obj, IntPtr part, IntPtr item);
-// Message_Handler_Cb is now legacy
-
-namespace text {
-public delegate void Filter_Cb(IntPtr data, IntPtr obj, IntPtr part, int _type, IntPtr text);
-public delegate void Change_Cb(IntPtr data, IntPtr obj, IntPtr part);
-}
-
-
-} // namespace edje
-
-public enum Elm_Code_Status_Type {
- ELM_CODE_STATUS_TYPE_DEFAULT = 0,
- ELM_CODE_STATUS_TYPE_CURRENT,
- ELM_CODE_STATUS_TYPE_IGNORED,
- ELM_CODE_STATUS_TYPE_NOTE,
- ELM_CODE_STATUS_TYPE_WARNING,
- ELM_CODE_STATUS_TYPE_ERROR,
- ELM_CODE_STATUS_TYPE_FATAL,
-
- ELM_CODE_STATUS_TYPE_ADDED,
- ELM_CODE_STATUS_TYPE_REMOVED,
- ELM_CODE_STATUS_TYPE_CHANGED,
-
- ELM_CODE_STATUS_TYPE_PASSED,
- ELM_CODE_STATUS_TYPE_FAILED,
-
- ELM_CODE_STATUS_TYPE_TODO,
-
- ELM_CODE_STATUS_TYPE_COUNT
-};
-
-
-[StructLayout(LayoutKind.Sequential)]
-public struct Elm_Atspi_Action
-{
- IntPtr name;
- IntPtr action;
- IntPtr param;
- IntPtr func;
-}
-
-[StructLayout(LayoutKind.Sequential)]
-public struct Tm {
- int tm_sec;
- int tm_min;
- int tm_hour;
- int tm_mday;
- int tm_mon;
- int tm_year;
- int tm_wday;
- int tm_yday;
- int tm_isdst;
-}
-
-public delegate IntPtr Efl_Ui_Calendar_Format_Cb(Tm stime); // struct tm as argument
+public delegate bool ElmMultibuttonentryItemFilterCb(IntPtr obj, IntPtr item_label, IntPtr item_data, IntPtr data);
+public delegate IntPtr ElmMultibuttonentryFormatCb(int count, IntPtr data);
+public delegate void EinaFreeCb(IntPtr data);
+public delegate void EvasSmartCb(IntPtr data, IntPtr obj, IntPtr event_info);
+public delegate void ElmObjectItemSignalCb(IntPtr data, IntPtr item, IntPtr emission, IntPtr source);
+public delegate void ElmTooltipItemContentCb(IntPtr data, IntPtr obj, IntPtr tooltip, IntPtr item);
ecore_ecore_ipc_client_example_SOURCES = ecore/ecore_ipc_client_example.c
ecore_ecore_ipc_client_example_CPPFLAGS = $(ECORE_COMMON_CPPFLAGS) $(AM_CPPFLAGS)
+if HAVE_CSHARP
+
+if HAVE_WIN32
+MCSFLAGS ?=
+MCSFLAGS += -define:WIN32
+endif
+
+EXTRA_PROGRAMS += \
+ecore/efl_mono_loop_timer_example
+
+ecore_efl_mono_loop_timer_example_SOURCES = \
+ ecore/efl_mono_loop_timer_example.cs
+
+ecore/efl_mono_loop_timer_example$(EXEEXT): $(ecore_efl_mono_loop_timer_example_SOURCES) $(am_dirstamp) $(top_builddir)/src/lib/efl_mono/libefl_mono.dll
+ @rm -f ecore/efl_mono_loop_timer_example$(EXEEXT)
+ $(AM_V_MCS) $(MCS) $(MCSFLAGS) -r:$(abs_top_builddir)/src/lib/efl_mono/libefl_mono.dll -out:$@ $(filter %.cs, $(^))
+
+endif
+
ECORE_SRCS = \
ecore/ecore_animator_example.c \
+++ /dev/null
-using System;
-using System.Runtime.InteropServices;
-using System.Runtime.CompilerServices;
-
-class TestMain
-{
- /* private efl.Loop loop; */
-
- public TestMain(efl.Loop loop)
- {
- /* this.loop = loop; */
- }
-
- static void Main(string[] args)
- {
- efl.All.Init();
-
- efl.Loop loop = new efl.LoopConcrete();
-
- TestMain listener = new TestMain(loop);
-
- loop.CALLBACK_ADD += listener.callback_added_cb;
-
- loop.CALLBACK_ADD += listener.on_idle_enter;
- loop.CALLBACK_ADD -= listener.on_idle_enter;
-
- loop.IDLE += listener.on_idle_enter; // Will trigger CALLBACK_ADD
-
- efl.All.Shutdown();
- }
-
- public void on_idle_enter(object sender, EventArgs e)
- {
- Console.WriteLine("I should not be called while the loop is not running...");
- }
-
- public void callback_added_cb(object sender, EventArgs e)
- {
- Console.WriteLine("Looks like we added a new callback.");
- }
-}
-
-
class TestMain
{
- private efl.Loop loop;
+ private Efl.Loop loop;
private int count;
- public TestMain(efl.Loop loop)
+ public TestMain(Efl.Loop loop)
{
this.loop = loop;
this.count = 0;
static void Main(string[] args)
{
- efl.All.Init();
+ Efl.All.Init();
- efl.Loop loop = new efl.LoopConcrete();
- efl.loop.Timer timer = new efl.loop.TimerConcrete(loop);
+ var loop = new Efl.Loop();
+ var timer = new Efl.LoopTimer(loop, (Efl.LoopTimer t) => {
+ t.SetInterval(1.0);
+ });
TestMain listener = new TestMain(loop);
Console.WriteLine("Starting MainLoop");
- timer.interval_set(1.0);
+ timer.TickEvt += listener.on_tick;
+ timer.TickEvt += listener.another_callback;
+ timer.TickEvt -= listener.another_callback;
- timer.TICK += listener.on_tick;
- timer.TICK += listener.another_callback;
- timer.TICK -= listener.another_callback;
+ loop.Begin();
- loop.begin();
-
- efl.All.Shutdown();
+ Efl.All.Shutdown();
}
public void on_tick(object sender, EventArgs e)
{
Console.WriteLine("on_tick called on listener");
- if (count++ == 5)
- loop.quit(0);
+ if (count++ == 5) {
+ Eina.Value v = new Eina.Value(Eina.ValueType.Int32);
+ v.Set(0);
+ loop.Quit(v);
+ }
}
public void another_callback(object sender, EventArgs e)
using static System.Console;
-class PlusTenNumberWrapper : example.NumberwrapperInherit
+class PlusTenNumberWrapper : Example.Numberwrapper
{
- public PlusTenNumberWrapper(efl.IObject parent = null)
+ public PlusTenNumberWrapper(Efl.Object parent = null)
: base(parent)
{}
{
public static void Main()
{
- eina.Config.Init();
- efl.eo.Config.Init();
+ Eina.Config.Init();
+ Efl.Eo.Config.Init();
var inheritObj = new PlusTenNumberWrapper();
WriteLine("## Using original object ##\n");
// Check original EFL object
- var origObj = new example.Numberwrapper();
+ var origObj = new Example.Numberwrapper();
given = 111;
origObj.SetNumber(given);
stored = origObj.GetNumber();
public static void Main()
{
- eina.Config.Init();
- efl.eo.Config.Init();
+ Eina.Config.Init();
+ Efl.Eo.Config.Init();
- var obj = new example.Numberwrapper();
+ var obj = new Example.Numberwrapper();
// Set internal value
obj.SetNumber(12);
{
public static void Main()
{
- eina.Config.Init();
+ Eina.Config.Init();
var strings = new string[]{
"helo", "hera", "starbuck", "kat", "boomer",
"skulls", "bulldog", "flat top", "hammerhead", "gonzo"
};
- var array = new eina.Array<string>(20U);
+ var array = new Eina.Array<string>(20U);
// Push new elements
foreach (string s in strings)
{
public static void Main()
{
- eina.Config.Init();
+ Eina.Config.Init();
var bytes = new byte[]{0, 1, 2, 3, 4, 5, 6};
- var bb = new eina.Binbuf();
+ var bb = new Eina.Binbuf();
// Append initial bytes
bb.Append(bytes);
public class ExampleEinaError01
{
private static bool RegisteredErrors = false;
- private static eina.Error MyErrorNegative;
- private static eina.Error MyErrorNull;
+ private static Eina.Error MyErrorNegative;
+ private static Eina.Error MyErrorNull;
private static void testFunc(int n, string s)
{
if (!RegisteredErrors)
{
- MyErrorNegative = eina.Error.Register("Negative number");
- MyErrorNull = eina.Error.Register("NULL pointer");
+ MyErrorNegative = Eina.Error.Register("Negative number");
+ MyErrorNull = Eina.Error.Register("NULL pointer");
RegisteredErrors = true;
}
if (n < 0)
{
- eina.Error.Set(MyErrorNegative);
+ Eina.Error.Set(MyErrorNegative);
return;
}
if (s == null)
{
- eina.Error.Set(MyErrorNull);
+ Eina.Error.Set(MyErrorNull);
return;
}
}
public static void Main()
{
- eina.Config.Init();
- efl.eo.Config.Init();
+ Eina.Config.Init();
+ Efl.Eo.Config.Init();
// Handling Eina_Error with exception
try
{
testFunc(-1, "abc");
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
}
- catch(efl.EflException e)
+ catch(Efl.EflException e)
{
WriteLine($"Caught error: {e.Message}");
}
// Handling Eina_Error directly
testFunc(42, null);
- eina.Error err = eina.Error.Get();
+ Eina.Error err = Eina.Error.Get();
if (err != 0)
{
WriteLine($"Error set: {err.Message}");
}
- eina.Error.Clear();
+ Eina.Error.Clear();
// No error set
try
{
testFunc(42, "abc");
- eina.Error.RaiseIfOccurred();
+ Eina.Error.RaiseIfOccurred();
- err = eina.Error.Get();
- WriteLine($"Really no error? {err == eina.Error.NO_ERROR}.");
+ err = Eina.Error.Get();
+ WriteLine($"Really no error? {err == Eina.Error.NO_ERROR}.");
}
catch
{
WriteLine("Unspected error!!!");
}
- WriteLine("No error message is empty string: \"{0}\"", eina.Error.NO_ERROR.Message);
- WriteLine("No error message is empty string: \"{0}\"", eina.Error.MsgGet(0));
+ WriteLine("No error message is empty string: \"{0}\"", Eina.Error.NO_ERROR.Message);
+ WriteLine("No error message is empty string: \"{0}\"", Eina.Error.MsgGet(0));
}
}
{
public static void Main()
{
- eina.Config.Init();
+ Eina.Config.Init();
- var phone_book = new eina.Hash<string, string>();
+ var phone_book = new Eina.Hash<string, string>();
// Add initial entries to our hash
phone_book.Add("Wolfgang Amadeus Mozart", "+01 23 456-78910");
public class Example
{
- public static efl.ui.IButton CreateButton(efl.IObject parent,
+ public static Efl.Ui.Button CreateButton(Efl.Object parent,
string text,
int w, int h,
EventHandler callback) {
- efl.ui.IButton button = new efl.ui.Button(parent);
+ Efl.Ui.Button button = new Efl.Ui.Button(parent);
button.SetText(text);
- button.SetSize(new eina.Size2D(w, h));
+ button.SetSize(new Eina.Size2D(w, h));
- button.ClickedEvt += callback;
+ ((Efl.Ui.Clickable)button).ClickedEvt += callback;
return button;
}
- public static void Formatter(eina.Strbuf buf, eina.Value val){
+ public static void Formatter(Eina.Strbuf buf, Eina.Value val){
double ratio;
if (val.Get(out ratio)) {
buf.Append($"{(int)(ratio*100)}%");
int W = 120;
int H = 30;
- efl.All.Init(efl.Components.Ui);
+ Efl.All.Init(Efl.Components.Ui);
- efl.ui.Win win = new efl.ui.Win(null);
+ Efl.Ui.Win win = new Efl.Ui.Win(null);
win.SetText("Hello, C#!!");
win.SetAutohide(true);
- efl.ui.Box_Flow box = new efl.ui.Box_Flow(win);
+ Efl.Ui.BoxFlow box = new Efl.Ui.BoxFlow(win);
- efl.ui.IButton button = CreateButton(box, "Click to exit", 120, 30,
+ Efl.Ui.Button button = CreateButton(box, "Click to exit", 120, 30,
(object sender, EventArgs e) => {
- efl.ui.Config.Exit();
+ Efl.Ui.Config.Exit();
});
box.DoPack(button);
- efl.ui.Progressbar bar = new efl.ui.Progressbar(box);
- bar.SetSize(new eina.Size2D(W, H));
+ Efl.Ui.Progressbar bar = new Efl.Ui.Progressbar(box);
+ bar.SetSize(new Eina.Size2D(W, H));
bar.SetFormatCb(Formatter);
- efl.ui.ISlider slider = new efl.ui.Slider(box);
- slider.SetSize(new eina.Size2D(W, H));
+ Efl.Ui.Slider slider = new Efl.Ui.Slider(box);
+ slider.SetSize(new Eina.Size2D(W, H));
slider.ChangedEvt += (object sender, EventArgs e) => {
bar.SetRangeValue(slider.GetRangeValue());
button.SetVisible(true);
box.SetVisible(true);
- win.SetSize(new eina.Size2D(W, 3 * H));
+ win.SetSize(new Eina.Size2D(W, 3 * H));
win.SetVisible(true);
- efl.ui.Config.Run();
+ Efl.Ui.Config.Run();
- efl.All.Shutdown();
+ Efl.All.Shutdown();
}
}
return miles * KMS_PER_MILE;
}
- private static void ShowErrorPopup(efl.ui.Win win, string message)
+ private static void ShowErrorPopup(Efl.Ui.Win win, string message)
{
- efl.ui.IAlert_Popup popup = new efl.ui.Alert_Popup(win);
- efl.ui.Text popup_text = new efl.ui.Text(popup);
+ Efl.Ui.AlertPopup popup = new Efl.Ui.AlertPopup(win);
+ Efl.Ui.Text popup_text = new Efl.Ui.Text(popup);
popup_text.SetText($"Error: {message}");
popup.SetContent(popup_text);
popup.SetVisible(true);
- popup.SetButton(efl.ui.Alert_Popup_Button.Positive, "Ok", null);
- popup.SetSize(new eina.Size2D(150, 30));
- popup.ButtonClickedEvt += (object sender, efl.ui.Alert_Popup.ButtonClickedEvt_Args e) => {
+ popup.SetButton(Efl.Ui.AlertPopupButton.Positive, "Ok", null);
+ popup.SetSize(new Eina.Size2D(150, 30));
+ popup.ButtonClickedEvt += (object sender, Efl.Ui.AlertPopupButtonClickedEvt_Args e) => {
popup.SetParent(null);
popup.Invalidate();
};
public static void Main() {
int W = 120;
int H = 30;
- eina.Size2D size = new eina.Size2D(W, H);
+ Eina.Size2D size = new Eina.Size2D(W, H);
- efl.All.Init(efl.Components.Ui);
+ Efl.All.Init(Efl.Components.Ui);
- efl.ui.Win win = new efl.ui.Win(null);
+ Efl.Ui.Win win = new Efl.Ui.Win(null);
win.SetText("C# Unit Converter");
win.SetAutohide(true);
- efl.ui.Box_Flow box = new efl.ui.Box_Flow(win);
- box.SetDirection(efl.ui.Dir.Horizontal);
+ Efl.Ui.BoxFlow box = new Efl.Ui.BoxFlow(win);
+ box.SetDirection(Efl.Ui.Dir.Horizontal);
- efl.ui.Box_Flow miles_box = new efl.ui.Box_Flow(box);
- miles_box.SetDirection(efl.ui.Dir.Down);
+ Efl.Ui.BoxFlow miles_box = new Efl.Ui.BoxFlow(box);
+ miles_box.SetDirection(Efl.Ui.Dir.Down);
box.DoPack(miles_box);
- efl.ui.Text miles_label = new efl.ui.Text(miles_box);
+ Efl.Ui.Text miles_label = new Efl.Ui.Text(miles_box);
miles_label.SetText("Miles:");
miles_label.SetSize(size);
miles_label.SetVisible(true);
- efl.ui.Text_Editable miles_input = new efl.ui.Text_Editable(miles_box);
+ Efl.Ui.TextEditable miles_input = new Efl.Ui.TextEditable(miles_box);
miles_input.SetText("");
miles_input.SetScrollable(true);
miles_input.SetSize(size);
miles_input.SetVisible(true);
- efl.ui.IButton miles_button = new efl.ui.Button(miles_box);
+ Efl.Ui.Button miles_button = new Efl.Ui.Button(miles_box);
miles_button.SetText("To Km");
miles_button.SetSize(size);
miles_button.SetVisible(true);
miles_box.DoPack(miles_button);
- efl.ui.Box_Flow kms_box = new efl.ui.Box_Flow(box);
- kms_box.SetDirection(efl.ui.Dir.Down);
+ Efl.Ui.BoxFlow kms_box = new Efl.Ui.BoxFlow(box);
+ kms_box.SetDirection(Efl.Ui.Dir.Down);
box.DoPack(kms_box);
- efl.ui.Text kms_label = new efl.ui.Text(kms_box);
+ Efl.Ui.Text kms_label = new Efl.Ui.Text(kms_box);
kms_label.SetText("Kilometers:");
kms_label.SetSize(size);
kms_label.SetVisible(true);
- efl.ui.Text_Editable kms_input = new efl.ui.Text_Editable(kms_box);
+ Efl.Ui.TextEditable kms_input = new Efl.Ui.TextEditable(kms_box);
kms_input.SetText("");
kms_input.SetScrollable(true);
kms_input.SetSize(size);
kms_input.SetVisible(true);
- efl.ui.IButton kms_button = new efl.ui.Button(kms_box);
+ Efl.Ui.Button kms_button = new Efl.Ui.Button(kms_box);
kms_button.SetText("To Miles");
kms_button.SetSize(size);
kms_button.SetVisible(true);
kms_box.DoPack(kms_input);
kms_box.DoPack(kms_button);
- kms_button.ClickedEvt += (object sender, EventArgs e) => {
+ ((Efl.Ui.Clickable)kms_button).ClickedEvt += (object sender, EventArgs e) => {
try
{
string text = kms_input.GetText();
}
};
- miles_button.ClickedEvt += (object sender, EventArgs e) => {
+ ((Efl.Ui.Clickable)miles_button).ClickedEvt += (object sender, EventArgs e) => {
try
{
string text = miles_input.GetText();
kms_box.SetVisible(true);
miles_box.SetVisible(true);
- box.SetPosition(new eina.Position2D(20, 30));
+ box.SetPosition(new Eina.Position2D(20, 30));
box.SetVisible(true);
- win.SetPosition(new eina.Position2D(200, 200));
+ win.SetPosition(new Eina.Position2D(200, 200));
- win.SetSize(new eina.Size2D(400, 120));
+ win.SetSize(new Eina.Size2D(400, 120));
win.SetVisible(true);
- efl.ui.Config.Run();
+ Efl.Ui.Config.Run();
- efl.All.Shutdown();
+ Efl.All.Shutdown();
}
}
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
-public class MyBox : evas.BoxInherit
+public class MyBox : Evas.Box
{
- public MyBox(efl.IObject parent) : base(parent) {}
+ public MyBox(Efl.Object parent) : base(parent) {}
[DllImport("evas")] static extern void evas_obj_box_layout_vertical(IntPtr obj, IntPtr data, IntPtr privdata);
[DllImport("evas")] static extern void evas_obj_box_layout_horizontal(IntPtr obj, IntPtr data, IntPtr privdata);
override public void CalculateGroup()
{
- IntPtr evas = evas_object_evas_get(raw_handle);
+ IntPtr evas = evas_object_evas_get(NativeHandle);
evas_event_freeze(evas);
Console.WriteLine("called group_calculate");
/* layouting_set(true); */
- evas_obj_box_layout_vertical(raw_handle, IntPtr.Zero, IntPtr.Zero);
+ evas_obj_box_layout_vertical(NativeHandle, IntPtr.Zero, IntPtr.Zero);
/* layouting_set(false); */
/* children_changed_set(false); */
evas_event_thaw(evas);
{
static void Main(string[] args)
{
- efl.All.Init();
+ Efl.All.Init();
- efl.Loop loop = new efl.Loop();
+ Efl.Loop loop = new Efl.Loop();
EcoreEvas ecore_evas = new EcoreEvas();
- efl.canvas.IObject canvas = ecore_evas.canvas;
+ Efl.Canvas.Object canvas = ecore_evas.canvas;
canvas.SetVisible(true);
- efl.IObject parent = canvas.GetParent();
- System.Diagnostics.Debug.Assert(parent.raw_handle != IntPtr.Zero);
+ Efl.Object parent = canvas.GetParent();
+ System.Diagnostics.Debug.Assert(parent.NativeHandle != IntPtr.Zero);
- evas.IBox box = new MyBox(canvas);
- eina.Size2D size = new eina.Size2D();
+ Evas.Box box = new MyBox(canvas);
+ Eina.Size2D size = new Eina.Size2D();
size.W = 320;
size.H = 240;
box.SetSize(size);
box.SetVisible(true);
- efl.canvas.Rectangle rect = new efl.canvas.Rectangle(canvas);
+ Efl.Canvas.Rectangle rect = new Efl.Canvas.Rectangle(canvas);
rect.SetColor(0, 0, 255, 255);
size.W = 320;
size.H = 120;
rect.SetVisible(true);
box.Append(rect);
- efl.canvas.Rectangle rect2 = new efl.canvas.Rectangle(canvas);
+ Efl.Canvas.Rectangle rect2 = new Efl.Canvas.Rectangle(canvas);
rect2.SetColor(0, 255, 0, 255);
rect2.SetSize(size);
rect2.SetVisible(true);
loop.Begin();
- efl.All.Shutdown();
+ Efl.All.Shutdown();
}
}
static int WIDTH = 320;
static int HEIGHT = 240;
- evas.IImage image;
+ Evas.Image image;
static string ImagePath([CallerFilePath] string folder="")
return System.IO.Path.GetDirectoryName(folder);
}
- public TestMain(evas.IImage image)
+ public TestMain(Evas.Image image)
{
this.image = image;
}
static void Main(string[] args)
{
- efl.All.Init();
+ Efl.All.Init();
- efl.Loop loop = new efl.Loop();
+ Efl.Loop loop = new Efl.Loop();
EcoreEvas ecore_evas = new EcoreEvas();
- eina.Size2D size = new eina.Size2D();
+ Eina.Size2D size = new Eina.Size2D();
- efl.canvas.IObject canvas = ecore_evas.canvas;
+ Efl.Canvas.Object canvas = ecore_evas.canvas;
canvas.SetVisible(true);
- efl.IObject parent = canvas.GetParent();
- System.Diagnostics.Debug.Assert(parent.raw_handle != IntPtr.Zero);
+ Efl.Object parent = canvas.GetParent();
+ System.Diagnostics.Debug.Assert(parent.NativeHandle != IntPtr.Zero);
- efl.canvas.Rectangle bg = new efl.canvas.Rectangle(canvas);
+ Efl.Canvas.Rectangle bg = new Efl.Canvas.Rectangle(canvas);
bg.SetColor(255, 255, 255, 255);
size.W = WIDTH;
size.H = HEIGHT;
bg.SetVisible(true);
string valid_path = args[0];
- evas.Image image = new evas.Image(canvas);
+ Evas.Image image = new Evas.Image(canvas);
image.SetFile(valid_path, null);
/* FIXME evas-image uses error handling code from
* evas_object_image_load_error_get, which seems to be not available
- * efl.image.load.State state = image.load_error_get(); */
+ * Efl.image.load.State state = image.load_error_get(); */
// FIXME missing move
- eina.Rect rect = new eina.Rect();
+ Eina.Rect rect = new Eina.Rect();
rect.X = 0;
rect.Y = 0;
/* EventListener callback = new EventListener(); */
/* bg.key_focus_set(true); */
- /* bg.event_callback_priority_add(evas.Callback_Type.Key_down, */
- /* efl.Callback_Priority.Default, */
+ /* bg.event_callback_priority_add(Evas.Callback_Type.Key_down, */
+ /* Efl.Callback_Priority.Default, */
/* callback, null); */
loop.Begin();
- efl.All.Shutdown();
+ Efl.All.Shutdown();
}
public void on_key_down(object sender, EventArgs e)
static void Main(string[] args)
{
- efl.All.Init();
+ Efl.All.Init();
- efl.Loop loop = new efl.Loop();
+ Efl.Loop loop = new Efl.Loop();
EcoreEvas ecore_evas = new EcoreEvas();
- eina.Size2D size = new eina.Size2D();
- eina.Position2D pos = new eina.Position2D();
+ Eina.Size2D size = new Eina.Size2D();
+ Eina.Position2D pos = new Eina.Position2D();
- efl.canvas.IObject canvas = ecore_evas.canvas;
+ Efl.Canvas.Object canvas = ecore_evas.canvas;
canvas.SetVisible(true);
- efl.canvas.Rectangle bg = new efl.canvas.Rectangle(canvas);
+ Efl.Canvas.Rectangle bg = new Efl.Canvas.Rectangle(canvas);
bg.SetColor(255, 255, 255, 255);
pos.X = 0;
pos.Y = 0;
bg.SetVisible(true);
string path = args[0];
- evas.Image logo = new evas.Image(canvas);
+ Evas.Image logo = new Evas.Image(canvas);
logo.SetFillAuto(true);
// TODO add preloaded support (depends on events)
pixels[i] = generator.Next();
}
- evas.Image noise_img = new evas.Image(canvas);
+ Evas.Image noise_img = new Evas.Image(canvas);
size.W = WIDTH / 4;
size.H = HEIGHT / 4;
noise_img.SetSize(size);
noise_img.SetVisible(true);
Console.WriteLine("Creating noise image with sizez %d, %d", WIDTH/4, HEIGHT/4);
- efl.canvas.Proxy proxy_img = new efl.canvas.Proxy(canvas);
+ Efl.Canvas.Proxy proxy_img = new Efl.Canvas.Proxy(canvas);
proxy_img.SetSource(noise_img);
pos.X = WIDTH / 2;
pos.Y = HEIGHT / 2;
{
int color_index = 0;
- efl.All.Init();
+ Efl.All.Init();
- efl.Loop loop = new efl.Loop();
+ Efl.Loop loop = new Efl.Loop();
EcoreEvas ecore_evas = new EcoreEvas();
- efl.canvas.IObject canvas = ecore_evas.canvas;
+ Efl.Canvas.Object canvas = ecore_evas.canvas;
canvas.SetVisible(true);
- efl.IObject parent = canvas.GetParent();
- System.Diagnostics.Debug.Assert(parent.raw_handle != IntPtr.Zero);
+ Efl.Object parent = canvas.GetParent();
+ System.Diagnostics.Debug.Assert(parent.NativeHandle != IntPtr.Zero);
- efl.canvas.Rectangle rect = new efl.canvas.Rectangle(canvas);
+ Efl.Canvas.Rectangle rect = new Efl.Canvas.Rectangle(canvas);
rect.SetColor(colors[0, 0], colors[0, 1], colors[0, 2], 255);
- eina.Size2D size = new eina.Size2D();
+ Eina.Size2D size = new Eina.Size2D();
size.W = 640;
size.H = 480;
rect.SetSize(size);
rect.SetVisible(true);
- canvas.KeyDownEvt += (object sender, efl.input.Interface.KeyDownEvt_Args e) => {
+ canvas.KeyDownEvt += (object sender, Efl.Input.InterfaceKeyDownEvt_Args e) => {
color_index = (color_index + 1) % 3;
Console.WriteLine("Key Down");
- Console.WriteLine("Got key obj at {0}", e.arg.raw_handle.ToString("X"));
+ Console.WriteLine("Got key obj at {0}", e.arg.NativeHandle.ToString("X"));
Console.WriteLine("Got key_get() == [{0}]", e.arg.GetKey());
rect.SetColor(colors[color_index, 0],
colors[color_index, 1],
loop.Begin();
- efl.All.Shutdown();
+ Efl.All.Shutdown();
}
}
static void Main(string[] args)
{
- efl.All.Init();
+ Efl.All.Init();
- efl.Loop loop = new efl.Loop();
+ Efl.Loop loop = new Efl.Loop();
EcoreEvas ecore_evas = new EcoreEvas();
- eina.Size2D size = new eina.Size2D();
+ Eina.Size2D size = new Eina.Size2D();
size.W = WIDTH;
size.H = HEIGHT;
- eina.Size2D hint = new eina.Size2D();
+ Eina.Size2D hint = new Eina.Size2D();
- efl.canvas.IObject canvas = ecore_evas.canvas;
+ Efl.Canvas.Object canvas = ecore_evas.canvas;
canvas.SetVisible(true);
- efl.IObject parent = canvas.GetParent();
- System.Diagnostics.Debug.Assert(parent.raw_handle != IntPtr.Zero);
+ Efl.Object parent = canvas.GetParent();
+ System.Diagnostics.Debug.Assert(parent.NativeHandle != IntPtr.Zero);
- efl.canvas.Rectangle bg = new efl.canvas.Rectangle(canvas);
+ Efl.Canvas.Rectangle bg = new Efl.Canvas.Rectangle(canvas);
bg.SetColor(255, 255, 255, 255);
bg.SetSize(size);
bg.SetVisible(true);
- evas.Table table = new evas.Table(canvas);
- table.SetHomogeneous(evas.object_table.Homogeneous_Mode.None);
+ Evas.Table table = new Evas.Table(canvas);
+ table.SetHomogeneous(Evas.ObjectTable.HomogeneousMode.None);
table.SetPadding(0, 0);
table.SetSize(size);
table.SetVisible(true);
- efl.canvas.Rectangle rect = new efl.canvas.Rectangle(canvas);
+ Efl.Canvas.Rectangle rect = new Efl.Canvas.Rectangle(canvas);
rect.SetColor(255, 0, 0, 255);
hint.W = 100;
hint.H = 50;
rect.SetVisible(true);
table.Pack(rect, 1, 1, 2, 1);
- rect = new efl.canvas.Rectangle(canvas);
+ rect = new Efl.Canvas.Rectangle(canvas);
rect.SetColor(0, 255, 0, 255);
hint.W = 50;
hint.H = 100;
rect.SetVisible(true);
table.Pack(rect, 1, 2, 1, 2);
- rect = new efl.canvas.Rectangle(canvas);
+ rect = new Efl.Canvas.Rectangle(canvas);
rect.SetColor(0, 0, 255, 255);
hint.W = 50;
hint.H = 50;
rect.SetVisible(true);
table.Pack(rect, 2, 2, 1, 1);
- rect = new efl.canvas.Rectangle(canvas);
+ rect = new Efl.Canvas.Rectangle(canvas);
rect.SetColor(255, 255, 0, 255);
rect.SetHintMin(hint);
rect.SetVisible(true);
loop.Begin();
- efl.All.Shutdown();
+ Efl.All.Shutdown();
}
}
static int HEIGHT = 240;
private EcoreEvas ecore_evas;
- private efl.canvas.IObject canvas;
- private efl.canvas.IRectangle bg;
- private evas.Text text;
- private evas.Image border;
+ private Efl.Canvas.Object canvas;
+ private Efl.Canvas.Rectangle bg;
+ private Evas.Text text;
+ private Evas.Image border;
public TestMain(String border_file) {
ecore_evas = new EcoreEvas();
- eina.Size2D size = new eina.Size2D();
- eina.Position2D position = new eina.Position2D();
+ Eina.Size2D size = new Eina.Size2D();
+ Eina.Position2D position = new Eina.Position2D();
canvas = ecore_evas.canvas;
canvas.SetVisible(true);
- bg = new efl.canvas.Rectangle(canvas);
+ bg = new Efl.Canvas.Rectangle(canvas);
bg.SetColor(255, 255, 255, 255);
position.X = 0;
position.Y = 0;
bg.SetVisible(true);
bg.SetKeyFocus(true);
+ /* ((Efl.Input.Interface)bg).KeyDownEvt += On_KeyDown; */
bg.KeyDownEvt += On_KeyDown;
- text = new evas.Text(canvas);
- text.SetStyle(evas.Text_Style_Type.OutlineSoftShadow);
+ text = new Evas.Text(canvas);
+ text.SetStyle(Evas.TextStyleType.OutlineSoftShadow);
text.SetColor(0, 0, 0, 255);
text.SetGlowColor(255, 0, 0, 255);
text.SetPosition(position);
text.SetVisible(true);
- efl.font.Size font_size = 0;
+ Efl.Font.Size font_size = 0;
String font = String.Empty;
text.GetFont(out font, out font_size);
Console.WriteLine("Adding text object with font {0} and size {1}", font, size);
// setup border
- border = new evas.Image(canvas);
+ border = new Evas.Image(canvas);
border.SetFile(border_file, null);
border.SetBorder(3, 3, 3, 3);
border.SetBorderCenterFill(0);
}
- private void On_KeyDown(object sender, efl.input.Interface.KeyDownEvt_Args e)
+ private void On_KeyDown(object sender, Efl.Input.InterfaceKeyDownEvt_Args e)
{
var key = e.arg.GetKey();
if (key == "h") {
Console.WriteLine(commands);
} else if (key == "t") {
- evas.Text_Style_Type type = text.GetStyle();
- type = (evas.Text_Style_Type)(((int)type + 1) % 10); // 10 hardcoded from C example
+ Evas.TextStyleType type = text.GetStyle();
+ type = (Evas.TextStyleType)(((int)type + 1) % 10); // 10 hardcoded from C example
text.SetStyle(type);
}
}
static void Main(string[] args)
{
- efl.All.Init();
+ Efl.All.Init();
String border_path = "./src/examples/evas/resources/images/red.png";
if (args.Length >= 1)
border_path = args[0];
- efl.Loop loop = new efl.Loop();
+ Efl.Loop loop = new Efl.Loop();
TestMain t = new TestMain(border_path);
loop.Begin();
- efl.All.Shutdown();
+ Efl.All.Shutdown();
}
}
return ret;
}
+
+ std::vector<event_def> get_all_events() const
+ {
+ std::vector<event_def> ret;
+
+ std::copy(events.cbegin(), events.cend(), std::back_inserter(ret));
+
+ for (auto inherit : inherits)
+ {
+ klass_def klass(get_klass(inherit, unit), unit);
+ std::copy(klass.events.cbegin(), klass.events.cend(),
+ std::back_inserter(ret));
+ }
+
+ return ret;
+ }
};
struct value_def
{
int original = 1984;
int received;
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
t.IntOut(original, out received);
{
int original = 1984;
int received;
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
t.IntPtrOut(original, out received);
public static readonly string[] append_seq_str = {"42","43","33"};
public static readonly string[] modified_seq_str = {"0x0","0x2A","0x42","42","43","33"};
- public static test.INumberwrapper NW(int n)
+ public static Dummy.Numberwrapper NW(int n)
{
- var nw = new test.Numberwrapper();
+ var nw = new Dummy.Numberwrapper();
nw.SetNumber(n);
return nw;
}
- public static test.INumberwrapper[] BaseSeqObj()
+ public static Dummy.Numberwrapper[] BaseSeqObj()
{
- var a = new test.Numberwrapper();
- var b = new test.Numberwrapper();
- var c = new test.Numberwrapper();
+ var a = new Dummy.Numberwrapper();
+ var b = new Dummy.Numberwrapper();
+ var c = new Dummy.Numberwrapper();
a.SetNumber(0x0);
b.SetNumber(0x2A);
c.SetNumber(0x42);
- return new test.INumberwrapper[]{a,b,c};
+ return new Dummy.Numberwrapper[]{a,b,c};
}
- public static test.Numberwrapper[] AppendSeqObj()
+ public static Dummy.Numberwrapper[] AppendSeqObj()
{
- var a = new test.Numberwrapper();
- var b = new test.Numberwrapper();
- var c = new test.Numberwrapper();
+ var a = new Dummy.Numberwrapper();
+ var b = new Dummy.Numberwrapper();
+ var c = new Dummy.Numberwrapper();
a.SetNumber(42);
b.SetNumber(43);
c.SetNumber(33);
- return new test.Numberwrapper[]{a,b,c};
+ return new Dummy.Numberwrapper[]{a,b,c};
}
- public static test.Numberwrapper[] ModifiedSeqObj()
+ public static Dummy.Numberwrapper[] ModifiedSeqObj()
{
- var a = new test.Numberwrapper();
- var b = new test.Numberwrapper();
- var c = new test.Numberwrapper();
- var d = new test.Numberwrapper();
- var e = new test.Numberwrapper();
- var f = new test.Numberwrapper();
+ var a = new Dummy.Numberwrapper();
+ var b = new Dummy.Numberwrapper();
+ var c = new Dummy.Numberwrapper();
+ var d = new Dummy.Numberwrapper();
+ var e = new Dummy.Numberwrapper();
+ var f = new Dummy.Numberwrapper();
a.SetNumber(0x0);
b.SetNumber(0x2A);
c.SetNumber(0x42);
d.SetNumber(42);
e.SetNumber(43);
f.SetNumber(33);
- return new test.Numberwrapper[]{a,b,c,d,e,f};
+ return new Dummy.Numberwrapper[]{a,b,c,d,e,f};
}
public static void NumberwrapperSequenceAssertEqual(
- test.INumberwrapper[] a
- , test.INumberwrapper[] b
+ Dummy.Numberwrapper[] a
+ , Dummy.Numberwrapper[] b
, [CallerLineNumber] int line = 0
, [CallerFilePath] string file = null
, [CallerMemberName] string member = null)
}
}
-class NativeInheritImpl : test.TestingInherit
+class NativeInheritImpl : Dummy.TestObject
{
- public NativeInheritImpl(efl.Object parent = null) : base(parent) {}
+ public NativeInheritImpl(Efl.Object parent = null) : base(parent) {}
public bool slice_in_flag = false;
public bool rw_slice_in_flag = false;
public bool binbuf_return_flag = false;
public bool binbuf_return_own_flag = false;
- override public bool EinaSliceIn(eina.Slice slice)
+ override public bool EinaSliceIn(Eina.Slice slice)
{
slice_in_flag = true;
return slice.GetBytes().SequenceEqual(BaseSequence.Values());
}
- override public bool EinaRwSliceIn(eina.Rw_Slice slice)
+ override public bool EinaRwSliceIn(Eina.RwSlice slice)
{
rw_slice_in_flag = true;
return slice.GetBytes().SequenceEqual(BaseSequence.Values());
private byte[] slice_out_seq = null;
private GCHandle slice_out_pinned;
- override public bool EinaSliceOut(ref eina.Slice slice)
+ override public bool EinaSliceOut(ref Eina.Slice slice)
{
slice_out_flag = true;
private byte[] rw_slice_out_seq = null;
private GCHandle rw_slice_out_pinned;
- override public bool EinaRwSliceOut(ref eina.Rw_Slice slice)
+ override public bool EinaRwSliceOut(ref Eina.RwSlice slice)
{
rw_slice_out_flag = true;
// //
//
- override public bool EinaBinbufIn(eina.Binbuf binbuf)
+ override public bool EinaBinbufIn(Eina.Binbuf binbuf)
{
binbuf_in_flag = true;
return r;
}
- private eina.Binbuf binbuf_in_own_binbuf = null;
- override public bool EinaBinbufInOwn(eina.Binbuf binbuf)
+ private Eina.Binbuf binbuf_in_own_binbuf = null;
+ override public bool EinaBinbufInOwn(Eina.Binbuf binbuf)
{
binbuf_in_own_flag = true;
return r;
}
- private eina.Binbuf binbuf_out_binbuf = null;
- override public bool EinaBinbufOut(out eina.Binbuf binbuf)
+ private Eina.Binbuf binbuf_out_binbuf = null;
+ override public bool EinaBinbufOut(out Eina.Binbuf binbuf)
{
binbuf_out_flag = true;
- binbuf = new eina.Binbuf();
+ binbuf = new Eina.Binbuf();
binbuf.Append(33);
binbuf_out_binbuf = binbuf;
return r;
}
- private eina.Binbuf binbuf_out_own_binbuf = null;
- override public bool EinaBinbufOutOwn(out eina.Binbuf binbuf)
+ private Eina.Binbuf binbuf_out_own_binbuf = null;
+ override public bool EinaBinbufOutOwn(out Eina.Binbuf binbuf)
{
binbuf_out_own_flag = true;
- binbuf = new eina.Binbuf();
+ binbuf = new Eina.Binbuf();
binbuf.Append(33);
binbuf_out_own_binbuf = binbuf;
return r;
}
- private eina.Binbuf binbuf_return_binbuf = null;
- override public eina.Binbuf EinaBinbufReturn()
+ private Eina.Binbuf binbuf_return_binbuf = null;
+ override public Eina.Binbuf EinaBinbufReturn()
{
binbuf_return_flag = true;
- var binbuf = new eina.Binbuf();
+ var binbuf = new Eina.Binbuf();
binbuf.Append(33);
binbuf_return_binbuf = binbuf;
return r;
}
- private eina.Binbuf binbuf_return_own_binbuf = null;
- override public eina.Binbuf EinaBinbufReturnOwn()
+ private Eina.Binbuf binbuf_return_own_binbuf = null;
+ override public Eina.Binbuf EinaBinbufReturnOwn()
{
binbuf_return_own_flag = true;
- var binbuf = new eina.Binbuf();
+ var binbuf = new Eina.Binbuf();
binbuf.Append(33);
binbuf_return_own_binbuf = binbuf;
public static void eina_binbuf_default()
{
- var binbuf = new eina.Binbuf();
+ var binbuf = new Eina.Binbuf();
Test.Assert(binbuf.Handle != IntPtr.Zero);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[0]));
}
public static void eina_binbuf_bytes()
{
- var binbuf = new eina.Binbuf(test_string);
+ var binbuf = new Eina.Binbuf(test_string);
Test.Assert(binbuf.Handle != IntPtr.Zero);
byte[] cmp = binbuf.GetBytes();
Test.Assert(cmp != test_string);
public static void eina_binbuf_bytes_length()
{
- var binbuf = new eina.Binbuf(test_string, 7);
+ var binbuf = new Eina.Binbuf(test_string, 7);
Test.Assert(binbuf.Handle != IntPtr.Zero);
byte[] cmp = binbuf.GetBytes();
byte[] expected = System.Text.Encoding.UTF8.GetBytes("0123456");
public static void eina_binbuf_copy_ctor()
{
- var binbuf = new eina.Binbuf(test_string);
+ var binbuf = new Eina.Binbuf(test_string);
Test.Assert(binbuf.Handle != IntPtr.Zero);
- var binbuf2 = new eina.Binbuf(binbuf);
+ var binbuf2 = new Eina.Binbuf(binbuf);
Test.Assert(binbuf2.Handle != IntPtr.Zero && binbuf.Handle != binbuf2.Handle);
byte[] cmp = binbuf.GetBytes();
byte[] cmp2 = binbuf2.GetBytes();
public static void free_get_null_handle()
{
- var binbuf = new eina.Binbuf(test_string);
+ var binbuf = new Eina.Binbuf(test_string);
Test.Assert(binbuf.Handle != IntPtr.Zero);
binbuf.Free();
Test.Assert(binbuf.Handle == IntPtr.Zero);
public static void reset_get_empty_string()
{
- var binbuf = new eina.Binbuf(test_string);
+ var binbuf = new Eina.Binbuf(test_string);
Test.Assert(binbuf.Handle != IntPtr.Zero);
byte[] cmp = binbuf.GetBytes();
Test.Assert(cmp != test_string);
public static void append_bytes()
{
- var binbuf = new eina.Binbuf();
+ var binbuf = new Eina.Binbuf();
binbuf.Append(test_string);
byte[] cmp = binbuf.GetBytes();
Test.Assert(cmp != test_string);
public static void append_bytes_length()
{
- var binbuf = new eina.Binbuf();
+ var binbuf = new Eina.Binbuf();
binbuf.Append(test_string, 7);
byte[] cmp = binbuf.GetBytes();
byte[] expected = System.Text.Encoding.UTF8.GetBytes("0123456");
public static void append_binbuf()
{
- var binbuf = new eina.Binbuf();
+ var binbuf = new Eina.Binbuf();
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[0]));
- var binbuf2 = new eina.Binbuf(test_string);
+ var binbuf2 = new Eina.Binbuf(test_string);
binbuf.Append(binbuf2);
byte[] cmp = binbuf.GetBytes();
byte[] cmp2 = binbuf2.GetBytes();
public static void append_char()
{
- var binbuf = new eina.Binbuf();
+ var binbuf = new Eina.Binbuf();
binbuf.Append((byte) 0);
binbuf.Append((byte) 12);
binbuf.Append((byte) 42);
public static void remove()
{
- var binbuf = new eina.Binbuf(test_string);
+ var binbuf = new Eina.Binbuf(test_string);
Test.Assert(binbuf.GetBytes().SequenceEqual(test_string));
binbuf.Remove(2, 9);
Test.Assert(binbuf.Handle != IntPtr.Zero);
public static void get_string_native()
{
- var binbuf = new eina.Binbuf(test_string);
+ var binbuf = new Eina.Binbuf(test_string);
Test.Assert(binbuf.GetBytes().SequenceEqual(test_string));
Test.Assert(binbuf.GetStringNative() != IntPtr.Zero);
}
public static void binbuf_free_string()
{
- var binbuf = new eina.Binbuf(test_string);
+ var binbuf = new Eina.Binbuf(test_string);
Test.Assert(binbuf.GetBytes().SequenceEqual(test_string));
binbuf.FreeString();
Test.Assert(binbuf.Handle != IntPtr.Zero);
public static void binbuf_length()
{
- var binbuf = new eina.Binbuf(test_string, 6);
+ var binbuf = new Eina.Binbuf(test_string, 6);
Test.Assert(binbuf.Length == 6);
Test.Assert(binbuf.GetBytes().Length == 6);
}
public static void test_eina_binbuf_in()
{
- test.ITesting t = new test.Testing();
- var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
+ var t = new Dummy.TestObject();
+ var binbuf = new Eina.Binbuf(base_seq, (uint)base_seq.Length);
Test.Assert(t.EinaBinbufIn(binbuf));
Test.Assert(binbuf.Own);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33}));
public static void test_eina_binbuf_in_own()
{
- test.ITesting t = new test.Testing();
- var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
+ var t = new Dummy.TestObject();
+ var binbuf = new Eina.Binbuf(base_seq, (uint)base_seq.Length);
Test.Assert(t.EinaBinbufInOwn(binbuf));
Test.Assert(!binbuf.Own);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33}));
public static void test_eina_binbuf_out()
{
- test.ITesting t = new test.Testing();
- eina.Binbuf binbuf;
+ var t = new Dummy.TestObject();
+ Eina.Binbuf binbuf;
Test.Assert(t.EinaBinbufOut(out binbuf));
Test.Assert(!binbuf.Own);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
public static void test_eina_binbuf_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Binbuf binbuf;
+ var t = new Dummy.TestObject();
+ Eina.Binbuf binbuf;
Test.Assert(t.EinaBinbufOutOwn(out binbuf));
Test.Assert(binbuf.Own);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
public static void test_eina_binbuf_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var binbuf = t.EinaBinbufReturn();
Test.Assert(!binbuf.Own);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
public static void test_eina_binbuf_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var binbuf = t.EinaBinbufReturnOwn();
Test.Assert(binbuf.Own);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
public static void test_inherit_eina_binbuf_in()
{
var t = new NativeInheritImpl();
- var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
+ var binbuf = new Eina.Binbuf(base_seq, (uint)base_seq.Length);
Test.Assert(t.CallEinaBinbufIn(binbuf));
Test.Assert(t.binbuf_in_flag);
Test.Assert(binbuf.Own);
public static void test_inherit_eina_binbuf_in_own()
{
var t = new NativeInheritImpl();
- var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
+ var binbuf = new Eina.Binbuf(base_seq, (uint)base_seq.Length);
binbuf.Own = false;
Test.Assert(t.CallEinaBinbufInOwn(binbuf));
Test.Assert(t.binbuf_in_own_flag);
public static void test_inherit_eina_binbuf_out()
{
var t = new NativeInheritImpl();
- eina.Binbuf binbuf = t.CallEinaBinbufOut();
+ Eina.Binbuf binbuf = t.CallEinaBinbufOut();
Test.Assert(t.binbuf_out_flag);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
binbuf.Reset();
public static void test_inherit_eina_binbuf_out_own()
{
var t = new NativeInheritImpl();
- eina.Binbuf binbuf = t.CallEinaBinbufOutOwn();
+ Eina.Binbuf binbuf = t.CallEinaBinbufOutOwn();
Test.Assert(t.binbuf_out_own_flag);
Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
binbuf.Reset();
public static void eina_slice_marshalling()
{
- var binbuf = new eina.Binbuf(base_seq);
+ var binbuf = new Eina.Binbuf(base_seq);
Test.Assert(binbuf.Handle != IntPtr.Zero);
- eina.Slice slc = eina.Binbuf.eina_binbuf_slice_get(binbuf.Handle);
+ Eina.Slice slc = Eina.Binbuf.eina_binbuf_slice_get(binbuf.Handle);
Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
Test.Assert(base_seq.Length == (int)(slc.Len));
public static void eina_slice_size()
{
- Test.Assert(Marshal.SizeOf(typeof(eina.Slice)) == Marshal.SizeOf(typeof(UIntPtr)) + Marshal.SizeOf(typeof(IntPtr)));
- Test.Assert(Marshal.SizeOf(typeof(eina.Rw_Slice)) == Marshal.SizeOf(typeof(UIntPtr)) + Marshal.SizeOf(typeof(IntPtr)));
+ Test.Assert(Marshal.SizeOf(typeof(Eina.Slice)) == Marshal.SizeOf(typeof(UIntPtr)) + Marshal.SizeOf(typeof(IntPtr)));
+ Test.Assert(Marshal.SizeOf(typeof(Eina.RwSlice)) == Marshal.SizeOf(typeof(UIntPtr)) + Marshal.SizeOf(typeof(IntPtr)));
}
public static void pinned_data_set()
{
- var binbuf = new eina.Binbuf();
- binbuf.Append(new eina.Slice().PinnedDataSet(pinnedPtr, (UIntPtr)3));
+ var binbuf = new Eina.Binbuf();
+ binbuf.Append(new Eina.Slice().PinnedDataSet(pinnedPtr, (UIntPtr)3));
Test.Assert(binbuf.GetBytes().SequenceEqual(base_seq));
}
public static void test_eina_slice_in()
{
- test.ITesting t = new test.Testing();
- var slc = new eina.Slice(pinnedPtr, (UIntPtr)3);
+ var t = new Dummy.TestObject();
+ var slc = new Eina.Slice(pinnedPtr, (UIntPtr)3);
Test.Assert(t.EinaSliceIn(slc));
}
GCHandle pinnedRWData = GCHandle.Alloc(rw_seq, GCHandleType.Pinned);
IntPtr ptr = pinnedRWData.AddrOfPinnedObject();
- var slc = new eina.Rw_Slice(ptr, (UIntPtr)3);
+ var slc = new Eina.RwSlice(ptr, (UIntPtr)3);
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
Test.Assert(t.EinaRwSliceIn(slc));
Test.Assert(slc.GetBytes().SequenceEqual(new byte[3]{0x1,0x2B,0x43}));
public static void test_eina_slice_out()
{
- test.ITesting t = new test.Testing();
- var slc = new eina.Slice();
+ var t = new Dummy.TestObject();
+ var slc = new Eina.Slice();
Test.Assert(t.EinaSliceOut(ref slc));
Test.Assert(slc.Mem != IntPtr.Zero);
Test.Assert(slc.Length == base_seq.Length);
public static void test_eina_rw_slice_out()
{
- test.ITesting t = new test.Testing();
- var slc = new eina.Rw_Slice();
+ var t = new Dummy.TestObject();
+ var slc = new Eina.RwSlice();
Test.Assert(t.EinaRwSliceOut(ref slc));
Test.Assert(slc.Mem != IntPtr.Zero);
Test.Assert(slc.Length == base_seq.Length);
public static void test_inherit_eina_slice_in()
{
var t = new NativeInheritImpl();
- var slc = new eina.Slice(pinnedPtr, (UIntPtr)3);
+ var slc = new Eina.Slice(pinnedPtr, (UIntPtr)3);
Test.Assert(t.EinaSliceIn(slc));
Test.Assert(t.slice_in_flag);
}
GCHandle pinnedRWData = GCHandle.Alloc(rw_seq, GCHandleType.Pinned);
IntPtr ptr = pinnedRWData.AddrOfPinnedObject();
- var slc = new eina.Rw_Slice(ptr, (UIntPtr)3);
+ var slc = new Eina.RwSlice(ptr, (UIntPtr)3);
var t = new NativeInheritImpl();
Test.Assert(t.EinaRwSliceIn(slc));
public static void test_inherit_eina_slice_out()
{
var t = new NativeInheritImpl();
- var slc = new eina.Slice();
+ var slc = new Eina.Slice();
Test.Assert(t.EinaSliceOut(ref slc));
Test.Assert(t.slice_out_flag);
Test.Assert(slc.Mem != IntPtr.Zero);
public static void test_inherit_eina_rw_slice_out()
{
var t = new NativeInheritImpl();
- var slc = new eina.Rw_Slice();
+ var slc = new Eina.RwSlice();
Test.Assert(t.EinaRwSliceOut(ref slc));
Test.Assert(t.rw_slice_out_flag);
Test.Assert(slc.Mem != IntPtr.Zero);
{
public static void eina_array_default()
{
- var a = new eina.Array<int>();
+ var a = new Eina.Array<int>();
Test.Assert(a.Handle != IntPtr.Zero);
}
public static void push_int()
{
- var a = new eina.Array<int>();
+ var a = new Eina.Array<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push(88));
Test.Assert(a[0] == 88);
public static void push_string()
{
- var a = new eina.Array<string>();
+ var a = new Eina.Array<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push("test string §éΨبÿツ"));
Test.AssertEquals("test string §éΨبÿツ", a[0]);
public static void push_obj()
{
- var a = new eina.Array<test.INumberwrapper>();
+ var a = new Eina.Array<Dummy.Numberwrapper>();
Test.Assert(a.Handle != IntPtr.Zero);
- var o = new test.Numberwrapper();
+ var o = new Dummy.Numberwrapper();
o.SetNumber(88);
Test.Assert(a.Push(o));
- Test.Assert(a[0].raw_handle == o.raw_handle);
+ Test.Assert(a[0].NativeHandle == o.NativeHandle);
Test.Assert(a[0].GetNumber() == 88);
}
public static void pop_int()
{
- var a = new eina.Array<int>();
+ var a = new Eina.Array<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push(88));
Test.Assert(a.Pop() == 88);
public static void pop_string()
{
- var a = new eina.Array<string>();
+ var a = new Eina.Array<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push("test string"));
Test.Assert(a.Pop() == "test string");
public static void pop_obj()
{
- var a = new eina.Array<test.INumberwrapper>();
+ var a = new Eina.Array<Dummy.Numberwrapper>();
Test.Assert(a.Handle != IntPtr.Zero);
- var o = new test.Numberwrapper();
+ var o = new Dummy.Numberwrapper();
o.SetNumber(88);
Test.Assert(a.Push(o));
var p = a.Pop();
- Test.Assert(p.raw_handle == o.raw_handle);
+ Test.Assert(p.NativeHandle == o.NativeHandle);
Test.Assert(p.GetNumber() == 88);
Test.Assert(a.Count() == 0);
}
public static void data_set_int()
{
- var a = new eina.Array<int>();
+ var a = new Eina.Array<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push(88));
Test.Assert(a[0] == 88);
public static void data_set_string()
{
- var a = new eina.Array<string>();
+ var a = new Eina.Array<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push("test string"));
Test.Assert(a[0] == "test string");
public static void data_set_obj()
{
- var a = new eina.Array<test.INumberwrapper>();
+ var a = new Eina.Array<Dummy.Numberwrapper>();
Test.Assert(a.Handle != IntPtr.Zero);
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
Test.Assert(a.Push(o1));
- Test.Assert(a[0].raw_handle == o1.raw_handle);
+ Test.Assert(a[0].NativeHandle == o1.NativeHandle);
Test.Assert(a[0].GetNumber() == 88);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
a.DataSet(0, o2);
- Test.Assert(a[0].raw_handle == o2.raw_handle);
+ Test.Assert(a[0].NativeHandle == o2.NativeHandle);
Test.Assert(a[0].GetNumber() == 44);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
a[0] = o3;
- Test.Assert(a[0].raw_handle == o3.raw_handle);
+ Test.Assert(a[0].NativeHandle == o3.NativeHandle);
Test.Assert(a[0].GetNumber() == 22);
}
public static void count_int()
{
- var a = new eina.Array<int>();
+ var a = new Eina.Array<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Count() == 0);
Test.Assert(a.Push(88));
public static void count_string()
{
- var a = new eina.Array<string>();
+ var a = new Eina.Array<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Count() == 0);
Test.Assert(a.Push("a"));
public static void count_obj()
{
- var a = new eina.Array<test.INumberwrapper>();
+ var a = new Eina.Array<Dummy.Numberwrapper>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Count() == 0);
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
Test.Assert(a.Push(o1));
- Test.Assert(a[0].raw_handle == o1.raw_handle);
+ Test.Assert(a[0].NativeHandle == o1.NativeHandle);
Test.Assert(a[0].GetNumber() == 88);
Test.Assert(a.Count() == 1);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
Test.Assert(a.Push(o2));
- Test.Assert(a[1].raw_handle == o2.raw_handle);
+ Test.Assert(a[1].NativeHandle == o2.NativeHandle);
Test.Assert(a[1].GetNumber() == 44);
Test.Assert(a.Count() == 2);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
Test.Assert(a.Push(o3));
- Test.Assert(a[2].raw_handle == o3.raw_handle);
+ Test.Assert(a[2].NativeHandle == o3.NativeHandle);
Test.Assert(a[2].GetNumber() == 22);
Test.Assert(a.Count() == 3);
}
public static void length_int()
{
- var a = new eina.Array<int>();
+ var a = new Eina.Array<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Length == 0);
Test.Assert(a.Push(88));
public static void length_string()
{
- var a = new eina.Array<string>();
+ var a = new Eina.Array<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Length == 0);
Test.Assert(a.Push("a"));
public static void eina_array_as_ienumerable_int()
{
- var a = new eina.Array<int>();
+ var a = new Eina.Array<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push(88));
Test.Assert(a.Push(44));
public static void eina_array_as_ienumerable_string()
{
- var a = new eina.Array<string>();
+ var a = new Eina.Array<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push("X"));
Test.Assert(a.Push("XX"));
public static void eina_array_as_ienumerable_obj()
{
- var a = new test.Numberwrapper();
- var b = new test.Numberwrapper();
- var c = new test.Numberwrapper();
+ var a = new Dummy.Numberwrapper();
+ var b = new Dummy.Numberwrapper();
+ var c = new Dummy.Numberwrapper();
a.SetNumber(88);
b.SetNumber(44);
c.SetNumber(22);
- var cmp = new test.Numberwrapper[]{a,b,c};
+ var cmp = new Dummy.Numberwrapper[]{a,b,c};
- var arr = new eina.Array<test.INumberwrapper>();
+ var arr = new Eina.Array<Dummy.Numberwrapper>();
Test.Assert(arr.Handle != IntPtr.Zero);
Test.Assert(arr.Push(a));
Test.Assert(arr.Push(b));
Test.Assert(arr.Push(c));
int i = 0;
- foreach (test.Numberwrapper e in arr)
+ foreach (Dummy.Numberwrapper e in arr)
{
Test.AssertEquals(cmp[i].GetNumber(), e.GetNumber());
- Test.Assert(cmp[i].raw_handle == e.raw_handle);
+ Test.Assert(cmp[i].NativeHandle == e.NativeHandle);
++i;
}
}
public static void test_eina_array_int_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<int>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<int>();
arr.Append(base_seq_int);
Test.Assert(t.EinaArrayIntIn(arr));
Test.Assert(arr.Own);
public static void test_eina_array_int_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<int>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<int>();
arr.Append(base_seq_int);
Test.Assert(t.EinaArrayIntInOwn(arr));
Test.Assert(!arr.Own);
public static void test_eina_array_int_out()
{
- test.ITesting t = new test.Testing();
- eina.Array<int> arr;
+ var t = new Dummy.TestObject();
+ Eina.Array<int> arr;
Test.Assert(t.EinaArrayIntOut(out arr));
Test.Assert(!arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_array_int_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Array<int> arr;
+ var t = new Dummy.TestObject();
+ Eina.Array<int> arr;
Test.Assert(t.EinaArrayIntOutOwn(out arr));
Test.Assert(arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_array_int_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaArrayIntReturn();
Test.Assert(!arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_array_int_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaArrayIntReturnOwn();
Test.Assert(arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
// String //
public static void test_eina_array_str_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<string>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<string>();
arr.Append(base_seq_str);
Test.Assert(t.EinaArrayStrIn(arr));
Test.Assert(arr.Own);
public static void test_eina_array_str_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<string>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<string>();
arr.Append(base_seq_str);
Test.Assert(t.EinaArrayStrInOwn(arr));
Test.Assert(!arr.Own);
public static void test_eina_array_str_out()
{
- test.ITesting t = new test.Testing();
- eina.Array<string> arr;
+ var t = new Dummy.TestObject();
+ Eina.Array<string> arr;
Test.Assert(t.EinaArrayStrOut(out arr));
Test.Assert(!arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_array_str_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Array<string> arr;
+ var t = new Dummy.TestObject();
+ Eina.Array<string> arr;
Test.Assert(t.EinaArrayStrOutOwn(out arr));
Test.Assert(arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_array_str_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaArrayStrReturn();
Test.Assert(!arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_array_str_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaArrayStrReturnOwn();
Test.Assert(arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_array_obj_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<Dummy.Numberwrapper>();
arr.Append(BaseSeqObj());
Test.Assert(t.EinaArrayObjIn(arr));
Test.Assert(arr.Own);
public static void test_eina_array_obj_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<Dummy.Numberwrapper>();
arr.Append(BaseSeqObj());
Test.Assert(t.EinaArrayObjInOwn(arr));
Test.Assert(!arr.Own);
public static void test_eina_array_obj_out()
{
- test.ITesting t = new test.Testing();
- eina.Array<test.INumberwrapper> arr;
+ var t = new Dummy.TestObject();
+ Eina.Array<Dummy.Numberwrapper> arr;
Test.Assert(t.EinaArrayObjOut(out arr));
Test.Assert(!arr.Own);
NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
public static void test_eina_array_obj_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Array<test.INumberwrapper> arr;
+ var t = new Dummy.TestObject();
+ Eina.Array<Dummy.Numberwrapper> arr;
Test.Assert(t.EinaArrayObjOutOwn(out arr));
Test.Assert(arr.Own);
NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
public static void test_eina_array_obj_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaArrayObjReturn();
Test.Assert(!arr.Own);
NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
public static void test_eina_array_obj_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaArrayObjReturnOwn();
Test.Assert(arr.Own);
NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
public static void test_eina_array_obj_return_in_same_id()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var cmp = BaseSeqObj();
- var a = new eina.Array<test.INumberwrapper>();
+ var a = new Eina.Array<Dummy.Numberwrapper>();
a.Append(cmp);
var b = t.EinaArrayObjReturnIn(a);
NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
int len = a.Length;
for (int i=0; i < len; ++i)
{
- Test.Assert(a[i].raw_handle == b[i].raw_handle);
- Test.Assert(a[i].raw_handle == cmp[i].raw_handle);
+ Test.Assert(a[i].NativeHandle == b[i].NativeHandle);
+ Test.Assert(a[i].NativeHandle == cmp[i].NativeHandle);
}
}
{
public static void eina_inarray_default()
{
- var a = new eina.Inarray<int>();
+ var a = new Eina.Inarray<int>();
Test.Assert(a.Handle != IntPtr.Zero);
a.Dispose();
}
public static void push_int()
{
- var a = new eina.Inarray<int>();
+ var a = new Eina.Inarray<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push(88) == 0);
Test.Assert(a[0] == 88);
public static void push_string()
{
- var a = new eina.Inarray<string>();
+ var a = new Eina.Inarray<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push("test string") == 0);
Test.Assert(a[0] == "test string");
public static void push_obj()
{
- var a = new eina.Inarray<test.INumberwrapper>();
+ var a = new Eina.Inarray<Dummy.Numberwrapper>();
Test.Assert(a.Handle != IntPtr.Zero);
- var o = new test.Numberwrapper();
+ var o = new Dummy.Numberwrapper();
o.SetNumber(88);
Test.Assert(a.Push(o) == 0);
- Test.Assert(a[0].raw_handle == o.raw_handle);
+ Test.Assert(a[0].NativeHandle == o.NativeHandle);
Test.Assert(a[0].GetNumber() == 88);
a.Dispose();
}
public static void pop_int()
{
- var a = new eina.Inarray<int>();
+ var a = new Eina.Inarray<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push(88) >= 0);
Test.Assert(a.Pop() == 88);
public static void pop_string()
{
- var a = new eina.Inarray<string>();
+ var a = new Eina.Inarray<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push("test string") >= 0);
Test.Assert(a.Pop() == "test string");
public static void pop_obj()
{
- var a = new eina.Inarray<test.INumberwrapper>();
+ var a = new Eina.Inarray<Dummy.Numberwrapper>();
Test.Assert(a.Handle != IntPtr.Zero);
- var o = new test.Numberwrapper();
+ var o = new Dummy.Numberwrapper();
o.SetNumber(88);
Test.Assert(a.Push(o) >= 0);
var p = a.Pop();
- Test.Assert(p.raw_handle == o.raw_handle);
+ Test.Assert(p.NativeHandle == o.NativeHandle);
Test.Assert(p.GetNumber() == 88);
Test.Assert(a.Count() == 0);
a.Dispose();
public static void replace_at_int()
{
- var a = new eina.Inarray<int>();
+ var a = new Eina.Inarray<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push(88) >= 0);
Test.Assert(a[0] == 88);
public static void replace_at_string()
{
- var a = new eina.Inarray<string>();
+ var a = new Eina.Inarray<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push("test string") >= 0);
Test.Assert(a[0] == "test string");
public static void replace_at_obj()
{
- var a = new eina.Inarray<test.INumberwrapper>();
+ var a = new Eina.Inarray<Dummy.Numberwrapper>();
Test.Assert(a.Handle != IntPtr.Zero);
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
Test.Assert(a.Push(o1) >= 0);
- Test.Assert(a[0].raw_handle == o1.raw_handle);
+ Test.Assert(a[0].NativeHandle == o1.NativeHandle);
Test.Assert(a[0].GetNumber() == 88);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
a.ReplaceAt(0, o2);
- Test.Assert(a[0].raw_handle == o2.raw_handle);
+ Test.Assert(a[0].NativeHandle == o2.NativeHandle);
Test.Assert(a[0].GetNumber() == 44);
Test.Assert(a.Count() == 1);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
a[0] = o3;
- Test.Assert(a[0].raw_handle == o3.raw_handle);
+ Test.Assert(a[0].NativeHandle == o3.NativeHandle);
Test.Assert(a[0].GetNumber() == 22);
Test.Assert(a.Count() == 1);
public static void count_int()
{
- var a = new eina.Inarray<int>();
+ var a = new Eina.Inarray<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Count() == 0);
Test.Assert(a.Push(88) == 0);
public static void count_string()
{
- var a = new eina.Inarray<string>();
+ var a = new Eina.Inarray<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Count() == 0);
Test.Assert(a.Push("a") == 0);
public static void count_obj()
{
- var a = new eina.Inarray<test.INumberwrapper>();
+ var a = new Eina.Inarray<Dummy.Numberwrapper>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Count() == 0);
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
Test.Assert(a.Push(o1) == 0);
- Test.Assert(a[0].raw_handle == o1.raw_handle);
+ Test.Assert(a[0].NativeHandle == o1.NativeHandle);
Test.Assert(a[0].GetNumber() == 88);
Test.Assert(a.Count() == 1);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
Test.Assert(a.Push(o2) == 1);
- Test.Assert(a[1].raw_handle == o2.raw_handle);
+ Test.Assert(a[1].NativeHandle == o2.NativeHandle);
Test.Assert(a[1].GetNumber() == 44);
Test.Assert(a.Count() == 2);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
Test.Assert(a.Push(o3) == 2);
- Test.Assert(a[2].raw_handle == o3.raw_handle);
+ Test.Assert(a[2].NativeHandle == o3.NativeHandle);
Test.Assert(a[2].GetNumber() == 22);
Test.Assert(a.Count() == 3);
public static void length_int()
{
- var a = new eina.Inarray<int>();
+ var a = new Eina.Inarray<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Length == 0);
Test.Assert(a.Push(88) >= 0);
public static void length_string()
{
- var a = new eina.Inarray<string>();
+ var a = new Eina.Inarray<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Length == 0);
Test.Assert(a.Push("a") >= 0);
public static void eina_inarray_as_ienumerable_int()
{
- var a = new eina.Inarray<int>();
+ var a = new Eina.Inarray<int>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push(88) == 0);
Test.Assert(a.Push(44) == 1);
public static void eina_inarray_as_ienumerable_string()
{
- var a = new eina.Inarray<string>();
+ var a = new Eina.Inarray<string>();
Test.Assert(a.Handle != IntPtr.Zero);
Test.Assert(a.Push("X") == 0);
Test.Assert(a.Push("XX") == 1);
public static void eina_inarray_as_ienumerable_obj()
{
- var a = new test.Numberwrapper();
- var b = new test.Numberwrapper();
- var c = new test.Numberwrapper();
+ var a = new Dummy.Numberwrapper();
+ var b = new Dummy.Numberwrapper();
+ var c = new Dummy.Numberwrapper();
a.SetNumber(88);
b.SetNumber(44);
c.SetNumber(22);
- var cmp = new test.Numberwrapper[]{a,b,c};
+ var cmp = new Dummy.Numberwrapper[]{a,b,c};
- var arr = new eina.Inarray<test.INumberwrapper>();
+ var arr = new Eina.Inarray<Dummy.Numberwrapper>();
Test.Assert(arr.Handle != IntPtr.Zero);
Test.Assert(arr.Push(a) == 0);
Test.Assert(arr.Push(b) == 1);
Test.Assert(arr.Push(c) == 2);
int i = 0;
- foreach (test.Numberwrapper e in arr)
+ foreach (Dummy.Numberwrapper e in arr)
{
Test.AssertEquals(cmp[i].GetNumber(), e.GetNumber());
- Test.Assert(cmp[i].raw_handle == e.raw_handle);
+ Test.Assert(cmp[i].NativeHandle == e.NativeHandle);
++i;
}
arr.Dispose();
public static void test_eina_inarray_int_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Inarray<int>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Inarray<int>();
arr.Append(base_seq_int);
Test.Assert(t.EinaInarrayIntIn(arr));
Test.Assert(arr.Own);
public static void test_eina_inarray_int_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Inarray<int>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Inarray<int>();
arr.Append(base_seq_int);
Test.Assert(t.EinaInarrayIntInOwn(arr));
Test.Assert(!arr.Own);
public static void test_eina_inarray_int_out()
{
- test.ITesting t = new test.Testing();
- eina.Inarray<int> arr;
+ var t = new Dummy.TestObject();
+ Eina.Inarray<int> arr;
Test.Assert(t.EinaInarrayIntOut(out arr));
Test.Assert(!arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_inarray_int_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Inarray<int> arr;
+ var t = new Dummy.TestObject();
+ Eina.Inarray<int> arr;
Test.Assert(t.EinaInarrayIntOutOwn(out arr));
Test.Assert(arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_inarray_int_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaInarrayIntReturn();
Test.Assert(!arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_inarray_int_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaInarrayIntReturnOwn();
Test.Assert(arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
// String //
public static void test_eina_inarray_str_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Inarray<string>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Inarray<string>();
arr.Append(base_seq_str);
Test.Assert(t.EinaInarrayStrIn(arr));
Test.Assert(arr.Own);
public static void test_eina_inarray_str_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Inarray<string>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Inarray<string>();
arr.Append(base_seq_str);
Test.Assert(t.EinaInarrayStrInOwn(arr));
Test.Assert(!arr.Own);
public static void test_eina_inarray_str_out()
{
- test.ITesting t = new test.Testing();
- eina.Inarray<string> arr;
+ var t = new Dummy.TestObject();
+ Eina.Inarray<string> arr;
Test.Assert(t.EinaInarrayStrOut(out arr));
Test.Assert(!arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_inarray_str_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Inarray<string> arr;
+ var t = new Dummy.TestObject();
+ Eina.Inarray<string> arr;
Test.Assert(t.EinaInarrayStrOutOwn(out arr));
Test.Assert(arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_inarray_str_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaInarrayStrReturn();
Test.Assert(!arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_inarray_str_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaInarrayStrReturnOwn();
Test.Assert(arr.Own);
Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_inarray_obj_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Inarray<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Inarray<Dummy.Numberwrapper>();
arr.Append(BaseSeqObj());
Test.Assert(t.EinaInarrayObjIn(arr));
Test.Assert(arr.Own);
public static void test_eina_inarray_obj_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Inarray<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Inarray<Dummy.Numberwrapper>();
arr.Append(BaseSeqObj());
Test.Assert(t.EinaInarrayObjInOwn(arr));
Test.Assert(!arr.Own);
public static void test_eina_inarray_obj_out()
{
- test.ITesting t = new test.Testing();
- eina.Inarray<test.INumberwrapper> arr;
+ var t = new Dummy.TestObject();
+ Eina.Inarray<Dummy.Numberwrapper> arr;
Test.Assert(t.EinaInarrayObjOut(out arr));
Test.Assert(!arr.Own);
NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
public static void test_eina_inarray_obj_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Inarray<test.INumberwrapper> arr;
+ var t = new Dummy.TestObject();
+ Eina.Inarray<Dummy.Numberwrapper> arr;
Test.Assert(t.EinaInarrayObjOutOwn(out arr));
Test.Assert(arr.Own);
NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
public static void test_eina_inarray_obj_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaInarrayObjReturn();
Test.Assert(!arr.Own);
NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
public static void test_eina_inarray_obj_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var arr = t.EinaInarrayObjReturnOwn();
Test.Assert(arr.Own);
NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
public static void test_eina_inarray_obj_return_in_same_id()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var cmp = BaseSeqObj();
- var a = new eina.Inarray<test.INumberwrapper>();
+ var a = new Eina.Inarray<Dummy.Numberwrapper>();
a.Append(cmp);
var b = t.EinaInarrayObjReturnIn(a);
NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
int len = a.Length;
for (int i=0; i < len; ++i)
{
- Test.Assert(a[i].raw_handle == b[i].raw_handle);
- Test.Assert(a[i].raw_handle == cmp[i].raw_handle);
+ Test.Assert(a[i].NativeHandle == b[i].NativeHandle);
+ Test.Assert(a[i].NativeHandle == cmp[i].NativeHandle);
}
a.Dispose();
}
{
public static void data_set_int()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
lst.Append(88);
Test.Assert(lst[0] == 88);
lst.DataSet(0, 44);
public static void data_set_string()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
lst.Append("test string");
Test.Assert(lst[0] == "test string");
lst.DataSet(0, "other string");
public static void data_set_obj()
{
- var lst = new eina.List<test.INumberwrapper>();
+ var lst = new Eina.List<Dummy.Numberwrapper>();
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
lst.Append(o1);
- Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o1.NativeHandle);
Test.Assert(lst[0].GetNumber() == 88);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
lst.DataSet(0, o2);
- Test.Assert(lst[0].raw_handle == o2.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o2.NativeHandle);
Test.Assert(lst[0].GetNumber() == 44);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
lst[0] = o3;
- Test.Assert(lst[0].raw_handle == o3.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o3.NativeHandle);
Test.Assert(lst[0].GetNumber() == 22);
}
public static void append_count_int()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
Test.Assert(lst.Count() == 0);
lst.Append(88);
Test.Assert(lst[0] == 88);
public static void append_count_string()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
Test.Assert(lst.Count() == 0);
lst.Append("a");
Test.Assert(lst[0] == "a");
public static void append_count_obj()
{
- var lst = new eina.List<test.INumberwrapper>();
+ var lst = new Eina.List<Dummy.Numberwrapper>();
Test.Assert(lst.Count() == 0);
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
lst.Append(o1);
- Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o1.NativeHandle);
Test.Assert(lst[0].GetNumber() == 88);
Test.Assert(lst.Count() == 1);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
lst.Append(o2);
- Test.Assert(lst[1].raw_handle == o2.raw_handle);
+ Test.Assert(lst[1].NativeHandle == o2.NativeHandle);
Test.Assert(lst[1].GetNumber() == 44);
Test.Assert(lst.Count() == 2);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
lst.Append(o3);
- Test.Assert(lst[2].raw_handle == o3.raw_handle);
+ Test.Assert(lst[2].NativeHandle == o3.NativeHandle);
Test.Assert(lst[2].GetNumber() == 22);
Test.Assert(lst.Count() == 3);
}
public static void length_int()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
Test.Assert(lst.Length == 0);
lst.Append(88);
Test.Assert(lst[0] == 88);
public static void length_string()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
Test.Assert(lst.Length == 0);
lst.Append("a");
Test.Assert(lst[0] == "a");
public static void prepend_count_int()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
Test.Assert(lst.Count() == 0);
lst.Prepend(88);
Test.Assert(lst[0] == 88);
public static void prepend_count_string()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
Test.Assert(lst.Count() == 0);
lst.Prepend("a");
Test.Assert(lst[0] == "a");
public static void prepend_count_obj()
{
- var lst = new eina.List<test.INumberwrapper>();
+ var lst = new Eina.List<Dummy.Numberwrapper>();
Test.Assert(lst.Count() == 0);
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
lst.Prepend(o1);
- Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o1.NativeHandle);
Test.Assert(lst[0].GetNumber() == 88);
Test.Assert(lst.Count() == 1);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
lst.Prepend(o2);
- Test.Assert(lst[0].raw_handle == o2.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o2.NativeHandle);
Test.Assert(lst[0].GetNumber() == 44);
Test.Assert(lst.Count() == 2);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
lst.Prepend(o3);
- Test.Assert(lst[0].raw_handle == o3.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o3.NativeHandle);
Test.Assert(lst[0].GetNumber() == 22);
Test.Assert(lst.Count() == 3);
}
public static void sorted_insert_int()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
lst.SortedInsert(88);
Test.Assert(lst.ToArray().SequenceEqual(new int[]{88}));
lst.SortedInsert(22);
public static void sorted_insert_string()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
lst.SortedInsert("c");
Test.Assert(lst.ToArray().SequenceEqual(new string[]{"c"}));
lst.SortedInsert("a");
public static void sort_int()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
lst.Append(88);
lst.Append(22);
lst.Append(11);
public static void sort_string()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
lst.Append("d");
lst.Append("b");
lst.Append("a");
public static void reverse_int()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
lst.Append(22);
lst.Append(44);
lst.Append(88);
public static void reverse_string()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
lst.Append("a");
lst.Append("b");
lst.Append("c");
public static void eina_list_as_ienumerable_int()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
lst.Append(88);
lst.Append(44);
lst.Append(22);
public static void eina_list_as_ienumerable_string()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
lst.Append("X");
lst.Append("XX");
lst.Append("XXX");
public static void eina_list_as_ienumerable_obj()
{
- var a = new test.Numberwrapper();
- var b = new test.Numberwrapper();
- var c = new test.Numberwrapper();
+ var a = new Dummy.Numberwrapper();
+ var b = new Dummy.Numberwrapper();
+ var c = new Dummy.Numberwrapper();
a.SetNumber(88);
b.SetNumber(44);
c.SetNumber(22);
- var cmp = new test.Numberwrapper[]{a,b,c};
+ var cmp = new Dummy.Numberwrapper[]{a,b,c};
- var lst = new eina.List<test.INumberwrapper>();
+ var lst = new Eina.List<Dummy.Numberwrapper>();
lst.Append(a);
lst.Append(b);
lst.Append(c);
int i = 0;
- foreach (test.Numberwrapper e in lst)
+ foreach (Dummy.Numberwrapper e in lst)
{
Test.AssertEquals(cmp[i].GetNumber(), e.GetNumber());
- Test.Assert(cmp[i].raw_handle == e.raw_handle);
+ Test.Assert(cmp[i].NativeHandle == e.NativeHandle);
++i;
}
}
public static void test_eina_list_int_in()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.List<int>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.List<int>();
lst.AppendArray(base_seq_int);
Test.Assert(t.EinaListIntIn(lst));
Test.Assert(lst.Own);
public static void test_eina_list_int_in_own()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.List<int>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.List<int>();
lst.AppendArray(base_seq_int);
Test.Assert(t.EinaListIntInOwn(lst));
Test.Assert(!lst.Own);
public static void test_eina_list_int_out()
{
- test.ITesting t = new test.Testing();
- eina.List<int> lst;
+ var t = new Dummy.TestObject();
+ Eina.List<int> lst;
Test.Assert(t.EinaListIntOut(out lst));
Test.Assert(!lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_list_int_out_own()
{
- test.ITesting t = new test.Testing();
- eina.List<int> lst;
+ var t = new Dummy.TestObject();
+ Eina.List<int> lst;
Test.Assert(t.EinaListIntOutOwn(out lst));
Test.Assert(lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_list_int_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaListIntReturn();
Test.Assert(!lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_list_int_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaListIntReturnOwn();
Test.Assert(lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
// String //
public static void test_eina_list_str_in()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.List<string>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.List<string>();
lst.AppendArray(base_seq_str);
Test.Assert(t.EinaListStrIn(lst));
Test.Assert(lst.Own);
public static void test_eina_list_str_in_own()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.List<string>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.List<string>();
lst.AppendArray(base_seq_str);
Test.Assert(t.EinaListStrInOwn(lst));
Test.Assert(!lst.Own);
public static void test_eina_list_str_out()
{
- test.ITesting t = new test.Testing();
- eina.List<string> lst;
+ var t = new Dummy.TestObject();
+ Eina.List<string> lst;
Test.Assert(t.EinaListStrOut(out lst));
Test.Assert(!lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_list_str_out_own()
{
- test.ITesting t = new test.Testing();
- eina.List<string> lst;
+ var t = new Dummy.TestObject();
+ Eina.List<string> lst;
Test.Assert(t.EinaListStrOutOwn(out lst));
Test.Assert(lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_list_str_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaListStrReturn();
Test.Assert(!lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_list_str_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaListStrReturnOwn();
Test.Assert(lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_list_obj_in()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.List<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.List<Dummy.Numberwrapper>();
lst.AppendArray(BaseSeqObj());
Test.Assert(t.EinaListObjIn(lst));
Test.Assert(lst.Own);
public static void test_eina_list_obj_in_own()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.List<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.List<Dummy.Numberwrapper>();
lst.AppendArray(BaseSeqObj());
Test.Assert(t.EinaListObjInOwn(lst));
Test.Assert(!lst.Own);
public static void test_eina_list_obj_out()
{
- test.ITesting t = new test.Testing();
- eina.List<test.INumberwrapper> lst;
+ var t = new Dummy.TestObject();
+ Eina.List<Dummy.Numberwrapper> lst;
Test.Assert(t.EinaListObjOut(out lst));
Test.Assert(!lst.Own);
NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
public static void test_eina_list_obj_out_own()
{
- test.ITesting t = new test.Testing();
- eina.List<test.INumberwrapper> lst;
+ var t = new Dummy.TestObject();
+ Eina.List<Dummy.Numberwrapper> lst;
Test.Assert(t.EinaListObjOutOwn(out lst));
Test.Assert(lst.Own);
NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
public static void test_eina_list_obj_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaListObjReturn();
Test.Assert(!lst.Own);
NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
public static void test_eina_list_obj_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaListObjReturnOwn();
Test.Assert(lst.Own);
NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
public static void test_eina_list_obj_return_in_same_id()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var cmp = BaseSeqObj();
- var a = new eina.List<test.INumberwrapper>();
+ var a = new Eina.List<Dummy.Numberwrapper>();
a.AppendArray(cmp);
var b = t.EinaListObjReturnIn(a);
NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
int len = a.Length;
for (int i=0; i < len; ++i)
{
- Test.Assert(a[i].raw_handle == b[i].raw_handle);
- Test.Assert(a[i].raw_handle == cmp[i].raw_handle);
+ Test.Assert(a[i].NativeHandle == b[i].NativeHandle);
+ Test.Assert(a[i].NativeHandle == cmp[i].NativeHandle);
}
}
}
{
public static void data_set_int()
{
- var lst = new eina.Inlist<int>();
+ var lst = new Eina.Inlist<int>();
lst.Append(88);
Test.Assert(lst[0] == 88);
lst.DataSet(0, 44);
public static void data_set_string()
{
- var lst = new eina.Inlist<string>();
+ var lst = new Eina.Inlist<string>();
lst.Append("test string");
Test.Assert(lst[0] == "test string");
lst.DataSet(0, "other string");
public static void data_set_obj()
{
- var lst = new eina.Inlist<test.INumberwrapper>();
+ var lst = new Eina.Inlist<Dummy.Numberwrapper>();
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
lst.Append(o1);
- Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o1.NativeHandle);
Test.Assert(lst[0].GetNumber() == 88);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
lst.DataSet(0, o2);
- Test.Assert(lst[0].raw_handle == o2.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o2.NativeHandle);
Test.Assert(lst[0].GetNumber() == 44);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
lst[0] = o3;
- Test.Assert(lst[0].raw_handle == o3.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o3.NativeHandle);
Test.Assert(lst[0].GetNumber() == 22);
Test.Assert(lst.Count() == 1);
public static void append_count_int()
{
- var lst = new eina.Inlist<int>();
+ var lst = new Eina.Inlist<int>();
Test.Assert(lst.Count() == 0);
lst.Append(88);
Test.Assert(lst[0] == 88);
public static void append_count_string()
{
- var lst = new eina.Inlist<string>();
+ var lst = new Eina.Inlist<string>();
Test.Assert(lst.Count() == 0);
lst.Append("a");
Test.Assert(lst[0] == "a");
public static void append_count_obj()
{
- var lst = new eina.Inlist<test.INumberwrapper>();
+ var lst = new Eina.Inlist<Dummy.Numberwrapper>();
Test.Assert(lst.Count() == 0);
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
lst.Append(o1);
- Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o1.NativeHandle);
Test.Assert(lst[0].GetNumber() == 88);
Test.Assert(lst.Count() == 1);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
lst.Append(o2);
- Test.Assert(lst[1].raw_handle == o2.raw_handle);
+ Test.Assert(lst[1].NativeHandle == o2.NativeHandle);
Test.Assert(lst[1].GetNumber() == 44);
Test.Assert(lst.Count() == 2);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
lst.Append(o3);
- Test.Assert(lst[2].raw_handle == o3.raw_handle);
+ Test.Assert(lst[2].NativeHandle == o3.NativeHandle);
Test.Assert(lst[2].GetNumber() == 22);
Test.Assert(lst.Count() == 3);
}
public static void length_int()
{
- var lst = new eina.Inlist<int>();
+ var lst = new Eina.Inlist<int>();
Test.Assert(lst.Length == 0);
lst.Append(88);
Test.Assert(lst[0] == 88);
public static void length_string()
{
- var lst = new eina.Inlist<string>();
+ var lst = new Eina.Inlist<string>();
Test.Assert(lst.Length == 0);
lst.Append("a");
Test.Assert(lst[0] == "a");
public static void prepend_count_int()
{
- var lst = new eina.Inlist<int>();
+ var lst = new Eina.Inlist<int>();
Test.Assert(lst.Count() == 0);
lst.Prepend(88);
Test.Assert(lst[0] == 88);
public static void prepend_count_string()
{
- var lst = new eina.Inlist<string>();
+ var lst = new Eina.Inlist<string>();
Test.Assert(lst.Count() == 0);
lst.Prepend("a");
Test.Assert(lst[0] == "a");
public static void prepend_count_obj()
{
- var lst = new eina.Inlist<test.INumberwrapper>();
+ var lst = new Eina.Inlist<Dummy.Numberwrapper>();
Test.Assert(lst.Count() == 0);
- var o1 = new test.Numberwrapper();
+ var o1 = new Dummy.Numberwrapper();
o1.SetNumber(88);
lst.Prepend(o1);
- Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o1.NativeHandle);
Test.Assert(lst[0].GetNumber() == 88);
Test.Assert(lst.Count() == 1);
- var o2 = new test.Numberwrapper();
+ var o2 = new Dummy.Numberwrapper();
o2.SetNumber(44);
lst.Prepend(o2);
- Test.Assert(lst[0].raw_handle == o2.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o2.NativeHandle);
Test.Assert(lst[0].GetNumber() == 44);
Test.Assert(lst.Count() == 2);
- var o3 = new test.Numberwrapper();
+ var o3 = new Dummy.Numberwrapper();
o3.SetNumber(22);
lst.Prepend(o3);
- Test.Assert(lst[0].raw_handle == o3.raw_handle);
+ Test.Assert(lst[0].NativeHandle == o3.NativeHandle);
Test.Assert(lst[0].GetNumber() == 22);
Test.Assert(lst.Count() == 3);
}
public static void eina_inlist_as_ienumerable_int()
{
- var lst = new eina.Inlist<int>();
+ var lst = new Eina.Inlist<int>();
lst.Append(88);
lst.Append(44);
lst.Append(22);
public static void eina_inlist_as_ienumerable_string()
{
- var lst = new eina.Inlist<string>();
+ var lst = new Eina.Inlist<string>();
lst.Append("X");
lst.Append("XX");
lst.Append("XXX");
public static void eina_inlist_as_ienumerable_obj()
{
- var a = new test.Numberwrapper();
- var b = new test.Numberwrapper();
- var c = new test.Numberwrapper();
+ var a = new Dummy.Numberwrapper();
+ var b = new Dummy.Numberwrapper();
+ var c = new Dummy.Numberwrapper();
a.SetNumber(88);
b.SetNumber(44);
c.SetNumber(22);
- var cmp = new test.Numberwrapper[]{a,b,c};
+ var cmp = new Dummy.Numberwrapper[]{a,b,c};
- var lst = new eina.Inlist<test.INumberwrapper>();
+ var lst = new Eina.Inlist<Dummy.Numberwrapper>();
lst.Append(a);
lst.Append(b);
lst.Append(c);
int i = 0;
- foreach (test.Numberwrapper e in lst)
+ foreach (Dummy.Numberwrapper e in lst)
{
Test.AssertEquals(cmp[i].GetNumber(), e.GetNumber());
- Test.Assert(cmp[i].raw_handle == e.raw_handle);
+ Test.Assert(cmp[i].NativeHandle == e.NativeHandle);
++i;
}
}
public static void test_eina_inlist_int_in()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.Inlist<int>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.Inlist<int>();
lst.AppendArray(base_seq_int);
Test.Assert(t.EinaInlistIntIn(lst));
Test.Assert(lst.Own);
public static void test_eina_inlist_int_in_own()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.Inlist<int>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.Inlist<int>();
lst.AppendArray(base_seq_int);
Test.Assert(t.EinaInlistIntInOwn(lst));
Test.Assert(!lst.Own);
public static void test_eina_inlist_int_out()
{
- test.ITesting t = new test.Testing();
- eina.Inlist<int> lst;
+ var t = new Dummy.TestObject();
+ Eina.Inlist<int> lst;
Test.Assert(t.EinaInlistIntOut(out lst));
Test.Assert(!lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_inlist_int_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Inlist<int> lst;
+ var t = new Dummy.TestObject();
+ Eina.Inlist<int> lst;
Test.Assert(t.EinaInlistIntOutOwn(out lst));
Test.Assert(lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_inlist_int_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaInlistIntReturn();
Test.Assert(!lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
public static void test_eina_inlist_int_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaInlistIntReturnOwn();
Test.Assert(lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
// String //
public static void test_eina_inlist_str_in()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.Inlist<string>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.Inlist<string>();
lst.AppendArray(base_seq_str);
Test.Assert(t.EinaInlistStrIn(lst));
Test.Assert(lst.Own);
public static void test_eina_inlist_str_in_own()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.Inlist<string>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.Inlist<string>();
lst.AppendArray(base_seq_str);
Test.Assert(t.EinaInlistStrInOwn(lst));
Test.Assert(!lst.Own);
public static void test_eina_inlist_str_out()
{
- test.ITesting t = new test.Testing();
- eina.Inlist<string> lst;
+ var t = new Dummy.TestObject();
+ Eina.Inlist<string> lst;
Test.Assert(t.EinaInlistStrOut(out lst));
Test.Assert(!lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_inlist_str_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Inlist<string> lst;
+ var t = new Dummy.TestObject();
+ Eina.Inlist<string> lst;
Test.Assert(t.EinaInlistStrOutOwn(out lst));
Test.Assert(lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_inlist_str_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaInlistStrReturn();
Test.Assert(!lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_inlist_str_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaInlistStrReturnOwn();
Test.Assert(lst.Own);
Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
public static void test_eina_inlist_obj_in()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.Inlist<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.Inlist<Dummy.Numberwrapper>();
lst.AppendArray(BaseSeqObj());
Test.Assert(t.EinaInlistObjIn(lst));
Test.Assert(lst.Own);
public static void test_eina_inlist_obj_in_own()
{
- test.ITesting t = new test.Testing();
- var lst = new eina.Inlist<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var lst = new Eina.Inlist<Dummy.Numberwrapper>();
lst.AppendArray(BaseSeqObj());
Test.Assert(t.EinaInlistObjInOwn(lst));
Test.Assert(!lst.Own);
public static void test_eina_inlist_obj_out()
{
- test.ITesting t = new test.Testing();
- eina.Inlist<test.INumberwrapper> lst;
+ var t = new Dummy.TestObject();
+ Eina.Inlist<Dummy.Numberwrapper> lst;
Test.Assert(t.EinaInlistObjOut(out lst));
Test.Assert(!lst.Own);
NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
public static void test_eina_inlist_obj_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Inlist<test.INumberwrapper> lst;
+ var t = new Dummy.TestObject();
+ Eina.Inlist<Dummy.Numberwrapper> lst;
Test.Assert(t.EinaInlistObjOutOwn(out lst));
Test.Assert(lst.Own);
NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
public static void test_eina_inlist_obj_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaInlistObjReturn();
Test.Assert(!lst.Own);
NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
public static void test_eina_inlist_obj_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var lst = t.EinaInlistObjReturnOwn();
Test.Assert(lst.Own);
NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
public static void test_eina_inlist_obj_return_in_same_id()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var cmp = BaseSeqObj();
- var a = new eina.Inlist<test.INumberwrapper>();
+ var a = new Eina.Inlist<Dummy.Numberwrapper>();
a.AppendArray(cmp);
var b = t.EinaInlistObjReturnIn(a);
NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
int len = a.Length;
for (int i=0; i < len; ++i)
{
- Test.Assert(a[i].raw_handle == b[i].raw_handle);
- Test.Assert(a[i].raw_handle == cmp[i].raw_handle);
+ Test.Assert(a[i].NativeHandle == b[i].NativeHandle);
+ Test.Assert(a[i].NativeHandle == cmp[i].NativeHandle);
}
}
} // < TestEinaInlist
{
public static void data_set_int()
{
- var hsh = new eina.Hash<int, int>();
+ var hsh = new Eina.Hash<int, int>();
Test.Assert(hsh.Count == 0);
hsh[88] = 888;
public static void data_set_str()
{
- var hsh = new eina.Hash<string, string>();
+ var hsh = new Eina.Hash<string, string>();
Test.Assert(hsh.Count == 0);
hsh["aa"] = "aaa";
public static void data_set_obj()
{
- var hsh = new eina.Hash<test.INumberwrapper, test.INumberwrapper>();
+ var hsh = new Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper>();
Test.Assert(hsh.Count == 0);
var a = NW(22);
var cc = NW(888);
hsh[a] = aa;
- Test.Assert(hsh[a].raw_handle == aa.raw_handle);
+ Test.Assert(hsh[a].NativeHandle == aa.NativeHandle);
Test.Assert(hsh[a].GetNumber() == aa.GetNumber());
Test.Assert(hsh.Count == 1);
hsh[b] = bb;
- Test.Assert(hsh[b].raw_handle == bb.raw_handle);
+ Test.Assert(hsh[b].NativeHandle == bb.NativeHandle);
Test.Assert(hsh[b].GetNumber() == bb.GetNumber());
Test.Assert(hsh.Count == 2);
hsh[c] = cc;
- Test.Assert(hsh[c].raw_handle == cc.raw_handle);
+ Test.Assert(hsh[c].NativeHandle == cc.NativeHandle);
Test.Assert(hsh[c].GetNumber() == cc.GetNumber());
Test.Assert(hsh.Count == 3);
public static void eina_hash_as_ienumerable_int()
{
- var hsh = new eina.Hash<int, int>();
+ var hsh = new Eina.Hash<int, int>();
var dct = new Dictionary<int, int>();
hsh[88] = 888;
public static void eina_hash_as_ienumerable_str()
{
- var hsh = new eina.Hash<string, string>();
+ var hsh = new Eina.Hash<string, string>();
var dct = new Dictionary<string, string>();
hsh["aa"] = "aaa";
public static void eina_hash_as_ienumerable_obj()
{
- var hsh = new eina.Hash<test.INumberwrapper, test.INumberwrapper>();
- var dct = new Dictionary<int, test.INumberwrapper>();
+ var hsh = new Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper>();
+ var dct = new Dictionary<int, Dummy.Numberwrapper>();
var a = NW(22);
var aa = NW(222);
int count = 0;
- foreach (KeyValuePair<test.INumberwrapper, test.INumberwrapper> kvp in hsh)
+ foreach (KeyValuePair<Dummy.Numberwrapper, Dummy.Numberwrapper> kvp in hsh)
{
- Test.Assert(dct[kvp.Key.GetNumber()].raw_handle == kvp.Value.raw_handle);
+ Test.Assert(dct[kvp.Key.GetNumber()].NativeHandle == kvp.Value.NativeHandle);
Test.Assert(dct[kvp.Key.GetNumber()].GetNumber() == kvp.Value.GetNumber());
dct.Remove(kvp.Key.GetNumber());
++count;
public static void test_eina_hash_int_in()
{
- test.ITesting t = new test.Testing();
- var hsh = new eina.Hash<int,int>();
+ var t = new Dummy.TestObject();
+ var hsh = new Eina.Hash<int,int>();
hsh[22] = 222;
Test.Assert(t.EinaHashIntIn(hsh));
Test.Assert(hsh.Own);
public static void test_eina_hash_int_in_own()
{
- test.ITesting t = new test.Testing();
- var hsh = new eina.Hash<int,int>();
+ var t = new Dummy.TestObject();
+ var hsh = new Eina.Hash<int,int>();
hsh[22] = 222;
Test.Assert(t.EinaHashIntInOwn(hsh));
Test.Assert(!hsh.Own);
public static void test_eina_hash_int_out()
{
- test.ITesting t = new test.Testing();
- eina.Hash<int,int> hsh;
+ var t = new Dummy.TestObject();
+ Eina.Hash<int,int> hsh;
Test.Assert(t.EinaHashIntOut(out hsh));
Test.Assert(!hsh.Own);
Test.Assert(hsh[22] == 222);
public static void test_eina_hash_int_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Hash<int,int> hsh;
+ var t = new Dummy.TestObject();
+ Eina.Hash<int,int> hsh;
Test.Assert(t.EinaHashIntOutOwn(out hsh));
Test.Assert(hsh.Own);
Test.Assert(hsh[22] == 222);
public static void test_eina_hash_int_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var hsh = t.EinaHashIntReturn();
Test.Assert(!hsh.Own);
Test.Assert(hsh[22] == 222);
public static void test_eina_hash_int_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var hsh = t.EinaHashIntReturnOwn();
Test.Assert(hsh.Own);
Test.Assert(hsh[22] == 222);
public static void test_eina_hash_str_in()
{
- test.ITesting t = new test.Testing();
- var hsh = new eina.Hash<string,string>();
+ var t = new Dummy.TestObject();
+ var hsh = new Eina.Hash<string,string>();
hsh["aa"] = "aaa";
Test.Assert(t.EinaHashStrIn(hsh));
Test.Assert(hsh.Own);
public static void test_eina_hash_str_in_own()
{
- test.ITesting t = new test.Testing();
- var hsh = new eina.Hash<string,string>();
+ var t = new Dummy.TestObject();
+ var hsh = new Eina.Hash<string,string>();
hsh["aa"] = "aaa";
Test.Assert(t.EinaHashStrInOwn(hsh));
Test.Assert(!hsh.Own);
public static void test_eina_hash_str_out()
{
- test.ITesting t = new test.Testing();
- eina.Hash<string,string> hsh;
+ var t = new Dummy.TestObject();
+ Eina.Hash<string,string> hsh;
Test.Assert(t.EinaHashStrOut(out hsh));
Test.Assert(!hsh.Own);
Test.Assert(hsh["aa"] == "aaa");
public static void test_eina_hash_str_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Hash<string,string> hsh;
+ var t = new Dummy.TestObject();
+ Eina.Hash<string,string> hsh;
Test.Assert(t.EinaHashStrOutOwn(out hsh));
Test.Assert(hsh.Own);
Test.Assert(hsh["aa"] == "aaa");
public static void test_eina_hash_str_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var hsh = t.EinaHashStrReturn();
Test.Assert(!hsh.Own);
Test.Assert(hsh["aa"] == "aaa");
public static void test_eina_hash_str_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var hsh = t.EinaHashStrReturnOwn();
Test.Assert(hsh.Own);
Test.Assert(hsh["aa"] == "aaa");
public static void test_eina_hash_obj_in()
{
- test.ITesting t = new test.Testing();
- var hsh = new eina.Hash<test.INumberwrapper, test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var hsh = new Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper>();
var nwk1 = NW(22);
var nwv1 = NW(222);
hsh[nwk1] = nwv1;
- test.INumberwrapper nwk2;
- test.INumberwrapper nwv2;
+ Dummy.Numberwrapper nwk2;
+ Dummy.Numberwrapper nwv2;
Test.Assert(t.EinaHashObjIn(hsh, nwk1, nwv1, out nwk2, out nwv2));
Test.Assert(hsh.Own);
- Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].NativeHandle == nwv1.NativeHandle);
Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
Test.Assert(hsh[nwk1].GetNumber() == 222);
- Test.Assert(hsh[nwk2].raw_handle == nwv2.raw_handle);
+ Test.Assert(hsh[nwk2].NativeHandle == nwv2.NativeHandle);
Test.Assert(hsh[nwk2].GetNumber() == nwv2.GetNumber());
Test.Assert(hsh[nwk2].GetNumber() == 444);
hsh.Dispose();
public static void test_eina_hash_obj_in_own()
{
- test.ITesting t = new test.Testing();
- var hsh = new eina.Hash<test.INumberwrapper, test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var hsh = new Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper>();
var nwk1 = NW(22);
var nwv1 = NW(222);
hsh[nwk1] = nwv1;
- test.INumberwrapper nwk2;
- test.INumberwrapper nwv2;
+ Dummy.Numberwrapper nwk2;
+ Dummy.Numberwrapper nwv2;
Test.Assert(t.EinaHashObjInOwn(hsh, nwk1, nwv1, out nwk2, out nwv2));
Test.Assert(!hsh.Own);
- Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].NativeHandle == nwv1.NativeHandle);
Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
Test.Assert(hsh[nwk1].GetNumber() == 222);
- Test.Assert(hsh[nwk2].raw_handle == nwv2.raw_handle);
+ Test.Assert(hsh[nwk2].NativeHandle == nwv2.NativeHandle);
Test.Assert(hsh[nwk2].GetNumber() == nwv2.GetNumber());
Test.Assert(hsh[nwk2].GetNumber() == 444);
hsh.Dispose();
public static void test_eina_hash_obj_out()
{
- test.ITesting t = new test.Testing();
- eina.Hash<test.INumberwrapper, test.INumberwrapper> hsh;
- test.INumberwrapper nwk1;
- test.INumberwrapper nwv1;
+ var t = new Dummy.TestObject();
+ Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper> hsh;
+ Dummy.Numberwrapper nwk1;
+ Dummy.Numberwrapper nwv1;
Test.Assert(t.EinaHashObjOut(out hsh, out nwk1, out nwv1));
Test.Assert(!hsh.Own);
- Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].NativeHandle == nwv1.NativeHandle);
Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
Test.Assert(hsh[nwk1].GetNumber() == 222);
- test.INumberwrapper nwk2 = NW(44);
- test.INumberwrapper nwv2 = NW(444);
+ Dummy.Numberwrapper nwk2 = NW(44);
+ Dummy.Numberwrapper nwv2 = NW(444);
hsh[nwk2] = nwv2;
hsh.Dispose();
Test.Assert(hsh.Handle == IntPtr.Zero);
public static void test_eina_hash_obj_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Hash<test.INumberwrapper, test.INumberwrapper> hsh;
- test.INumberwrapper nwk1;
- test.INumberwrapper nwv1;
+ var t = new Dummy.TestObject();
+ Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper> hsh;
+ Dummy.Numberwrapper nwk1;
+ Dummy.Numberwrapper nwv1;
Test.Assert(t.EinaHashObjOutOwn(out hsh, out nwk1, out nwv1));
Test.Assert(hsh.Own);
- Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].NativeHandle == nwv1.NativeHandle);
Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
Test.Assert(hsh[nwk1].GetNumber() == 222);
- test.INumberwrapper nwk2 = NW(44);
- test.INumberwrapper nwv2 = NW(444);
+ Dummy.Numberwrapper nwk2 = NW(44);
+ Dummy.Numberwrapper nwv2 = NW(444);
hsh[nwk2] = nwv2;
hsh.Dispose();
Test.Assert(hsh.Handle == IntPtr.Zero);
public static void test_eina_hash_obj_return()
{
- test.ITesting t = new test.Testing();
- test.INumberwrapper nwk1;
- test.INumberwrapper nwv1;
+ var t = new Dummy.TestObject();
+ Dummy.Numberwrapper nwk1;
+ Dummy.Numberwrapper nwv1;
var hsh = t.EinaHashObjReturn(out nwk1, out nwv1);
Test.Assert(!hsh.Own);
- Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].NativeHandle == nwv1.NativeHandle);
Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
Test.Assert(hsh[nwk1].GetNumber() == 222);
- test.INumberwrapper nwk2 = NW(44);
- test.INumberwrapper nwv2 = NW(444);
+ Dummy.Numberwrapper nwk2 = NW(44);
+ Dummy.Numberwrapper nwv2 = NW(444);
hsh[nwk2] = nwv2;
hsh.Dispose();
Test.Assert(hsh.Handle == IntPtr.Zero);
public static void test_eina_hash_obj_return_own()
{
- test.ITesting t = new test.Testing();
- test.INumberwrapper nwk1;
- test.INumberwrapper nwv1;
+ var t = new Dummy.TestObject();
+ Dummy.Numberwrapper nwk1;
+ Dummy.Numberwrapper nwv1;
var hsh = t.EinaHashObjReturnOwn(out nwk1, out nwv1);
Test.Assert(hsh.Own);
- Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].NativeHandle == nwv1.NativeHandle);
Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
Test.Assert(hsh[nwk1].GetNumber() == 222);
- test.INumberwrapper nwk2 = NW(44);
- test.INumberwrapper nwv2 = NW(444);
+ Dummy.Numberwrapper nwk2 = NW(44);
+ Dummy.Numberwrapper nwv2 = NW(444);
hsh[nwk2] = nwv2;
hsh.Dispose();
Test.Assert(hsh.Handle == IntPtr.Zero);
public static void eina_array_int_empty_iterator()
{
- var arr = new eina.Array<int>();
+ var arr = new Eina.Array<int>();
var itr = arr.GetIterator();
int idx = 0;
foreach (int e in itr)
public static void eina_array_int_filled_iterator()
{
- var arr = new eina.Array<int>();
+ var arr = new Eina.Array<int>();
arr.Append(base_seq_int);
var itr = arr.GetIterator();
int idx = 0;
public static void eina_array_str_empty_iterator()
{
- var arr = new eina.Array<string>();
+ var arr = new Eina.Array<string>();
var itr = arr.GetIterator();
int idx = 0;
foreach (string e in itr)
public static void eina_array_str_filled_iterator()
{
- var arr = new eina.Array<string>();
+ var arr = new Eina.Array<string>();
arr.Append(base_seq_str);
var itr = arr.GetIterator();
int idx = 0;
public static void eina_array_obj_empty_iterator()
{
- var arr = new eina.Array<test.INumberwrapper>();
+ var arr = new Eina.Array<Dummy.Numberwrapper>();
var itr = arr.GetIterator();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
++idx;
}
public static void eina_array_obj_filled_iterator()
{
- var arr = new eina.Array<test.INumberwrapper>();
+ var arr = new Eina.Array<Dummy.Numberwrapper>();
var base_objs = BaseSeqObj();
arr.Append(base_objs);
var itr = arr.GetIterator();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
- Test.Assert(e.raw_handle == base_objs[idx].raw_handle);
+ Test.Assert(e.NativeHandle == base_objs[idx].NativeHandle);
Test.Assert(e.GetNumber() == base_objs[idx].GetNumber());
++idx;
}
public static void eina_inarray_int_empty_iterator()
{
- var arr = new eina.Inarray<int>();
+ var arr = new Eina.Inarray<int>();
var itr = arr.GetIterator();
int idx = 0;
foreach (int e in itr)
public static void eina_inarray_int_filled_iterator()
{
- var arr = new eina.Inarray<int>();
+ var arr = new Eina.Inarray<int>();
arr.Append(base_seq_int);
var itr = arr.GetIterator();
int idx = 0;
public static void eina_list_int_empty_iterator()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
var itr = lst.GetIterator();
int idx = 0;
foreach (int e in itr)
public static void eina_list_int_filled_iterator()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
lst.AppendArray(base_seq_int);
var itr = lst.GetIterator();
int idx = 0;
public static void eina_list_str_empty_iterator()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
var itr = lst.GetIterator();
int idx = 0;
foreach (string e in itr)
public static void eina_list_str_filled_iterator()
{
- var lst = new eina.List<string>();
+ var lst = new Eina.List<string>();
lst.AppendArray(base_seq_str);
var itr = lst.GetIterator();
int idx = 0;
public static void eina_list_obj_empty_iterator()
{
- var lst = new eina.List<test.INumberwrapper>();
+ var lst = new Eina.List<Dummy.Numberwrapper>();
var itr = lst.GetIterator();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
++idx;
}
public static void eina_list_obj_filled_iterator()
{
- var lst = new eina.List<test.INumberwrapper>();
+ var lst = new Eina.List<Dummy.Numberwrapper>();
var base_objs = BaseSeqObj();
lst.AppendArray(base_objs);
var itr = lst.GetIterator();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
- Test.Assert(e.raw_handle == base_objs[idx].raw_handle);
+ Test.Assert(e.NativeHandle == base_objs[idx].NativeHandle);
Test.Assert(e.GetNumber() == base_objs[idx].GetNumber());
++idx;
}
public static void eina_inlist_int_empty_iterator()
{
- var lst = new eina.Inlist<int>();
+ var lst = new Eina.Inlist<int>();
var itr = lst.GetIterator();
int idx = 0;
foreach (int e in itr)
public static void eina_inlist_int_filled_iterator()
{
- var lst = new eina.Inlist<int>();
+ var lst = new Eina.Inlist<int>();
lst.AppendArray(base_seq_int);
var itr = lst.GetIterator();
int idx = 0;
public static void eina_hash_keys_int_empty_iterator()
{
- var hsh = new eina.Hash<int, int>();
+ var hsh = new Eina.Hash<int, int>();
var itr = hsh.Keys();
bool entered = false;
foreach (int e in itr)
public static void eina_hash_values_int_empty_iterator()
{
- var hsh = new eina.Hash<int, int>();
+ var hsh = new Eina.Hash<int, int>();
var itr = hsh.Values();
bool entered = false;
foreach (int e in itr)
public static void eina_hash_keys_int_filled_iterator()
{
- var hsh = new eina.Hash<int, int>();
+ var hsh = new Eina.Hash<int, int>();
var dct = new Dictionary<int, bool>();
hsh[22] = 222;
hsh[44] = 444;
public static void eina_hash_values_int_filled_iterator()
{
- var hsh = new eina.Hash<int, int>();
+ var hsh = new Eina.Hash<int, int>();
var dct = new Dictionary<int, bool>();
hsh[22] = 222;
hsh[44] = 444;
public static void eina_hash_keys_str_empty_iterator()
{
- var hsh = new eina.Hash<string, string>();
+ var hsh = new Eina.Hash<string, string>();
var itr = hsh.Keys();
bool entered = false;
foreach (string e in itr)
public static void eina_hash_values_str_empty_iterator()
{
- var hsh = new eina.Hash<string, string>();
+ var hsh = new Eina.Hash<string, string>();
var itr = hsh.Values();
bool entered = false;
foreach (string e in itr)
public static void eina_hash_keys_str_filled_iterator()
{
- var hsh = new eina.Hash<string, string>();
+ var hsh = new Eina.Hash<string, string>();
var dct = new Dictionary<string, bool>();
hsh["aa"] = "aaa";
hsh["bb"] = "bbb";
public static void eina_hash_values_str_filled_iterator()
{
- var hsh = new eina.Hash<string, string>();
+ var hsh = new Eina.Hash<string, string>();
var dct = new Dictionary<string, bool>();
hsh["aa"] = "aaa";
hsh["bb"] = "bbb";
public static void eina_hash_keys_obj_empty_iterator()
{
- var hsh = new eina.Hash<test.INumberwrapper, test.INumberwrapper>();
+ var hsh = new Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper>();
var itr = hsh.Keys();
bool entered = false;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
entered = true;
}
public static void eina_hash_values_obj_empty_iterator()
{
- var hsh = new eina.Hash<test.INumberwrapper, test.INumberwrapper>();
+ var hsh = new Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper>();
var itr = hsh.Values();
bool entered = false;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
entered = true;
}
public static void eina_hash_keys_obj_filled_iterator()
{
- var hsh = new eina.Hash<test.INumberwrapper, test.INumberwrapper>();
- var dct = new eina.Hash<int, test.INumberwrapper>();
+ var hsh = new Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper>();
+ var dct = new Eina.Hash<int, Dummy.Numberwrapper>();
var a = NW(22);
var b = NW(44);
var c = NW(88);
var itr = hsh.Keys();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
Test.Assert(dct[e.GetNumber()] != null);
- Test.Assert(dct[e.GetNumber()].raw_handle == e.raw_handle);
+ Test.Assert(dct[e.GetNumber()].NativeHandle == e.NativeHandle);
Test.Assert(dct[e.GetNumber()].GetNumber() == e.GetNumber());
dct.Remove(e.GetNumber());
++idx;
public static void eina_hash_values_obj_filled_iterator()
{
- var hsh = new eina.Hash<test.INumberwrapper, test.INumberwrapper>();
- var dct = new eina.Hash<int, test.INumberwrapper>();
+ var hsh = new Eina.Hash<Dummy.Numberwrapper, Dummy.Numberwrapper>();
+ var dct = new Eina.Hash<int, Dummy.Numberwrapper>();
var a = NW(22);
var b = NW(44);
var c = NW(88);
var itr = hsh.Values();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
Test.Assert(dct[e.GetNumber()] != null);
- Test.Assert(dct[e.GetNumber()].raw_handle == e.raw_handle);
+ Test.Assert(dct[e.GetNumber()].NativeHandle == e.NativeHandle);
Test.Assert(dct[e.GetNumber()].GetNumber() == e.GetNumber());
dct.Remove(e.GetNumber());
++idx;
public static void test_eina_iterator_int_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<int>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<int>();
arr.Append(base_seq_int);
var itr = arr.GetIterator();
public static void test_eina_iterator_int_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<int>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<int>();
arr.Append(base_seq_int);
var itr = arr.GetIterator();
arr.OwnContent = false;
public static void test_eina_iterator_int_out()
{
- test.ITesting t = new test.Testing();
- eina.Iterator<int> itr;
+ var t = new Dummy.TestObject();
+ Eina.Iterator<int> itr;
Test.Assert(t.EinaIteratorIntOut(out itr));
public static void test_eina_iterator_int_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Iterator<int> itr;
+ var t = new Dummy.TestObject();
+ Eina.Iterator<int> itr;
Test.Assert(t.EinaIteratorIntOutOwn(out itr));
public static void test_eina_iterator_int_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var itr = t.EinaIteratorIntReturn();
public static void test_eina_iterator_int_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var itr = t.EinaIteratorIntReturnOwn();
public static void test_eina_iterator_str_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<string>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<string>();
arr.Append(base_seq_str);
var itr = arr.GetIterator();
public static void test_eina_iterator_str_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<string>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<string>();
arr.Append(base_seq_str);
var itr = arr.GetIterator();
arr.OwnContent = false;
public static void test_eina_iterator_str_out()
{
- test.ITesting t = new test.Testing();
- eina.Iterator<string> itr;
+ var t = new Dummy.TestObject();
+ Eina.Iterator<string> itr;
Test.Assert(t.EinaIteratorStrOut(out itr));
public static void test_eina_iterator_str_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Iterator<string> itr;
+ var t = new Dummy.TestObject();
+ Eina.Iterator<string> itr;
Test.Assert(t.EinaIteratorStrOutOwn(out itr));
public static void test_eina_iterator_str_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var itr = t.EinaIteratorStrReturn();
public static void test_eina_iterator_str_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var itr = t.EinaIteratorStrReturnOwn();
public static void test_eina_iterator_obj_in()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<Dummy.Numberwrapper>();
arr.Append(BaseSeqObj());
var itr = arr.GetIterator();
public static void test_eina_iterator_obj_in_own()
{
- test.ITesting t = new test.Testing();
- var arr = new eina.Array<test.INumberwrapper>();
+ var t = new Dummy.TestObject();
+ var arr = new Eina.Array<Dummy.Numberwrapper>();
arr.Append(BaseSeqObj());
var itr = arr.GetIterator();
arr.OwnContent = false;
public static void test_eina_iterator_obj_out()
{
- test.ITesting t = new test.Testing();
- eina.Iterator<test.INumberwrapper> itr;
+ var t = new Dummy.TestObject();
+ Eina.Iterator<Dummy.Numberwrapper> itr;
Test.Assert(t.EinaIteratorObjOut(out itr));
var base_seq_obj = BaseSeqObj();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
Test.AssertEquals(e.GetNumber(), base_seq_obj[idx].GetNumber());
++idx;
public static void test_eina_iterator_obj_out_own()
{
- test.ITesting t = new test.Testing();
- eina.Iterator<test.INumberwrapper> itr;
+ var t = new Dummy.TestObject();
+ Eina.Iterator<Dummy.Numberwrapper> itr;
Test.Assert(t.EinaIteratorObjOutOwn(out itr));
var base_seq_obj = BaseSeqObj();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
Test.AssertEquals(e.GetNumber(), base_seq_obj[idx].GetNumber());
++idx;
public static void test_eina_iterator_obj_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var itr = t.EinaIteratorObjReturn();
var base_seq_obj = BaseSeqObj();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
Test.AssertEquals(e.GetNumber(), base_seq_obj[idx].GetNumber());
++idx;
public static void test_eina_iterator_obj_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var itr = t.EinaIteratorObjReturnOwn();
var base_seq_obj = BaseSeqObj();
int idx = 0;
- foreach (test.INumberwrapper e in itr)
+ foreach (Dummy.Numberwrapper e in itr)
{
Test.AssertEquals(e.GetNumber(), base_seq_obj[idx].GetNumber());
++idx;
{
public static void basic_accessor_list()
{
- var lst = new eina.List<int>();
+ var lst = new Eina.List<int>();
lst.Append(1);
lst.Append(2);
lst.Append(3);
lst.Append(4);
- eina.Accessor<int> accessor = lst.GetAccessor();
+ Eina.Accessor<int> accessor = lst.GetAccessor();
var zipped = accessor.Zip(lst, (first, second) => new Tuple<int, int>(first, second));
public static void basic_accessor_array()
{
- var arr = new eina.Array<string>();
+ var arr = new Eina.Array<string>();
arr.Append(base_seq_str);
- eina.Accessor<string> accessor = arr.GetAccessor();
+ Eina.Accessor<string> accessor = arr.GetAccessor();
var zipped = accessor.Zip(arr, (first, second) => new Tuple<string, string>(first, second));
public static void basic_accessor_inlist()
{
- var lst = new eina.Inlist<int>();
+ var lst = new Eina.Inlist<int>();
lst.Append(1);
lst.Append(2);
lst.Append(3);
lst.Append(4);
- eina.Accessor<int> accessor = lst.GetAccessor();
+ Eina.Accessor<int> accessor = lst.GetAccessor();
var zipped = accessor.Zip(lst, (first, second) => new Tuple<int, int>(first, second));
public static void basic_accessor_inarray()
{
- var arr = new eina.Inarray<int>();
+ var arr = new Eina.Inarray<int>();
arr.Append(base_seq_int);
- eina.Accessor<int> accessor = arr.GetAccessor();
+ Eina.Accessor<int> accessor = arr.GetAccessor();
var zipped = accessor.Zip(arr, (first, second) => new Tuple<int, int>(first, second));
class TestEo
{
- private class Derived : test.TestingInherit
+ private class Derived : Dummy.TestObject
{
}
//
public static void return_same_object()
{
- test.ITesting testing = new test.Testing();
- test.ITesting o1 = testing.ReturnObject();
- Test.Assert(o1.raw_handle != IntPtr.Zero);
- Test.Assert(o1.raw_handle == testing.raw_handle);
- test.ITesting o2 = o1.ReturnObject();
- Test.Assert(o2.raw_handle != IntPtr.Zero);
- Test.Assert(o2.raw_handle == o1.raw_handle);
+ var testing = new Dummy.TestObject();
+ var o1 = testing.ReturnObject();
+ Test.Assert(o1.NativeHandle != IntPtr.Zero);
+ Test.Assert(o1.NativeHandle == testing.NativeHandle);
+ var o2 = o1.ReturnObject();
+ Test.Assert(o2.NativeHandle != IntPtr.Zero);
+ Test.Assert(o2.NativeHandle == o1.NativeHandle);
}
-
/* Commented out as adding the event listener seems to prevent it from being GC'd.
public static void destructor_really_frees()
{
bool delEventCalled = false;
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
obj.DEL += (object sender, EventArgs e) => { delEventCalled = true; };
}
{
bool delEventCalled = false;
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
+ Eina.Log.Error($"Created object 0x{obj.NativeHandle.ToInt64():x}");
obj.DelEvt += (object sender, EventArgs e) => { delEventCalled = true; };
+ Eina.Log.Error($"Will dispose object 0x{obj.NativeHandle.ToInt64():x}");
((IDisposable)obj).Dispose();
}
{
bool delEventCalled = false;
{
- test.ITesting obj = new Derived();
+ var obj = new Derived();
obj.DEL += (object sender, EventArgs e) => { delEventCalled = true; };
}
{
bool delEventCalled = false;
{
- test.ITesting obj = new Derived();
+ var obj = new Derived();
obj.DEL += (object sender, EventArgs e) => { delEventCalled = true; };
((IDisposable)obj).Dispose();
}
*/
}
-class MyLoop : efl.LoopInherit
+
+class MyLoop : Efl.Loop
{
public MyLoop() : base(null) { }
}
{
public static void instantiate_inherited()
{
- efl.ILoop loop = new MyLoop();
- Test.Assert(loop.raw_handle != System.IntPtr.Zero);
+ Efl.Loop loop = new MyLoop();
+ Test.Assert(loop.NativeHandle != System.IntPtr.Zero);
}
}
{
public static void name_getset()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
string name = "Dummy";
obj.SetName(name);
{
bool called = false;
string name = "Test object";
- test.ITesting obj = new test.Testing(null, (test.ITesting a) => {
+ var obj = new Dummy.TestObject(null, (Dummy.TestObject a) => {
called = true;
- Console.WriteLine("callback: obj raw_handle: {0:x}", a.raw_handle);
+ Console.WriteLine("callback: obj NativeHandle: {0:x}", a.NativeHandle);
a.SetName(name);
});
Test.AssertEquals(name, obj.GetName());
}
- private class Derived : test.TestingInherit
+ private class Derived : Dummy.TestObject
{
- public Derived(test.ITesting parent = null,
- test.TestingInherit.ConstructingMethod cb = null) : base(parent, cb) {
+ public Derived(Dummy.TestObject parent = null,
+ Dummy.TestObject.ConstructingMethod cb = null) : base(parent, cb) {
}
}
{
bool called = false;
string name = "Another test object";
- Derived obj = new Derived(null, (test.ITesting a) => {
+ Derived obj = new Derived(null, (Dummy.TestObject a) => {
called = true;
a.SetComment(name);
});
{
public static void basic_parent()
{
- test.ITesting parent = new test.Testing(null);
- test.ITesting child = new test.Testing(parent);
+ var parent = new Dummy.TestObject(null);
+ var child = new Dummy.TestObject(parent);
Test.AssertEquals(parent, child.GetParent());
- test.ITesting parent_retrieved = test.Testing.static_cast(child.GetParent());
+ var parent_retrieved = Dummy.TestObject.static_cast(child.GetParent());
Test.AssertEquals(parent, parent_retrieved);
}
public static void parent_inherited_class()
{
- test.INumberwrapper parent = new test.Numberwrapper(null);
- test.ITesting child = new test.Testing(parent);
+ Dummy.Numberwrapper parent = new Dummy.Numberwrapper(null);
+ var child = new Dummy.TestObject(parent);
Test.AssertEquals(parent, child.GetParent());
- test.INumberwrapper parent_retrieved = test.Numberwrapper.static_cast(child.GetParent());
+ Dummy.Numberwrapper parent_retrieved = Dummy.Numberwrapper.static_cast(child.GetParent());
Test.AssertEquals(parent, parent_retrieved);
}
- private class Derived : test.TestingInherit
+ private class Derived : Dummy.TestObject
{
- public Derived(test.ITesting parent = null) : base (parent)
+ public Derived(Dummy.TestObject parent = null) : base (parent)
{
}
}
public static void basic_parent_managed_inherit()
{
- test.ITesting parent = new Derived(null);
- test.ITesting child = new Derived(parent);
+ var parent = new Derived(null);
+ var child = new Derived(parent);
Test.AssertEquals(parent, child.GetParent());
- test.ITesting parent_from_cast = test.Testing.static_cast(child.GetParent());
+ var parent_from_cast = Dummy.TestObject.static_cast(child.GetParent());
Test.AssertEquals(parent, parent_from_cast);
}
}
public static void basic_class_method()
{
int reference = 0xbeef;
- test.Testing.SetKlassProp(reference);
- Test.AssertEquals(reference, test.Testing.GetKlassProp());
+ Dummy.TestObject.SetKlassProp(reference);
+ Test.AssertEquals(reference, Dummy.TestObject.GetKlassProp());
}
public static void inherited_class_method()
{
int reference = 0xdead;
- test.Child.SetKlassProp(reference);
- Test.AssertEquals(reference, test.Child.GetKlassProp());
+ Dummy.Child.SetKlassProp(reference);
+ Test.AssertEquals(reference, Dummy.Child.GetKlassProp());
}
}
{
public static void basic_typedef_test()
{
- test.ITesting obj = new test.Testing();
- test.MyInt input = 1900;
- test.MyInt receiver;
+ var obj = new Dummy.TestObject();
+ Dummy.MyInt input = 1900;
+ Dummy.MyInt receiver;
int ret = obj.BypassTypedef(input, out receiver);
- Test.AssertEquals((test.MyInt)ret, input);
+ Test.AssertEquals((Dummy.MyInt)ret, input);
Test.AssertEquals(receiver, input);
}
{
public static void basic_eo_accessors()
{
- test.ITesting obj = new test.Testing();
- eina.List<int> lst = new eina.List<int>();
+ var obj = new Dummy.TestObject();
+ Eina.List<int> lst = new Eina.List<int>();
lst.Append(4);
lst.Append(3);
lst.Append(2);
lst.Append(5);
- eina.Accessor<int> acc = obj.CloneAccessor(lst.GetAccessor());
+ Eina.Accessor<int> acc = obj.CloneAccessor(lst.GetAccessor());
var zipped = acc.Zip(lst, (first, second) => new Tuple<int, int>(first, second));
class TestEoFinalize
{
- public sealed class Inherit : efl.ObjectInherit
+ public sealed class Inherit : Efl.Object
{
public bool finalizeCalled = false;
- public override efl.IObject FinalizeAdd()
+ public override Efl.Object FinalizeAdd()
{
finalizeCalled = true;
return this;
}
}
+class TestEoMultipleChildClasses
+{
+
+ public sealed class FirstChild : Efl.Object
+ {
+ public int receivedValue = 0;
+ public override Efl.Object FinalizeAdd()
+ {
+ receivedValue = 1;
+ return this;
+ }
+ }
+
+ public sealed class SecondChild : Efl.Object
+ {
+ public int receivedValue = 0;
+ public override Efl.Object FinalizeAdd()
+ {
+ receivedValue = 2;
+ return this;
+ }
+ }
+
+ public static void test_multiple_child_classes()
+ {
+ FirstChild obj = new FirstChild();
+ Test.AssertEquals(1, obj.receivedValue);
+ SecondChild obj2 = new SecondChild();
+ Test.AssertEquals(2, obj2.receivedValue);
+
+ obj = new FirstChild();
+ Test.AssertEquals(1, obj.receivedValue);
+ }
+}
+
}
{
public static void test_simple_task_run()
{
- efl.ILoop loop = efl.App.GetLoopMain();
- eina.Future future = loop.Idle();
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ Eina.Future future = loop.Idle();
bool callbackCalled = false;
int ret_code = 1992;
- future.Then((eina.Value value) => {
+ future.Then((Eina.Value value) => {
callbackCalled = true;
- eina.Value v = new eina.Value(eina.ValueType.Int32);
+ Eina.Value v = new Eina.Value(Eina.ValueType.Int32);
v.Set(ret_code);
loop.Quit(v);
return value;
});
- eina.Value ret_value = loop.Begin();
+ Eina.Value ret_value = loop.Begin();
Test.Assert(callbackCalled, "Future loop callback must have been called.");
- Test.AssertEquals(ret_value.GetValueType(), eina.ValueType.Int32);
+ Test.AssertEquals(ret_value.GetValueType(), Eina.ValueType.Int32);
int ret_from_value;
Test.Assert(ret_value.Get(out ret_from_value));
public static void test_object_promise()
{
- efl.ILoop loop = efl.App.GetLoopMain();
- test.Testing obj = new test.Testing();
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ var obj = new Dummy.TestObject();
- eina.Future future = obj.GetFuture();
+ Eina.Future future = obj.GetFuture();
bool callbackCalled = false;
int receivedValue = -1;
int sentValue = 1984;
- future.Then((eina.Value value) => {
+ future.Then((Eina.Value value) => {
callbackCalled = true;
- Test.AssertEquals(value.GetValueType(), eina.ValueType.Int32);
+ Test.AssertEquals(value.GetValueType(), Eina.ValueType.Int32);
value.Get(out receivedValue);
return value;
public static void test_object_promise_cancel()
{
- efl.ILoop loop = efl.App.GetLoopMain();
- test.Testing obj = new test.Testing();
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ var obj = new Dummy.TestObject();
- eina.Future future = obj.GetFuture();
+ Eina.Future future = obj.GetFuture();
bool callbackCalled = false;
- eina.Error receivedError = -1;
- eina.Error sentError = 120;
- future.Then((eina.Value value) => {
+ Eina.Error receivedError = -1;
+ Eina.Error sentError = 120;
+ future.Then((Eina.Value value) => {
callbackCalled = true;
- Test.AssertEquals(value.GetValueType(), eina.ValueType.Error);
+ Test.AssertEquals(value.GetValueType(), Eina.ValueType.Error);
value.Get(out receivedError);
return value;
class LoopConsumer
{
- public static async Task Consume(efl.ILoop loop)
+ public static async Task Consume(Efl.Loop loop)
{
- Task<eina.Value> task = loop.IdleAsync();
- eina.Value v = await task;
+ Task<Eina.Value> task = loop.IdleAsync();
+ Eina.Value v = await task;
loop.Quit(v);
}
}
{
public static void test_simple_async()
{
- efl.ILoop loop = efl.App.GetLoopMain();
+ Efl.Loop loop = Efl.App.GetLoopMain();
Task t = LoopConsumer.Consume(loop);
loop.Begin();
public static void test_async_fulfill()
{
- efl.ILoop loop = efl.App.GetLoopMain();
- test.ITesting obj = new test.Testing();
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ var obj = new Dummy.TestObject();
- Task<eina.Value> task = obj.GetFutureAsync();
+ Task<Eina.Value> task = obj.GetFutureAsync();
int sentValue = 1337;
obj.FulfillPromise(sentValue);
loop.Iterate();
- eina.Value v = task.Result;
- Test.AssertEquals(v.GetValueType(), eina.ValueType.Int32);
+ Eina.Value v = task.Result;
+ Test.AssertEquals(v.GetValueType(), Eina.ValueType.Int32);
int receivedValue;
v.Get(out receivedValue);
public static void test_async_cancel()
{
- efl.ILoop loop = efl.App.GetLoopMain();
- test.ITesting obj = new test.Testing();
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ var obj = new Dummy.TestObject();
CancellationTokenSource cancelSrc = new CancellationTokenSource();
- Task<eina.Value> task = obj.GetFutureAsync(cancelSrc.Token);
+ Task<Eina.Value> task = obj.GetFutureAsync(cancelSrc.Token);
cancelSrc.Cancel();
loop.Iterate();
bool raised = false;
try
{
- eina.Value v = task.Result;
+ Eina.Value v = task.Result;
}
catch (AggregateException ae)
{
public static void test_async_reject()
{
- efl.ILoop loop = efl.App.GetLoopMain();
- test.ITesting obj = new test.Testing();
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ var obj = new Dummy.TestObject();
- Task<eina.Value> task = obj.GetFutureAsync();
+ Task<Eina.Value> task = obj.GetFutureAsync();
- eina.Error sentError = 1337;
+ Eina.Error sentError = 1337;
obj.RejectPromise(sentError);
loop.Iterate();
bool raised = false;
try
{
- eina.Value v = task.Result;
+ Eina.Value v = task.Result;
}
catch (AggregateException ae)
{
raised = true;
ae.Handle((x) =>
{
- Test.Assert(x is efl.FutureException, "AggregateException must have been TaskCanceledException");
- efl.FutureException ex = x as efl.FutureException;
+ Test.Assert(x is Efl.FutureException, "AggregateException must have been TaskCanceledException");
+ Efl.FutureException ex = x as Efl.FutureException;
Test.AssertEquals(ex.Error, sentError);
return true;
});
{
public static void basic_test()
{
- eina.Error.Clear();
- Test.AssertNotRaises<efl.EflException>(eina.Error.RaiseIfOccurred);
- eina.Error.Set(eina.Error.ENOENT);
- Test.AssertRaises<efl.EflException>(eina.Error.RaiseIfOccurred);
+ Eina.Error.Clear();
+ Test.AssertNotRaises<Efl.EflException>(Eina.Error.RaiseIfOccurred);
+ Eina.Error.Set(Eina.Error.ENOENT);
+ Test.AssertRaises<Efl.EflException>(Eina.Error.RaiseIfOccurred);
}
}
public static void global_eina_error()
{
- test.ITesting obj = new test.Testing();
- Test.AssertRaises<efl.EflException>(() => obj.RaisesEinaError());
+ var obj = new Dummy.TestObject();
+ Test.AssertRaises<Efl.EflException>(() => obj.RaisesEinaError());
}
- class Child : test.TestingInherit {
+ class Child : Dummy.TestObject {
}
public static void global_eina_error_inherited()
{
- test.ITesting obj = new Child();
- Test.AssertRaises<efl.EflException>(() => obj.RaisesEinaError());
+ var obj = new Child();
+ Test.AssertRaises<Efl.EflException>(() => obj.RaisesEinaError());
}
class CustomException : Exception {
public CustomException(string msg): base(msg) {}
}
- class Overrider : test.TestingInherit {
+ class Overrider : Dummy.TestObject {
public override void ChildrenRaiseError() {
throw (new CustomException("Children error"));
}
public static void exception_raised_from_inherited_virtual()
{
- test.ITesting obj = new Overrider();
+ var obj = new Overrider();
- Test.AssertRaises<efl.EflException>(obj.CallChildrenRaiseError);
+ Test.AssertRaises<Efl.EflException>(obj.CallChildrenRaiseError);
}
// return eina_error
public static void eina_error_return()
{
- test.ITesting obj = new test.Testing();
- eina.Error expected = 42;
+ var obj = new Dummy.TestObject();
+ Eina.Error expected = 42;
obj.SetErrorRet(expected);
- eina.Error error = obj.ReturnsError();
+ Eina.Error error = obj.ReturnsError();
Test.AssertEquals(expected, error);
Test.AssertEquals(expected, error);
}
- class ReturnOverride : test.TestingInherit {
- eina.Error code;
- public override void SetErrorRet(eina.Error err) {
+ class ReturnOverride : Dummy.TestObject {
+ Eina.Error code;
+ public override void SetErrorRet(Eina.Error err) {
code = 2 * err;
}
- public override eina.Error ReturnsError()
+ public override Eina.Error ReturnsError()
{
return code;
}
public static void eina_error_return_from_inherited_virtual()
{
- test.ITesting obj = new ReturnOverride();
- eina.Error expected = 42;
+ var obj = new ReturnOverride();
+ Eina.Error expected = 42;
obj.SetErrorRet(expected);
- eina.Error error = obj.ReturnsError();
+ Eina.Error error = obj.ReturnsError();
- Test.AssertEquals(new eina.Error(expected * 2), error);
+ Test.AssertEquals(new Eina.Error(expected * 2), error);
expected = 0;
obj.SetErrorRet(expected);
error = obj.ReturnsError();
- Test.AssertEquals(new eina.Error(expected * 2), error);
+ Test.AssertEquals(new Eina.Error(expected * 2), error);
}
// events
// An event whose managed delegate generates an exception
// must set an eina_error so it can be reported back to
// the managed code
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
Listener listener = new Listener();
obj.EvtWithIntEvt += listener.callback;
- Test.AssertRaises<efl.EflException>(() => { obj.EmitEventWithInt(2); });
+ Test.AssertRaises<Efl.EflException>(() => { obj.EmitEventWithInt(2); });
}
}
}
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
-public class MyBox : evas.BoxInherit
+public class MyBox : Evas.Box
{
- public MyBox(efl.Object parent) : base(parent) {}
+ public MyBox(Efl.Object parent) : base(parent) {}
[DllImport("evas")] static extern void evas_obj_box_layout_vertical(IntPtr obj, IntPtr data, IntPtr privdata);
[DllImport("evas")] static extern void evas_obj_box_layout_horizontal(IntPtr obj, IntPtr data, IntPtr privdata);
override public void CalculateGroup()
{
- IntPtr evas = evas_object_evas_get(raw_handle);
+ IntPtr evas = evas_object_evas_get(NativeHandle);
evas_event_freeze(evas);
- eina.Log.Debug("called group_calculate");
+ Eina.Log.Debug("called group_calculate");
// slayouting_set(true);
- evas_obj_box_layout_vertical(raw_handle, IntPtr.Zero, IntPtr.Zero);
+ evas_obj_box_layout_vertical(NativeHandle, IntPtr.Zero, IntPtr.Zero);
// layouting_set(false);
// children_changed_set(false);
evas_event_thaw(evas);
/* canvas.visible_set(true); */
/* efl.Object parent = canvas.parent_get(); */
- /* Test.Assert(parent.raw_handle != IntPtr.Zero); */
+ /* Test.Assert(parent.NativeHandle != IntPtr.Zero); */
/* efl.canvas.Rectangle rect = new efl.canvas.RectangleConcrete(canvas); */
/* rect.color_set(255, 255, 255, 255); */
using System;
-using static test.Testing; // For the event args
-
namespace TestSuite
{
{
public bool called = false;
public bool correct_sender = false;
- public efl.ILoop loop { get; set; }
+ public Efl.Loop loop { get; set; }
protected void callback(object sender, EventArgs e) {
called = true;
- efl.IObject obj = sender as efl.IObject;
+ Efl.Object obj = sender as Efl.Object;
if (obj != null)
{
obj.SetName("loop_called");
correct_sender = true;
}
- eina.Value v = new eina.Value(eina.ValueType.Int32);
+ Eina.Value v = new Eina.Value(Eina.ValueType.Int32);
v.Set(0);
loop.Quit(v);
}
public static void idle_event()
{
- efl.ILoop loop = new efl.Loop();
+ Efl.Loop loop = new Efl.Loop();
loop.SetName("loop");
TestEoEvents listener = new TestEoEvents();
listener.loop = loop;
public static void event_with_string_payload()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
string received_string = null;
- obj.EvtWithStringEvt += (object sender, EvtWithStringEvt_Args e) => {
+ obj.EvtWithStringEvt += (object sender, Dummy.TestObjectEvtWithStringEvt_Args e) => {
received_string = e.arg;
};
public static void event_with_int_payload()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
int received_int= 0;
- obj.EvtWithIntEvt += (object sender, EvtWithIntEvt_Args e) => {
+ obj.EvtWithIntEvt += (object sender, Dummy.TestObjectEvtWithIntEvt_Args e) => {
received_int = e.arg;
};
public static void event_with_bool_payload()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
bool received_bool = false;
- obj.EvtWithBoolEvt += (object sender, EvtWithBoolEvt_Args e) => {
+ obj.EvtWithBoolEvt += (object sender, Dummy.TestObjectEvtWithBoolEvt_Args e) => {
received_bool = e.arg;
};
public static void event_with_uint_payload()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
uint received_uint = 0;
- obj.EvtWithUintEvt += (object sender, EvtWithUintEvt_Args e) => {
+ obj.EvtWithUintEvt += (object sender, Dummy.TestObjectEvtWithUintEvt_Args e) => {
received_uint = e.arg;
};
public static void event_with_object_payload()
{
- test.ITesting obj = new test.Testing();
- test.ITesting received_obj = null;
+ var obj = new Dummy.TestObject();
+ Dummy.TestObject received_obj = null;
- obj.EvtWithObjEvt += (object sender, EvtWithObjEvt_Args e) => {
+ obj.EvtWithObjEvt += (object sender, Dummy.TestObjectEvtWithObjEvt_Args e) => {
received_obj = e.arg;
};
- test.ITesting sent_obj = new test.Testing();
+ var sent_obj = new Dummy.TestObject();
obj.EmitEventWithObj(sent_obj);
public static void event_with_error_payload()
{
- test.ITesting obj = new test.Testing();
- eina.Error received_error = 0;
+ var obj = new Dummy.TestObject();
+ Eina.Error received_error = 0;
- obj.EvtWithErrorEvt += (object sender, EvtWithErrorEvt_Args e) => {
+ obj.EvtWithErrorEvt += (object sender, Dummy.TestObjectEvtWithErrorEvt_Args e) => {
received_error = e.arg;
};
- eina.Error sent_error = -2001;
+ Eina.Error sent_error = -2001;
obj.EmitEventWithError(sent_error);
public static void event_with_struct_payload()
{
- test.ITesting obj = new test.Testing();
- test.StructSimple received_struct = default(test.StructSimple);
+ var obj = new Dummy.TestObject();
+ Dummy.StructSimple received_struct = default(Dummy.StructSimple);
- obj.EvtWithStructEvt += (object sender, EvtWithStructEvt_Args e) => {
+ obj.EvtWithStructEvt += (object sender, Dummy.TestObjectEvtWithStructEvt_Args e) => {
received_struct = e.arg;
};
- test.StructSimple sent_struct = default(test.StructSimple);
+ Dummy.StructSimple sent_struct = default(Dummy.StructSimple);
sent_struct.Fstring = "Struct Event";
obj.EmitEventWithStruct(sent_struct);
{
int received = 0;
int sent = 42;
- test.ITesting obj = new test.Testing(null, (test.ITesting t) => {
- t.EvtWithIntEvt += (object sender, EvtWithIntEvt_Args e) => {
+ var obj = new Dummy.TestObject(null, (Dummy.TestObject t) => {
+ t.EvtWithIntEvt += (object sender, Dummy.TestObjectEvtWithIntEvt_Args e) => {
received = e.arg;
};
});
{
public static void test_add_remove_event()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
bool called = true;
- EventHandler<test.Testing.EvtWithIntEvt_Args> evtCb = (object sender, EvtWithIntEvt_Args e) => {
+ EventHandler<Dummy.TestObjectEvtWithIntEvt_Args> evtCb = (object sender, Dummy.TestObjectEvtWithIntEvt_Args e) => {
called = true;
};
obj.EvtWithIntEvt -= evtCb;
obj.EmitEventWithInt(42);
Test.Assert(!called);
+ }
+}
+
+class TestInterfaceEvents
+{
+ public static void test_nonconflicting_events()
+ {
+ var obj = new Dummy.TestObject();
+ var called = false;
+
+ EventHandler cb = (object sender, EventArgs e) => {
+ called = true;
+ };
+
+ obj.NonconflictedEvt += cb;
+ obj.EmitNonconflicted();
+ Test.Assert(called);
+ }
+
+ public static void test_conflicting_events()
+ {
+ var obj = new Dummy.TestObject();
+ var test_called = false;
+ var another_called = false;
+
+ EventHandler cb = (object sender, EventArgs e) => {
+ test_called = true;
+ };
+
+ EventHandler another_cb = (object sender, EventArgs e) => {
+ another_called = true;
+ };
+ ((Dummy.TestIface)obj).ConflictedEvt += cb;
+ ((Dummy.AnotherIface)obj).ConflictedEvt += another_cb;
+ obj.EmitTestConflicted();
+ Test.Assert(test_called);
+ Test.Assert(!another_called);
+ test_called = false;
+ obj.EmitAnotherConflicted();
+ Test.Assert(!test_called);
+ Test.Assert(another_called);
}
}
}
{
public static void func_pointer_marshalling()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
bool called = false;
- eina.Strbuf buf = new eina.Strbuf();
+ Eina.Strbuf buf = new Eina.Strbuf();
string argument = "Some String";
- eina.Value v = new eina.Value(eina.ValueType.String);
+ Eina.Value v = new Eina.Value(Eina.ValueType.String);
v.Set(argument);
string reference = new string(argument.ToCharArray().Reverse().ToArray());
- obj.CallFormatCb(buf, v, (eina.Strbuf ibuf, eina.Value val) => {
+ obj.CallFormatCb(buf, v, (Eina.Strbuf ibuf, Eina.Value val) => {
called = true;
string str = null;
val.Get(out str);
public static void set_callback_basic()
{
setup();
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
obj.SetCallback(twice);
Test.Assert(called == false, "set_callback should not call the callback");
{
setup();
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
obj.SetCallback(y => {
called = true;
return y + 4;
{
setup();
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
obj.SetCallback(twice);
Test.Assert(called == false, "set_callback should not call the callback");
Test.AssertEquals(42 * 42, x);
}
- class NoOverride : test.TestingInherit {
+ class NoOverride : Dummy.TestObject {
}
public static void set_callback_inherited_no_override()
{
Test.AssertEquals(42 * 3, x);
}
- class WithOverride : test.TestingInherit {
+ class WithOverride : Dummy.TestObject {
public bool set_called = false;
public bool invoke_called = false;
- public test.SimpleCb cb = null;
+ public Dummy.SimpleCb cb = null;
public WithOverride() : base() {
}
- public override void SetCallback(test.SimpleCb cb) {
+ public override void SetCallback(Dummy.SimpleCb cb) {
set_called = true;
this.cb = cb;
}
invoke_called = true;
if (cb != null)
return cb(a);
- eina.Log.Error("No callback set upon call_callback invocation");
+ Eina.Log.Error("No callback set upon call_callback invocation");
return -1;
}
}
static int Main(string[] args)
{
- efl.All.Init();
+ Efl.All.Init();
bool pass = true;
{
public static void basic_part_test()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
do_part_test(t);
}
- private class Child : test.TestingInherit
+ private class Child : Dummy.TestObject
{
public Child() : base(null) {}
}
do_part_test(t);
}
- private static void do_part_test(test.ITesting t)
+ private static void do_part_test(Dummy.TestObject t)
{
- var p1 = t.Part1;
- var p2 = t.Part2;
- Test.Assert(p1 is test.Testing);
- Test.AssertEquals("part1", p1.GetName());
- Test.Assert(p2 is test.Testing);
- Test.AssertEquals("part2", p2.GetName());
+ var p1 = t.PartOne;
+ var p2 = t.PartTwo;
+ Test.Assert(p1 is Dummy.TestObject);
+ Test.AssertEquals("part_one", p1.GetName());
+ Test.Assert(p2 is Dummy.TestObject);
+ Test.AssertEquals("part_two", p2.GetName());
}
}
public static void test_simple_cancel()
{
bool cleanCalled = false;
- eina.Promise promise = new eina.Promise(() => { cleanCalled = true; });
- eina.Future future = new eina.Future(promise);
+ Eina.Promise promise = new Eina.Promise(() => { cleanCalled = true; });
+ Eina.Future future = new Eina.Future(promise);
future.Cancel();
Test.Assert(cleanCalled, "Promise clean callback should have been called.");
Test.AssertRaises<ObjectDisposedException>(() => { promise.Resolve(null); });
public static void test_simple_resolve()
{
bool callbackCalled = false;
- eina.Value received_value = null;
+ Eina.Value received_value = null;
- efl.ILoop loop = efl.App.GetLoopMain();
- eina.Promise promise = new eina.Promise();
- eina.Future future = new eina.Future(promise);
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ Eina.Promise promise = new Eina.Promise();
+ Eina.Future future = new Eina.Future(promise);
- future = future.Then((eina.Value value) => {
+ future = future.Then((Eina.Value value) => {
callbackCalled = true;
received_value = value;
return value;
} );
- eina.Value reference_value = new eina.Value(eina.ValueType.Int32);
+ Eina.Value reference_value = new Eina.Value(Eina.ValueType.Int32);
reference_value.Set(1984);
promise.Resolve(reference_value);
public static void test_simple_reject()
{
bool callbackCalled = false;
- eina.Error received_error = eina.Error.NO_ERROR;
+ Eina.Error received_error = Eina.Error.NO_ERROR;
- efl.ILoop loop = efl.App.GetLoopMain();
- eina.Promise promise = new eina.Promise();
- eina.Future future = new eina.Future(promise);
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ Eina.Promise promise = new Eina.Promise();
+ Eina.Future future = new Eina.Future(promise);
- future = future.Then((eina.Value value) => {
+ future = future.Then((Eina.Value value) => {
callbackCalled = true;
value.Get(out received_error);
return value;
});
- promise.Reject(eina.Error.EPERM);
+ promise.Reject(Eina.Error.EPERM);
loop.Iterate();
Test.Assert(callbackCalled, "Future callback should have been called.");
- Test.AssertEquals(received_error, eina.Error.EPERM);
+ Test.AssertEquals(received_error, Eina.Error.EPERM);
Test.AssertRaises<ObjectDisposedException>(() => { promise.Resolve(null); });
Test.AssertRaises<ObjectDisposedException>(future.Cancel);
{
bool callbackCalled = false;
bool promiseCallbackCalled = false;
- eina.Error received_error = eina.Error.NO_ERROR;
+ Eina.Error received_error = Eina.Error.NO_ERROR;
- eina.Promise promise = new eina.Promise(() => { promiseCallbackCalled = true; });
- eina.Future future = new eina.Future(promise);
+ Eina.Promise promise = new Eina.Promise(() => { promiseCallbackCalled = true; });
+ Eina.Future future = new Eina.Future(promise);
- future = future.Then((eina.Value value) => {
+ future = future.Then((Eina.Value value) => {
callbackCalled = true;
value.Get(out received_error);
return value;
Test.Assert(promiseCallbackCalled, "Promise cancel callback should have been called.");
Test.Assert(callbackCalled, "Future callback should have been called.");
- Test.AssertEquals(received_error, eina.Error.ECANCELED);
+ Test.AssertEquals(received_error, Eina.Error.ECANCELED);
}
- private delegate eina.Future.ResolvedCb FutureCbGenerator(int x);
+ private delegate Eina.Future.ResolvedCb FutureCbGenerator(int x);
public static void test_then_chaining()
{
bool[] callbacksCalled = {false, false, false, false};
- eina.Value[] received_value = {null, null, null, null};
+ Eina.Value[] received_value = {null, null, null, null};
FutureCbGenerator genResolvedCb = (int i) => {
- return (eina.Value value) => {
+ return (Eina.Value value) => {
callbacksCalled[i] = true;
int x;
value.Get(out x);
};
};
- efl.ILoop loop = efl.App.GetLoopMain();
- eina.Promise promise = new eina.Promise();
- eina.Future future = new eina.Future(promise);
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ Eina.Promise promise = new Eina.Promise();
+ Eina.Future future = new Eina.Future(promise);
for (int i = 0; i < 4; i++)
future = future.Then(genResolvedCb(i));
- eina.Value reference_value = new eina.Value(eina.ValueType.Int32);
+ Eina.Value reference_value = new Eina.Value(Eina.ValueType.Int32);
reference_value.Set(0);
promise.Resolve(reference_value);
public static void test_then_chain_array()
{
bool[] callbacksCalled = {false, false, false, false};
- eina.Value[] received_value = {null, null, null, null};
+ Eina.Value[] received_value = {null, null, null, null};
FutureCbGenerator genResolvedCb = (int i) => {
- return (eina.Value value) => {
+ return (Eina.Value value) => {
callbacksCalled[i] = true;
int x;
value.Get(out x);
};
};
- var cbs = new List<eina.Future.ResolvedCb>();
+ var cbs = new List<Eina.Future.ResolvedCb>();
for (int i = 0; i < 4; i++)
cbs.Add(genResolvedCb(i));
- efl.ILoop loop = efl.App.GetLoopMain();
- eina.Promise promise = new eina.Promise();
- eina.Future future = new eina.Future(promise);
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ Eina.Promise promise = new Eina.Promise();
+ Eina.Future future = new Eina.Future(promise);
future = future.Chain(cbs);
- eina.Value reference_value = new eina.Value(eina.ValueType.Int32);
+ Eina.Value reference_value = new Eina.Value(Eina.ValueType.Int32);
reference_value.Set(0);
promise.Resolve(reference_value);
public static void test_cancel_after_resolve()
{
bool callbackCalled = false;
- eina.Error received_error = eina.Error.NO_ERROR;
+ Eina.Error received_error = Eina.Error.NO_ERROR;
- efl.ILoop loop = efl.App.GetLoopMain();
- eina.Promise promise = new eina.Promise();
- eina.Future future = new eina.Future(promise);
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ Eina.Promise promise = new Eina.Promise();
+ Eina.Future future = new Eina.Future(promise);
- future = future.Then((eina.Value value) => {
+ future = future.Then((Eina.Value value) => {
callbackCalled = true;
value.Get(out received_error);
return value;
});
- promise.Reject(eina.Error.EPERM);
+ promise.Reject(Eina.Error.EPERM);
future.Cancel();
loop.Iterate();
Test.Assert(callbackCalled, "Future callback should have been called.");
- Test.AssertEquals(received_error, eina.Error.ECANCELED);
+ Test.AssertEquals(received_error, Eina.Error.ECANCELED);
Test.AssertRaises<ObjectDisposedException>(() => { promise.Resolve(null); });
Test.AssertRaises<ObjectDisposedException>(future.Cancel);
public static void test_constructor_with_callback()
{
bool callbackCalled = false;
- eina.Value received_value = null;
+ Eina.Value received_value = null;
- efl.ILoop loop = efl.App.GetLoopMain();
- eina.Promise promise = new eina.Promise();
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ Eina.Promise promise = new Eina.Promise();
#pragma warning disable 0219
- eina.Future future = new eina.Future(promise,(eina.Value value) => {
+ Eina.Future future = new Eina.Future(promise,(Eina.Value value) => {
callbackCalled = true;
received_value = value;
return value;
} );
#pragma warning restore 0219
- eina.Value reference_value = new eina.Value(eina.ValueType.Int32);
+ Eina.Value reference_value = new Eina.Value(Eina.ValueType.Int32);
reference_value.Set(1984);
promise.Resolve(reference_value);
public static void test_reject_on_disposal()
{
bool callbackCalled = false;
- eina.Error received_error = eina.Error.NO_ERROR;
+ Eina.Error received_error = Eina.Error.NO_ERROR;
- efl.ILoop loop = efl.App.GetLoopMain();
- eina.Promise promise = new eina.Promise();
- eina.Future future = new eina.Future(promise);
+ Efl.Loop loop = Efl.App.GetLoopMain();
+ Eina.Promise promise = new Eina.Promise();
+ Eina.Future future = new Eina.Future(promise);
- future = future.Then((eina.Value value) => {
+ future = future.Then((Eina.Value value) => {
callbackCalled = true;
value.Get(out received_error);
return value;
loop.Iterate();
Test.Assert(callbackCalled, "Future callback should have been called.");
- Test.AssertEquals(received_error, eina.Error.ECANCELED);
+ Test.AssertEquals(received_error, Eina.Error.ECANCELED);
Test.AssertRaises<ObjectDisposedException>(() => { promise.Resolve(null); });
Test.AssertRaises<ObjectDisposedException>(future.Cancel);
{
public static void test_steal()
{
- eina.Strbuf buf = new eina.Strbuf();
+ Eina.Strbuf buf = new Eina.Strbuf();
buf.Append("Here's");
buf.Append(' ');
public static void test_eolian()
{
- test.ITesting obj = new test.Testing();
- eina.Strbuf buf = new eina.Strbuf();
+ var obj = new Dummy.TestObject();
+ Eina.Strbuf buf = new Eina.Strbuf();
obj.AppendToStrbuf(buf, "Appended");
obj.AppendToStrbuf(buf, " to buf");
Test.AssertEquals("Appended to buf", buf.Steal());
}
- private class Appender : test.TestingInherit
+ private class Appender : Dummy.TestObject
{
public bool called;
public Appender() : base(null)
called = false;
}
- public override void AppendToStrbuf(eina.Strbuf buf, string str)
+ public override void AppendToStrbuf(Eina.Strbuf buf, string str)
{
- eina.Log.Error("Virtual wrapper called");
+ Eina.Log.Error("Virtual wrapper called");
called = true;
buf.Append(str);
}
public static void test_virtual_eolian()
{
Appender obj = new Appender();
- eina.Strbuf buf = new eina.Strbuf();
+ Eina.Strbuf buf = new Eina.Strbuf();
obj.CallAppendToStrbuf(buf, "Is");
obj.CallAppendToStrbuf(buf, " this");
public static void in_string()
{
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
String sent = "in_string";
String returned = obj.InString(sent);
Test.AssertEquals(sent, returned);
public static void in_own_string()
{
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
String sent = "in_own_string";
String returned = obj.InOwnString(sent);
Test.AssertEquals(sent, returned);
public static void return_string()
{
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
Test.AssertEquals("string", obj.ReturnString());
}
System.GC.Collect();
public static void return_own_string()
{
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
Test.AssertEquals("own_string", obj.ReturnOwnString());
}
System.GC.Collect();
{
{
String str = String.Empty;
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
obj.OutString(out str);
Test.AssertEquals("out_string", str);
}
{
{
String str = String.Empty;
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
obj.OutOwnString(out str);
Test.AssertEquals(str.ToString(), "out_own_string");
}
System.GC.Collect();
}
- private class StringReturner : test.TestingInherit
+ private class StringReturner : Dummy.TestObject
{
public String received_in;
public String received_in_own;
* some time in the future */
public static void return_string_from_virtual()
{
- test.ITesting obj = new StringReturner();
+ var obj = new StringReturner();
/* for (int i = 0; i < 10000; i ++) // Uncomment this to check for memory leaks. */
Test.AssertEquals("inherited", obj.CallReturnString());
System.GC.Collect();
/* The managed wrapper must surrender the ownership to the C after the virtual call. */
public static void return_own_string_from_virtual()
{
- test.ITesting obj = new StringReturner();
+ var obj = new StringReturner();
/* for (int i = 0; i < 10000; i ++) // Uncomment this to check for memory leaks. */
Test.AssertEquals("own_inherited", obj.CallReturnOwnString());
System.GC.Collect();
* need to cache it until some time in the future. */
public static void out_string_from_virtual()
{
- test.ITesting obj = new StringReturner();
+ var obj = new StringReturner();
/* for (int i = 0; i < 10000; i ++) // Uncomment this to check for memory leaks. */
Test.AssertEquals("out_inherited", obj.CallOutString());
System.GC.Collect();
/* The managed wrapper gives C the ownership of the filled out parameter */
public static void out_own_string_from_virtual()
{
- test.ITesting obj = new StringReturner();
+ var obj = new StringReturner();
/* for (int i = 0; i < 10000; i ++) // Uncomment this to check for memory leaks. */
Test.AssertEquals("out_own_inherited", obj.CallOutOwnString());
System.GC.Collect();
public static void in_stringshare()
{
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
String sent = "in_stringshare";
String returned = obj.InStringshare(sent);
Test.AssertEquals(sent, returned);
public static void in_own_stringshare()
{
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
String sent = "in_own_stringshare";
String returned = obj.InOwnStringshare(sent);
Test.AssertEquals(sent, returned);
public static void return_stringshare()
{
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
Test.AssertEquals("stringshare", obj.ReturnStringshare());
}
System.GC.Collect();
public static void return_own_stringshare()
{
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
Test.AssertEquals("own_stringshare", obj.ReturnOwnStringshare());
}
System.GC.Collect();
{
{
String str = String.Empty;
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
obj.OutStringshare(out str);
Test.AssertEquals("out_stringshare", str);
}
{
{
String str = String.Empty;
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
obj.OutOwnStringshare(out str);
Test.AssertEquals(str.ToString(), "out_own_stringshare");
}
System.GC.Collect();
}
- private class StringshareReturner : test.TestingInherit
+ private class StringshareReturner : Dummy.TestObject
{
public String received_in;
public String received_in_own;
public static void return_stringshare_from_virtual()
{
- test.ITesting obj = new StringshareReturner();
+ var obj = new StringshareReturner();
// for (int i = 0; i < 1000000; i ++) // Uncomment this to check for memory leaks.
Test.AssertEquals("inherited", obj.CallReturnStringshare());
}
public static void return_own_stringshare_from_virtual()
{
- test.ITesting obj = new StringshareReturner();
+ var obj = new StringshareReturner();
// for (int i = 0; i < 1000000; i ++) // Uncomment this to check for memory leaks.
Test.AssertEquals("own_inherited", obj.CallReturnOwnStringshare());
}
public static void out_stringshare_from_virtual()
{
- test.ITesting obj = new StringshareReturner();
+ var obj = new StringshareReturner();
// for (int i = 0; i < 1000000; i ++) // Uncomment this to check for memory leaks.
Test.AssertEquals("out_inherited", obj.CallOutStringshare());
}
public static void out_own_stringshare_from_virtual()
{
- test.ITesting obj = new StringshareReturner();
+ var obj = new StringshareReturner();
// for (int i = 0; i < 1000000; i ++) // Uncomment this to check for memory leaks.
Test.AssertEquals("out_own_inherited", obj.CallOutOwnStringshare());
}
{
// Auxiliary function //
- private static test.StructSimple structSimpleWithValues()
+ private static Dummy.StructSimple structSimpleWithValues()
{
- var simple = new test.StructSimple();
+ var simple = new Dummy.StructSimple();
simple.Fbyte = (sbyte)-126;
simple.Fubyte = (byte) 254u;
simple.Fdouble = -9007199254740992.0;
simple.Fbool = true;
simple.Fvoid_ptr = (IntPtr) 0xFE;
- simple.Fenum = test.SampleEnum.V2;
+ simple.Fenum = Dummy.SampleEnum.V2;
simple.Fstring = "test/string";
simple.Fmstring = "test/mstring";
simple.Fstringshare = "test/stringshare";
return simple;
}
- private static void checkStructSimple(test.StructSimple simple)
+ private static void checkStructSimple(Dummy.StructSimple simple)
{
Test.Assert(simple.Fbyte == (sbyte) -126);
Test.Assert(simple.Fubyte == (byte) 254u);
Test.Assert(simple.Fdouble == -9007199254740992.0);
Test.Assert(simple.Fbool == true);
Test.Assert(simple.Fvoid_ptr == (IntPtr) 0xFE);
- Test.Assert(simple.Fenum == test.SampleEnum.V2);
+ Test.Assert(simple.Fenum == Dummy.SampleEnum.V2);
Test.Assert(simple.Fstring == "test/string");
Test.Assert(simple.Fmstring == "test/mstring");
Test.Assert(simple.Fstringshare == "test/stringshare");
}
- private static void checkZeroedStructSimple(test.StructSimple simple)
+ private static void checkZeroedStructSimple(Dummy.StructSimple simple)
{
Test.Assert(simple.Fbyte == 0);
Test.Assert(simple.Fubyte == 0);
Test.Assert(simple.Fdouble == 0);
Test.Assert(simple.Fbool == false);
Test.Assert(simple.Fvoid_ptr == IntPtr.Zero);
- Test.Assert(simple.Fenum == test.SampleEnum.V0);
+ Test.Assert(simple.Fenum == Dummy.SampleEnum.V0);
Test.Assert(simple.Fstring == null);
Test.Assert(simple.Fmstring == null);
Test.Assert(simple.Fstringshare == null);
}
- private static test.StructComplex structComplexWithValues()
+ private static Dummy.StructComplex structComplexWithValues()
{
- var complex = new test.StructComplex();
+ var complex = new Dummy.StructComplex();
- complex.Farray = new eina.Array<int>();
+ complex.Farray = new Eina.Array<int>();
complex.Farray.Push(0x0);
complex.Farray.Push(0x2A);
complex.Farray.Push(0x42);
- complex.Finarray = new eina.Inarray<int>();
+ complex.Finarray = new Eina.Inarray<int>();
complex.Finarray.Push(0x0);
complex.Finarray.Push(0x2A);
complex.Finarray.Push(0x42);
- complex.Flist = new eina.List<string>();
+ complex.Flist = new Eina.List<string>();
complex.Flist.Append("0x0");
complex.Flist.Append("0x2A");
complex.Flist.Append("0x42");
- complex.Finlist = new eina.Inlist<int>();
+ complex.Finlist = new Eina.Inlist<int>();
complex.Finlist.Append(0x0);
complex.Finlist.Append(0x2A);
complex.Finlist.Append(0x42);
- complex.Fhash = new eina.Hash<string, string>();
+ complex.Fhash = new Eina.Hash<string, string>();
complex.Fhash["aa"] = "aaa";
complex.Fhash["bb"] = "bbb";
complex.Fhash["cc"] = "ccc";
complex.Fiterator = complex.Farray.GetIterator();
- complex.Fany_value = new eina.Value(eina.ValueType.Double);
+ complex.Fany_value = new Eina.Value(Eina.ValueType.Double);
complex.Fany_value.Set(-9007199254740992.0);
- complex.Fany_value_ptr = new eina.Value(eina.ValueType.String);
+ complex.Fany_value_ptr = new Eina.Value(Eina.ValueType.String);
complex.Fany_value_ptr.Set("abc");
- complex.Fbinbuf = new eina.Binbuf();
+ complex.Fbinbuf = new Eina.Binbuf();
complex.Fbinbuf.Append(126);
complex.Fslice.Length = 1;
- complex.Fslice.Mem = eina.MemoryNative.Alloc(1);
+ complex.Fslice.Mem = Eina.MemoryNative.Alloc(1);
Marshal.WriteByte(complex.Fslice.Mem, 125);
- complex.Fobj = new test.Numberwrapper();
+ complex.Fobj = new Dummy.Numberwrapper();
complex.Fobj.SetNumber(42);
return complex;
}
- private static void checkStructComplex(test.StructComplex complex)
+ private static void checkStructComplex(Dummy.StructComplex complex)
{
Test.Assert(complex.Farray.ToArray().SequenceEqual(base_seq_int));
}
- private static void checkZeroedStructComplex(test.StructComplex complex)
+ private static void checkZeroedStructComplex(Dummy.StructComplex complex)
{
Test.Assert(complex.Farray == null);
Test.Assert(complex.Finarray == null);
private static void simple_default_instantiation()
{
- var simple = new test.StructSimple();
+ var simple = new Dummy.StructSimple();
checkZeroedStructSimple(simple);
}
private static void complex_default_instantiation()
{
- var complex = new test.StructComplex();
+ var complex = new Dummy.StructComplex();
checkZeroedStructComplex(complex);
}
public static void parameter_initialization()
{
- var simple = new test.StructSimple(0x1, 0x2, (char)0x3, 0x4, 0x5);
+ var simple = new Dummy.StructSimple(0x1, 0x2, (char)0x3, 0x4, 0x5);
Test.AssertEquals(0x1, simple.Fbyte);
Test.AssertEquals(0x2, simple.Fubyte);
Test.AssertEquals(0x3, simple.Fchar);
public static void simple_in()
{
var simple = structSimpleWithValues();
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
bool r = t.StructSimpleIn(simple);
Test.Assert(r, "Function returned false");
}
var simple = structSimpleWithValues();
int original = simple.Fint;
simple.Fmstring = "Struct Ptr In";
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
Test.Assert(t.StructSimplePtrIn(ref simple));
Test.AssertEquals(-original, simple.Fint);
Test.AssertEquals("nI rtP tcurtS", simple.Fmstring);
var simple = structSimpleWithValues();
int original = simple.Fint;
simple.Fmstring = "Struct Ptr In Own";
- test.ITesting t = new test.Testing();
- test.StructSimple result = t.StructSimplePtrInOwn(ref simple);
+ var t = new Dummy.TestObject();
+ Dummy.StructSimple result = t.StructSimplePtrInOwn(ref simple);
Test.AssertEquals(-original, result.Fint);
Test.AssertEquals("nwO nI rtP tcurtS", result.Fmstring);
}
public static void simple_out()
{
- var simple = new test.StructSimple();
- test.ITesting t = new test.Testing();
+ var simple = new Dummy.StructSimple();
+ var t = new Dummy.TestObject();
bool r = t.StructSimpleOut(out simple);
Test.Assert(r, "Function returned false");
checkStructSimple(simple);
public static void simple_ptr_out()
{
- test.StructSimple simple;
- test.ITesting t = new test.Testing();
- test.StructSimple result = t.StructSimplePtrOut(out simple);
+ Dummy.StructSimple simple;
+ var t = new Dummy.TestObject();
+ Dummy.StructSimple result = t.StructSimplePtrOut(out simple);
Test.AssertEquals(result.Fint, simple.Fint);
Test.AssertEquals(result.Fstring, simple.Fstring);
}
public static void simple_ptr_out_own()
{
- test.StructSimple simple;
- test.ITesting t = new test.Testing();
- test.StructSimple result = t.StructSimplePtrOutOwn(out simple);
+ Dummy.StructSimple simple;
+ var t = new Dummy.TestObject();
+ Dummy.StructSimple result = t.StructSimplePtrOutOwn(out simple);
Test.AssertEquals(result.Fint, simple.Fint);
Test.AssertEquals(simple.Fstring, "Ptr Out Own");
}
public static void simple_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var simple = t.StructSimpleReturn();
checkStructSimple(simple);
}
public static void simple_ptr_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var simple = t.StructSimplePtrReturn();
Test.AssertEquals(simple.Fstring, "Ret Ptr");
}
public static void simple_ptr_return_own()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var simple = t.StructSimplePtrReturnOwn();
Test.AssertEquals(simple.Fstring, "Ret Ptr Own");
}
- public class StructReturner : test.TestingInherit
+ public class StructReturner : Dummy.TestObject
{
- public test.StructSimple received;
+ public Dummy.StructSimple received;
public bool called;
public StructReturner() : base(null)
{
called = false;
- received = default(test.StructSimple);
+ received = default(Dummy.StructSimple);
}
- public override bool StructSimpleIn(test.StructSimple simple)
+ public override bool StructSimpleIn(Dummy.StructSimple simple)
{
called = true;
received = simple;
return true;
}
- public override bool StructSimplePtrIn(ref test.StructSimple simple)
+ public override bool StructSimplePtrIn(ref Dummy.StructSimple simple)
{
called = true;
simple.Fstring = "Virtual Struct Ptr In";
return true;
}
- public override test.StructSimple StructSimplePtrInOwn(ref test.StructSimple simple)
+ public override Dummy.StructSimple StructSimplePtrInOwn(ref Dummy.StructSimple simple)
{
called = true;
received = simple;
return received;
}
- public override bool StructSimpleOut(out test.StructSimple simple) {
+ public override bool StructSimpleOut(out Dummy.StructSimple simple) {
called = true;
- simple = new test.StructSimple();
+ simple = new Dummy.StructSimple();
simple.Fstring = "Virtual Struct Out";
return true;
}
- public override test.StructSimple StructSimplePtrOut(out test.StructSimple simple) {
+ public override Dummy.StructSimple StructSimplePtrOut(out Dummy.StructSimple simple) {
called = true;
// No way to explicitly define the ownership of the parameter.
- simple = new test.StructSimple();
+ simple = new Dummy.StructSimple();
simple.Fstring = "Virtual Struct Ptr Out";
return simple;
}
- public override test.StructSimple StructSimplePtrOutOwn(out test.StructSimple simple) {
+ public override Dummy.StructSimple StructSimplePtrOutOwn(out Dummy.StructSimple simple) {
called = true;
// No way to explicitly define the ownership of the parameter.
- simple = new test.StructSimple();
+ simple = new Dummy.StructSimple();
simple.Fstring = "Virtual Struct Ptr Out Own";
return simple;
}
- public override test.StructSimple StructSimpleReturn()
+ public override Dummy.StructSimple StructSimpleReturn()
{
called = true;
- var simple = new test.StructSimple();
+ var simple = new Dummy.StructSimple();
simple.Fstring = "Virtual Struct Return";
return simple;
}
- public override test.StructSimple StructSimplePtrReturn()
+ public override Dummy.StructSimple StructSimplePtrReturn()
{
called = true;
- var simple = new test.StructSimple();
+ var simple = new Dummy.StructSimple();
simple.Fstring = "Virtual Struct Ptr Return";
return simple;
}
- public override test.StructSimple StructSimplePtrReturnOwn()
+ public override Dummy.StructSimple StructSimplePtrReturnOwn()
{
called = true;
- var simple = new test.StructSimple();
+ var simple = new Dummy.StructSimple();
simple.Fstring = "Virtual Struct Ptr Return Own";
return simple;
}
public static void simple_out_virtual()
{
StructReturner t = new StructReturner();
- test.StructSimple simple;
+ Dummy.StructSimple simple;
t.CallStructSimpleOut(out simple);
Test.Assert(t.called, "override was not called");
Test.AssertEquals("Virtual Struct Out", simple.Fstring);
public static void simple_ptr_out_virtual()
{
StructReturner t = new StructReturner();
- test.StructSimple simple;
+ Dummy.StructSimple simple;
t.CallStructSimplePtrOut(out simple);
Test.Assert(t.called, "override was not called");
Test.AssertEquals("Virtual Struct Ptr Out", simple.Fstring);
public static void simple_ptr_out_own_virtual()
{
StructReturner t = new StructReturner();
- test.StructSimple simple;
+ Dummy.StructSimple simple;
t.CallStructSimplePtrOutOwn(out simple);
Test.Assert(t.called, "override was not called");
Test.AssertEquals("Virtual Struct Ptr Out Own", simple.Fstring);
public static void simple_return_virtual()
{
StructReturner t = new StructReturner();
- test.StructSimple simple = t.CallStructSimpleReturn();
+ Dummy.StructSimple simple = t.CallStructSimpleReturn();
Test.Assert(t.called, "override was not called");
Test.AssertEquals("Virtual Struct Return", simple.Fstring);
}
public static void simple_ptr_return_virtual()
{
StructReturner t = new StructReturner();
- test.StructSimple simple = t.CallStructSimplePtrReturn();
+ Dummy.StructSimple simple = t.CallStructSimplePtrReturn();
Test.Assert(t.called, "override was not called");
Test.AssertEquals("Virtual Struct Ptr Return", simple.Fstring);
}
public static void simple_ptr_return_own_virtual()
{
StructReturner t = new StructReturner();
- test.StructSimple simple = t.CallStructSimplePtrReturnOwn();
+ Dummy.StructSimple simple = t.CallStructSimplePtrReturnOwn();
Test.Assert(t.called, "override was not called");
Test.AssertEquals("Virtual Struct Ptr Return Own", simple.Fstring);
}
public static void complex_in()
{
var complex = structComplexWithValues();
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
bool r = t.StructComplexIn(complex);
Test.Assert(r, "Function returned false");
}
public static void complex_out()
{
- var complex = new test.StructComplex();
- test.ITesting t = new test.Testing();
+ var complex = new Dummy.StructComplex();
+ var t = new Dummy.TestObject();
bool r = t.StructComplexOut(out complex);
Test.Assert(r, "Function returned false");
checkStructComplex(complex);
public static void complex_return()
{
- test.ITesting t = new test.Testing();
+ var t = new Dummy.TestObject();
var complex = t.StructComplexReturn();
checkStructComplex(complex);
}
public static void TestByteSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Byte)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Byte)) {
byte val = 0xff;
Test.Assert(v.Set(val));
byte x;
public static void TestSByteSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.SByte)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.SByte)) {
sbyte val = -45;
Test.Assert(v.Set(val));
sbyte x;
public static void TestShortSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Short)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Short)) {
short val = -128;
Test.Assert(v.Set(val));
short x;
public static void TestUShortSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.UShort)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.UShort)) {
ushort val = 0xff55;
Test.Assert(v.Set(val));
ushort x;
public static void TestLongSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Long)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Long)) {
long val = 0xdeadbeef;
Test.Assert(v.Set(val));
long x;
public static void TestULongSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.ULong)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.ULong)) {
ulong val = 0xdeadbeef;
Test.Assert(v.Set(val));
ulong x;
public static void TestFloatSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Float)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Float)) {
float val = 1.609344f;
Test.Assert(v.Set(val));
float x;
public static void TestDoubleSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Double)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Double)) {
double val = 1.609344;
Test.Assert(v.Set(val));
double x;
public static void TestIntSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(v.Set(32));
int x;
Test.Assert(v.Get(out x));
public static void TestUIntSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(v.Set(0xdeadbeef));
uint x = 0;
Test.Assert(v.Get(out x));
public static void TestStringSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.String)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.String)) {
string expected_str = "Hello";
Test.Assert(v.Set(expected_str));
string str = null;
public static void TestErrorSimple()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Error)) {
- eina.Error error = new eina.Error(eina.Error.NO_ERROR);
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Error)) {
+ Eina.Error error = new Eina.Error(Eina.Error.NO_ERROR);
Test.Assert(v.Set(error));
- eina.Error x;
+ Eina.Error x;
Test.Assert(v.Get(out x));
Test.AssertEquals(error, x);
}
public static void TestSetWrongType()
{
- using (eina.Value v = new eina.Value(eina.ValueType.String)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.String)) {
Test.AssertRaises<ArgumentException>(() => v.Set(42));
Test.AssertNotRaises<ArgumentException>(() => v.Set("Wumpus"));
- Test.Assert(v.Setup(eina.ValueType.Int32));
+ Test.Assert(v.Setup(Eina.ValueType.Int32));
Test.AssertRaises<ArgumentException>(() => v.Set("Wat?"));
Test.AssertNotRaises<ArgumentException>(() => v.Set(1984));
}
public static void TestValueSetup()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(v.Set(44));
int x = 0;
Test.Assert(v.Get(out x));
Test.AssertEquals(44, x);
- v.Setup(eina.ValueType.String);
+ v.Setup(Eina.ValueType.String);
string str = "Hello";
Test.Assert(v.Get(out str));
public static void TestValueDispose()
{
- eina.Value v = new eina.Value(eina.ValueType.Int32);
+ Eina.Value v = new Eina.Value(Eina.ValueType.Int32);
v.Dispose();
Test.AssertRaises<ObjectDisposedException>(v.Flush);
Test.AssertRaises<ObjectDisposedException>(() => v.ToString());
public static void TestValueFlush()
{
- using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(v.Set(44));
Test.Assert(!v.Flushed);
v.Flush();
Test.Assert(v.Flushed);
int x;
- Test.AssertRaises<eina.ValueFlushedException>(() => v.Get(out x));
+ Test.AssertRaises<Eina.ValueFlushedException>(() => v.Get(out x));
x = 42;
- Test.AssertRaises<eina.ValueFlushedException>(() => v.Set(x));
+ Test.AssertRaises<Eina.ValueFlushedException>(() => v.Set(x));
- v.Setup(eina.ValueType.String);
- Test.AssertNotRaises<eina.ValueFlushedException>(() => v.Set("Hello, EFL"));
+ v.Setup(Eina.ValueType.String);
+ Test.AssertNotRaises<Eina.ValueFlushedException>(() => v.Set("Hello, EFL"));
string y = String.Empty;
- Test.AssertNotRaises<eina.ValueFlushedException>(() => v.Get(out y));
+ Test.AssertNotRaises<Eina.ValueFlushedException>(() => v.Get(out y));
v.Flush();
- Test.AssertRaises<eina.ValueFlushedException>(() => v.Get(out y));
+ Test.AssertRaises<Eina.ValueFlushedException>(() => v.Get(out y));
- v.Setup(eina.ValueType.Array, eina.ValueType.UInt32);
+ v.Setup(Eina.ValueType.Array, Eina.ValueType.UInt32);
- Test.AssertNotRaises<eina.ValueFlushedException>(() =>
+ Test.AssertNotRaises<Eina.ValueFlushedException>(() =>
v.Append(42));
v.Flush();
- Test.AssertRaises<eina.ValueFlushedException>(() =>
+ Test.AssertRaises<Eina.ValueFlushedException>(() =>
v.Append(42));
- Test.AssertRaises<eina.ValueFlushedException>(() => v.GetValueSubType());
+ Test.AssertRaises<Eina.ValueFlushedException>(() => v.GetValueSubType());
}
}
private delegate bool BoolRet();
public static void TestValueOptionalInt()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Optional)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Optional)) {
Test.Assert(a.Optional);
Test.Assert(a.OptionalEmpty); // By default, optional values are empty
}
public static void TestValueOptionalUint()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Optional)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Optional)) {
Test.Assert(a.Optional);
Test.Assert(a.OptionalEmpty); // By default, optional values are empty
}
public static void TestValueOptionalString()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(!a.Optional);
BoolRet dummy = () => a.OptionalEmpty;
- Test.AssertRaises<eina.InvalidValueTypeException>(() => dummy());
+ Test.AssertRaises<Eina.InvalidValueTypeException>(() => dummy());
}
- using (eina.Value a = new eina.Value(eina.ValueType.Optional)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Optional)) {
Test.Assert(a.Optional);
Test.Assert(a.OptionalEmpty); // By default, optional values are empty
}
public static void TestValueOptionalArrays()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Optional))
- using (eina.Value expected = new eina.Value(eina.ValueType.Array,
- eina.ValueType.Int32))
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Optional))
+ using (Eina.Value expected = new Eina.Value(Eina.ValueType.Array,
+ Eina.ValueType.Int32))
{
Test.Assert(a.Optional);
Test.Assert(a.Set(expected));
Test.Assert(!a.OptionalEmpty);
- eina.Value actual = null;
+ Eina.Value actual = null;
Test.Assert(a.Get(out actual));
Test.AssertEquals(expected, actual);
}
public static void TestValueOptionalLists()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Optional))
- using (eina.Value expected = new eina.Value(eina.ValueType.List,
- eina.ValueType.Int32))
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Optional))
+ using (Eina.Value expected = new Eina.Value(Eina.ValueType.List,
+ Eina.ValueType.Int32))
{
Test.Assert(a.Optional);
Test.Assert(a.Set(expected));
Test.Assert(!a.OptionalEmpty);
- eina.Value actual = null;
+ Eina.Value actual = null;
Test.Assert(a.Get(out actual));
Test.AssertEquals(expected, actual);
}
public static void TestValueCompareInts()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Int32))
- using (eina.Value b = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Int32))
+ using (Eina.Value b = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(a.Set(123));
Test.Assert(b.Set(123));
Test.AssertEquals(0, a.CompareTo(b));
public static void TestValueComparisonEquals()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Int32))
- using (eina.Value b = new eina.Value(eina.ValueType.Int32))
- using (eina.Value c = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Int32))
+ using (Eina.Value b = new Eina.Value(Eina.ValueType.Int32))
+ using (Eina.Value c = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(a.Set(1));
Test.Assert(b.Set(1));
Test.Assert(c.Set(1));
public static void TestValueComparisonOverloadEquals()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Int32))
- using (eina.Value b = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Int32))
+ using (Eina.Value b = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(a.Set(1));
Test.Assert(b.Set(1));
public static void TestValueComparisonOverloadLessMore()
{
- using (eina.Value a = new eina.Value(eina.ValueType.Int32))
- using (eina.Value b = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.Int32))
+ using (Eina.Value b = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(a.Set(1));
Test.Assert(b.Set(0));
public static void TestValueCompareStrings()
{
- using (eina.Value a = new eina.Value(eina.ValueType.String))
- using (eina.Value b = new eina.Value(eina.ValueType.String)) {
+ using (Eina.Value a = new Eina.Value(Eina.ValueType.String))
+ using (Eina.Value b = new Eina.Value(Eina.ValueType.String)) {
Test.Assert(a.Set("aaa"));
Test.Assert(b.Set("aaa"));
Test.AssertEquals(0, a.CompareTo(b));
public static void TestValueCompareArray()
{
- using(eina.Value a = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32))
- using(eina.Value b = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32)) {
+ using(Eina.Value a = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.Int32))
+ using(Eina.Value b = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.Int32)) {
Test.AssertEquals(a, b);
public static void TestValueCompareList()
{
- using(eina.Value a = new eina.Value(eina.ValueType.List, eina.ValueType.Int32))
- using(eina.Value b = new eina.Value(eina.ValueType.List, eina.ValueType.Int32)) {
+ using(Eina.Value a = new Eina.Value(Eina.ValueType.List, Eina.ValueType.Int32))
+ using(Eina.Value b = new Eina.Value(Eina.ValueType.List, Eina.ValueType.Int32)) {
Test.AssertEquals(a, b);
public static void TestValueToString()
{
- using(eina.Value a = new eina.Value(eina.ValueType.Int32)) {
+ using(Eina.Value a = new Eina.Value(Eina.ValueType.Int32)) {
int i = -12345;
string x = $"{i}";
Test.Assert(a.Set(i));
uint u = 0xdeadbeef;
x = $"{u}";
- Test.Assert(a.Setup(eina.ValueType.UInt32));
+ Test.Assert(a.Setup(Eina.ValueType.UInt32));
Test.Assert(a.Set(u));
Test.AssertEquals(x, a.ToString());
string s = "Hello, Johnny!";
x = s;
- Test.Assert(a.Setup(eina.ValueType.String));
+ Test.Assert(a.Setup(Eina.ValueType.String));
Test.Assert(a.Set(s));
Test.AssertEquals(x, a.ToString());
}
public static void TestValueConvertInt()
{
- using(eina.Value from = new eina.Value(eina.ValueType.Int32))
- using(eina.Value to = new eina.Value(eina.ValueType.UInt32)) {
+ using(Eina.Value from = new Eina.Value(Eina.ValueType.Int32))
+ using(Eina.Value to = new Eina.Value(Eina.ValueType.UInt32)) {
int source = 0x7FFFFFFF;
uint target_uint;
int target_int;
Test.Assert(to.Get(out target_uint));
Test.AssertEquals(target_uint, (uint)source);
- Test.Assert(to.Setup(eina.ValueType.Int32));
+ Test.Assert(to.Setup(Eina.ValueType.Int32));
Test.Assert(from.ConvertTo(to));
Test.Assert(to.Get(out target_int));
Test.AssertEquals(target_int, source);
- Test.Assert(to.Setup(eina.ValueType.String));
+ Test.Assert(to.Setup(Eina.ValueType.String));
Test.Assert(from.ConvertTo(to));
Test.Assert(to.Get(out target_str));
Test.AssertEquals(target_str, source_str);
public static void TestValueConvertUInt()
{
- using(eina.Value from = new eina.Value(eina.ValueType.UInt32))
- using(eina.Value to = new eina.Value(eina.ValueType.UInt32)) {
+ using(Eina.Value from = new Eina.Value(Eina.ValueType.UInt32))
+ using(Eina.Value to = new Eina.Value(Eina.ValueType.UInt32)) {
uint source = 0xFFFFFFFF;
uint target_uint;
string target_str;
Test.Assert(to.Get(out target_uint));
Test.AssertEquals(target_uint, source);
- Test.Assert(to.Setup(eina.ValueType.Int32));
+ Test.Assert(to.Setup(Eina.ValueType.Int32));
Test.Assert(!from.ConvertTo(to));
- Test.Assert(to.Setup(eina.ValueType.String));
+ Test.Assert(to.Setup(Eina.ValueType.String));
Test.Assert(from.ConvertTo(to));
Test.Assert(to.Get(out target_str));
Test.AssertEquals(target_str, source_str);
public static void TestValueContainerConstructorWrongArgs()
{
Test.AssertRaises<ArgumentException>(() => {
- using(eina.Value array = new eina.Value(eina.ValueType.String, eina.ValueType.String)) { }
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.String, Eina.ValueType.String)) { }
});
}
public static void TestValueContainerWithNonContainerAccess()
{
- using(eina.Value array = new eina.Value(eina.ValueType.Int32)) {
- Test.AssertRaises<eina.InvalidValueTypeException>(() => array[0] = 1);
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.Int32)) {
+ Test.AssertRaises<Eina.InvalidValueTypeException>(() => array[0] = 1);
object val = null;
- Test.AssertRaises<eina.InvalidValueTypeException>(() => val = array[0]);
+ Test.AssertRaises<Eina.InvalidValueTypeException>(() => val = array[0]);
}
}
public static void TestValueArray() {
- using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32)) {
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.Int32)) {
Test.AssertEquals(0, array.Count());
Test.Assert(array.Append(0));
Test.AssertEquals(1, array.Count());
Test.AssertEquals("[1984, -42, 5, 42]", array.ToString());
}
- using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.UInt32)) {
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.UInt32)) {
Test.Assert(array.Append(2));
Test.AssertEquals((uint)array[0], (uint)2);
Test.AssertRaises<OverflowException>(() => array[0] = -1);
}
- using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.String)) {
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.String)) {
Test.Assert(array.Append("hello"));
Test.Assert(array.Append("world"));
}
public static void TestArrayOutOfBounds() {
- using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32)) {
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.Int32)) {
object placeholder = null;
Test.AssertRaises<System.ArgumentOutOfRangeException>(() => array[0] = 1);
Test.AssertRaises<System.ArgumentOutOfRangeException>(() => placeholder = array[0]);
}
public static void TestValueArraySubType() {
- using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32))
- Test.AssertEquals(eina.ValueType.Int32, array.GetValueSubType());
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.Int32))
+ Test.AssertEquals(Eina.ValueType.Int32, array.GetValueSubType());
- using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.UInt32))
- Test.AssertEquals(eina.ValueType.UInt32, array.GetValueSubType());
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.UInt32))
+ Test.AssertEquals(Eina.ValueType.UInt32, array.GetValueSubType());
}
public static void TestValueArrayConvert() {
- using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32))
- using(eina.Value other = new eina.Value(eina.ValueType.Int32)) {
+ using(Eina.Value array = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.Int32))
+ using(Eina.Value other = new Eina.Value(Eina.ValueType.Int32)) {
other.Set(100);
other.ConvertTo(array);
Test.AssertEquals(100, (int)array[0]);
}
public static void TestValueList() {
- using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.Int32)) {
+ using(Eina.Value list = new Eina.Value(Eina.ValueType.List, Eina.ValueType.Int32)) {
Test.AssertEquals(0, list.Count());
Test.Assert(list.Append(0));
Test.AssertEquals(1, list.Count());
Test.AssertEquals("[1984, -42, 5, 42]", list.ToString());
}
- using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.UInt32)) {
+ using(Eina.Value list = new Eina.Value(Eina.ValueType.List, Eina.ValueType.UInt32)) {
Test.Assert(list.Append(2));
Test.AssertEquals((uint)list[0], (uint)2);
Test.AssertRaises<OverflowException>(() => list[0] = -1);
}
- using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.String)) {
+ using(Eina.Value list = new Eina.Value(Eina.ValueType.List, Eina.ValueType.String)) {
Test.Assert(list.Append("hello"));
Test.Assert(list.Append("world"));
}
public static void TestListOutOfBounds() {
- using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.Int32)) {
+ using(Eina.Value list = new Eina.Value(Eina.ValueType.List, Eina.ValueType.Int32)) {
object placeholder = null;
Test.AssertRaises<System.ArgumentOutOfRangeException>(() => list[0] = 1);
Test.AssertRaises<System.ArgumentOutOfRangeException>(() => placeholder = list[0]);
}
public static void TestValueListSubType() {
- using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.Int32))
- Test.AssertEquals(eina.ValueType.Int32, list.GetValueSubType());
+ using(Eina.Value list = new Eina.Value(Eina.ValueType.List, Eina.ValueType.Int32))
+ Test.AssertEquals(Eina.ValueType.Int32, list.GetValueSubType());
- using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.UInt32))
- Test.AssertEquals(eina.ValueType.UInt32, list.GetValueSubType());
+ using(Eina.Value list = new Eina.Value(Eina.ValueType.List, Eina.ValueType.UInt32))
+ Test.AssertEquals(Eina.ValueType.UInt32, list.GetValueSubType());
}
public static void TestValueListConvert() {
- using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.Int32))
- using(eina.Value other = new eina.Value(eina.ValueType.Int32)) {
+ using(Eina.Value list = new Eina.Value(Eina.ValueType.List, Eina.ValueType.Int32))
+ using(Eina.Value other = new Eina.Value(Eina.ValueType.Int32)) {
other.Set(100);
other.ConvertTo(list);
Test.AssertEquals(100, (int)list[0]);
public static void TestStringThroughValue() {
// Check if Value_Native->Value doesn't try to free the pointed string.
- using(eina.Value value_ptr = new eina.Value(eina.ValueType.String)) {
+ using(Eina.Value value_ptr = new Eina.Value(Eina.ValueType.String)) {
string payload = "Something";
value_ptr.Set(payload);
- eina.Value_Native byvalue = value_ptr;
- eina.Value another_value_ptr = byvalue;
+ Eina.ValueNative byvalue = value_ptr;
+ Eina.Value another_value_ptr = byvalue;
Test.AssertEquals(value_ptr, another_value_ptr);
}
}
public static void TestValueEmpty() {
- using (eina.Value empty = new eina.Value(eina.ValueType.Empty)) {
+ using (Eina.Value empty = new Eina.Value(Eina.ValueType.Empty)) {
Test.Assert(empty.Empty, "Value must be empty");
- empty.Setup(eina.ValueType.Int32);
+ empty.Setup(Eina.ValueType.Int32);
// Values already set-up are not empty. For this kind of empty, use Optional
Test.Assert(!empty.Empty, "Values already set-up must not be empty.");
}
public static void TestValueCopy() {
- eina.Value v2 = null;
+ Eina.Value v2 = null;
int raw_val = 42;
- using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Int32)) {
Test.Assert(v.Set(raw_val));
- v2 = new eina.Value(v);
+ v2 = new Eina.Value(v);
}
int rec_val;
public static class TestEinaValueEolian {
public static void TestEolianEinaValueInReturn()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
- using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Int32)) {
v.Set(42);
obj.SetValuePtr(v);
- Test.AssertEquals(eina.Ownership.Managed, v.Ownership);
+ Test.AssertEquals(Eina.Ownership.Managed, v.Ownership);
- eina.Value v_received = obj.GetValuePtrOwn();
- Test.AssertEquals(eina.Ownership.Managed, v_received.Ownership);
+ Eina.Value v_received = obj.GetValuePtrOwn();
+ Test.AssertEquals(Eina.Ownership.Managed, v_received.Ownership);
Test.AssertEquals(v, v_received);
v_received.Dispose();
}
public static void TestEolianEinaValueInOwn()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
- using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.Int32)) {
v.Set(2001);
- Test.AssertEquals(eina.Ownership.Managed, v.Ownership);
+ Test.AssertEquals(Eina.Ownership.Managed, v.Ownership);
obj.SetValuePtrOwn(v);
- Test.AssertEquals(eina.Ownership.Unmanaged, v.Ownership);
+ Test.AssertEquals(Eina.Ownership.Unmanaged, v.Ownership);
- eina.Value v_received = obj.GetValuePtr();
- Test.AssertEquals(eina.Ownership.Unmanaged, v_received.Ownership);
+ Eina.Value v_received = obj.GetValuePtr();
+ Test.AssertEquals(Eina.Ownership.Unmanaged, v_received.Ownership);
Test.AssertEquals(v, v_received);
public static void TestEolianEinaValueOut()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
- using (eina.Value v = new eina.Value(eina.ValueType.String)) {
- eina.Value v_out = null;
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.String)) {
+ Eina.Value v_out = null;
v.Set("hello!");
obj.SetValuePtr(v);
obj.OutValuePtr(out v_out);
Test.AssertEquals(v, v_out);
- Test.AssertEquals(eina.Ownership.Unmanaged, v_out.Ownership);
+ Test.AssertEquals(Eina.Ownership.Unmanaged, v_out.Ownership);
}
}
public static void TestEolianEinaValueOutOwn()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
- using (eina.Value v = new eina.Value(eina.ValueType.String)) {
- eina.Value v_out = null;
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.String)) {
+ Eina.Value v_out = null;
v.Set("hello!");
obj.SetValuePtr(v);
obj.OutValuePtrOwn(out v_out);
Test.AssertEquals(v, v_out);
- Test.AssertEquals(eina.Ownership.Managed, v_out.Ownership);
+ Test.AssertEquals(Eina.Ownership.Managed, v_out.Ownership);
}
}
public static void TestEolianEinaValueOutByValue()
{
- test.ITesting obj = new test.Testing();
+ var obj = new Dummy.TestObject();
- using (eina.Value v = new eina.Value(eina.ValueType.String)) {
- eina.Value v_out = null;
+ using (Eina.Value v = new Eina.Value(Eina.ValueType.String)) {
+ Eina.Value v_out = null;
v.Set("hello!");
obj.SetValue(v);
obj.OutValue(out v_out);
Test.AssertEquals(v, v_out);
- Test.AssertEquals(eina.Ownership.Managed, v_out.Ownership);
+ Test.AssertEquals(Eina.Ownership.Managed, v_out.Ownership);
}
}
- private class ValueHandler : test.TestingInherit
+ private class ValueHandler : Dummy.TestObject
{
- public eina.Value value;
+ public Eina.Value value;
public ValueHandler() : base(null)
{
value = null;
}
- public override void SetValue(eina.Value value)
+ public override void SetValue(Eina.Value value)
{
this.value = value;
}
public static void TestEolianEinaValueByValueConst()
{
ValueHandler obj = new ValueHandler();
- using (eina.Value val = new eina.Value(eina.ValueType.String)) {
+ using (Eina.Value val = new Eina.Value(Eina.ValueType.String)) {
obj.CallSetValue(val);
Test.AssertEquals(val, obj.value);
}
--- /dev/null
+interface Dummy.Another_Iface ()
+{
+ methods {
+ emit_another_conflicted {
+ }
+ }
+ events {
+ conflicted: void;
+ }
+}
import eina_types;
-class Test.Child extends Test.Testing {
+class Dummy.Child extends Dummy.Test_Object {
implements {
class.constructor;
-class Test.Numberwrapper extends Efl.Object {
+class Dummy.Numberwrapper extends Efl.Object {
methods {
@property number {
get {
--- /dev/null
+interface Dummy.Test_Iface ()
+{
+ methods {
+ emit_test_conflicted {
+ }
+ emit_nonconflicted {
+ }
+ }
+ events {
+ conflicted: void;
+ nonconflicted: void;
+ }
+}
import eina_types;
-type Test.MyInt: int;
+type Dummy.MyInt: int;
-enum Test.SampleEnum {
+enum Dummy.SampleEnum {
v0,
v1,
v2,
v4,
}
-struct Test.StructSimple
+struct Dummy.StructSimple
{
fbyte: byte;
fubyte: ubyte;
fdouble: double;
fbool: bool;
fvoid_ptr: void_ptr;
- fenum: Test.SampleEnum;
+ fenum: Dummy.SampleEnum;
// fboolptr: ptr(bool); // TODO
// fbyteptr: ptr(byte);
// fubyteptr: ptr(ubyte);
// ffloatptr: ptr(float);
// fdoubleptr: ptr(double);
// fvoid_ptrptr: ptr(void_ptr);
- // fenumptr: ptr(Test.SampleEnum);
+ // fenumptr: ptr(Dummy.SampleEnum);
fstring: string;
fmstring: mstring;
fstringshare: stringshare;
- fmyint: Test.MyInt;
+ fmyint: Dummy.MyInt;
}
-struct Test.StructComplex {
+struct Dummy.StructComplex {
farray: array<ptr(int)>;
finarray: inarray<int>;
flist: list<string>;
fbinbuf: ptr(Eina.Binbuf);
fslice: Eina.Slice;
// fslice: ptr(Eina.Slice); // TODO
- fobj: Test.Numberwrapper;
+ fobj: Dummy.Numberwrapper;
}
-function Test.SimpleCb {
+function Dummy.SimpleCb {
params {
a: int;
}
return: int;
};
-function Test.FormatCb {
+function Dummy.FormatCb {
params {
@in str: strbuf;
@in value: const(any_value);
}
};
-class Test.Testing extends Efl.Object implements Efl.Part {
+class Dummy.Test_Object extends Efl.Object implements Efl.Part, Dummy.Test_Iface, Dummy.Another_Iface {
parts {
- part1: Test.Testing; [[ Part number one. ]]
- part2: Test.Testing; [[ Part number two. ]]
+ part_one: Dummy.Test_Object; [[ Part number one. ]]
+ part_two: Dummy.Test_Object; [[ Part number two. ]]
}
methods {
return_object {
- return: Test.Testing;
+ return: Dummy.Test_Object;
}
int_out {
/* Object */
eina_array_obj_in {
params {
- @in arr: array<Test.Numberwrapper>;
+ @in arr: array<Dummy.Numberwrapper>;
}
return: bool;
}
eina_array_obj_in_own {
params {
- @in arr: array<Test.Numberwrapper @owned> @owned;
+ @in arr: array<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_array_obj_out {
params {
- @out arr: array<Test.Numberwrapper>;
+ @out arr: array<Dummy.Numberwrapper>;
}
return: bool;
}
eina_array_obj_out_own {
params {
- @out arr: array<Test.Numberwrapper @owned> @owned;
+ @out arr: array<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_array_obj_return {
- return: array<Test.Numberwrapper>;
+ return: array<Dummy.Numberwrapper>;
}
check_eina_array_obj_return {
return: bool;
}
eina_array_obj_return_own {
- return: array<Test.Numberwrapper @owned> @owned;
+ return: array<Dummy.Numberwrapper @owned> @owned;
}
eina_array_obj_return_in {
params {
- @in arr: array<Test.Numberwrapper>;
+ @in arr: array<Dummy.Numberwrapper>;
}
- return: array<Test.Numberwrapper>;
+ return: array<Dummy.Numberwrapper>;
}
/* Eina Inarray */
/* Object */
eina_inarray_obj_in {
params {
- @in arr: inarray<Test.Numberwrapper>;
+ @in arr: inarray<Dummy.Numberwrapper>;
}
return: bool;
}
eina_inarray_obj_in_own {
params {
- @in arr: inarray<Test.Numberwrapper @owned> @owned;
+ @in arr: inarray<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_inarray_obj_out {
params {
- @out arr: inarray<Test.Numberwrapper>;
+ @out arr: inarray<Dummy.Numberwrapper>;
}
return: bool;
}
eina_inarray_obj_out_own {
params {
- @out arr: inarray<Test.Numberwrapper @owned> @owned;
+ @out arr: inarray<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_inarray_obj_return {
- return: inarray<Test.Numberwrapper>;
+ return: inarray<Dummy.Numberwrapper>;
}
check_eina_inarray_obj_return {
return: bool;
}
eina_inarray_obj_return_own {
- return: inarray<Test.Numberwrapper @owned> @owned;
+ return: inarray<Dummy.Numberwrapper @owned> @owned;
}
eina_inarray_obj_return_in {
params {
- @in arr: inarray<Test.Numberwrapper>;
+ @in arr: inarray<Dummy.Numberwrapper>;
}
- return: inarray<Test.Numberwrapper>;
+ return: inarray<Dummy.Numberwrapper>;
}
/* Eina List */
/* Object */
eina_list_obj_in {
params {
- @in lst: list<Test.Numberwrapper>;
+ @in lst: list<Dummy.Numberwrapper>;
}
return: bool;
}
eina_list_obj_in_own {
params {
- @in lst: list<Test.Numberwrapper @owned> @owned;
+ @in lst: list<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_list_obj_out {
params {
- @out lst: list<Test.Numberwrapper>;
+ @out lst: list<Dummy.Numberwrapper>;
}
return: bool;
}
eina_list_obj_out_own {
params {
- @out lst: list<Test.Numberwrapper @owned> @owned;
+ @out lst: list<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_list_obj_return {
- return: list<Test.Numberwrapper>;
+ return: list<Dummy.Numberwrapper>;
}
check_eina_list_obj_return {
return: bool;
}
eina_list_obj_return_own {
- return: list<Test.Numberwrapper @owned> @owned;
+ return: list<Dummy.Numberwrapper @owned> @owned;
}
eina_list_obj_return_in {
params {
- @in lst: list<Test.Numberwrapper>;
+ @in lst: list<Dummy.Numberwrapper>;
}
- return: list<Test.Numberwrapper>;
+ return: list<Dummy.Numberwrapper>;
}
/* Eina Inlist */
/* Object */
eina_inlist_obj_in {
params {
- @in lst: inlist<Test.Numberwrapper>;
+ @in lst: inlist<Dummy.Numberwrapper>;
}
return: bool;
}
eina_inlist_obj_in_own {
params {
- @in lst: inlist<Test.Numberwrapper @owned> @owned;
+ @in lst: inlist<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_inlist_obj_out {
params {
- @out lst: inlist<Test.Numberwrapper>;
+ @out lst: inlist<Dummy.Numberwrapper>;
}
return: bool;
}
eina_inlist_obj_out_own {
params {
- @out lst: inlist<Test.Numberwrapper @owned> @owned;
+ @out lst: inlist<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_inlist_obj_return {
- return: inlist<Test.Numberwrapper>;
+ return: inlist<Dummy.Numberwrapper>;
}
check_eina_inlist_obj_return {
return: bool;
}
eina_inlist_obj_return_own {
- return: inlist<Test.Numberwrapper @owned> @owned;
+ return: inlist<Dummy.Numberwrapper @owned> @owned;
}
eina_inlist_obj_return_in {
params {
- @in lst: inlist<Test.Numberwrapper>;
+ @in lst: inlist<Dummy.Numberwrapper>;
}
- return: inlist<Test.Numberwrapper>;
+ return: inlist<Dummy.Numberwrapper>;
}
// Object //
eina_hash_obj_in {
params {
- @in hsh: hash<Test.Numberwrapper, Test.Numberwrapper>;
- @in nwk1: Test.Numberwrapper;
- @in nwv1: Test.Numberwrapper;
- @out nwk2: Test.Numberwrapper;
- @out nwv2: Test.Numberwrapper;
+ @in hsh: hash<Dummy.Numberwrapper, Dummy.Numberwrapper>;
+ @in nwk1: Dummy.Numberwrapper;
+ @in nwv1: Dummy.Numberwrapper;
+ @out nwk2: Dummy.Numberwrapper;
+ @out nwv2: Dummy.Numberwrapper;
}
return: bool;
}
eina_hash_obj_in_own {
params {
- @in hsh: hash<Test.Numberwrapper, Test.Numberwrapper @owned> @owned;
- @in nwk1: Test.Numberwrapper;
- @in nwv1: Test.Numberwrapper;
- @out nwk2: Test.Numberwrapper;
- @out nwv2: Test.Numberwrapper;
+ @in hsh: hash<Dummy.Numberwrapper, Dummy.Numberwrapper @owned> @owned;
+ @in nwk1: Dummy.Numberwrapper;
+ @in nwv1: Dummy.Numberwrapper;
+ @out nwk2: Dummy.Numberwrapper;
+ @out nwv2: Dummy.Numberwrapper;
}
return: bool;
}
check_eina_hash_obj_in_own {
params {
- @in nwk1: Test.Numberwrapper;
- @in nwv1: Test.Numberwrapper;
- @in nwk2: Test.Numberwrapper;
- @in nwv2: Test.Numberwrapper;
+ @in nwk1: Dummy.Numberwrapper;
+ @in nwv1: Dummy.Numberwrapper;
+ @in nwk2: Dummy.Numberwrapper;
+ @in nwv2: Dummy.Numberwrapper;
}
return: bool;
}
eina_hash_obj_out {
params {
- @out hsh: hash<Test.Numberwrapper, Test.Numberwrapper>;
- @out nwk: Test.Numberwrapper;
- @out nwv: Test.Numberwrapper;
+ @out hsh: hash<Dummy.Numberwrapper, Dummy.Numberwrapper>;
+ @out nwk: Dummy.Numberwrapper;
+ @out nwv: Dummy.Numberwrapper;
}
return: bool;
}
check_eina_hash_obj_out {
params {
- @in nwk1: Test.Numberwrapper;
- @in nwv1: Test.Numberwrapper;
- @in nwk2: Test.Numberwrapper;
- @in nwv2: Test.Numberwrapper;
+ @in nwk1: Dummy.Numberwrapper;
+ @in nwv1: Dummy.Numberwrapper;
+ @in nwk2: Dummy.Numberwrapper;
+ @in nwv2: Dummy.Numberwrapper;
}
return: bool;
}
eina_hash_obj_out_own {
params {
- @out hsh: hash<Test.Numberwrapper, Test.Numberwrapper @owned> @owned;
- @out nwk: Test.Numberwrapper;
- @out nwv: Test.Numberwrapper;
+ @out hsh: hash<Dummy.Numberwrapper, Dummy.Numberwrapper @owned> @owned;
+ @out nwk: Dummy.Numberwrapper;
+ @out nwv: Dummy.Numberwrapper;
}
return: bool;
}
eina_hash_obj_return {
params {
- @out nwk: Test.Numberwrapper;
- @out nwv: Test.Numberwrapper;
+ @out nwk: Dummy.Numberwrapper;
+ @out nwv: Dummy.Numberwrapper;
}
- return: hash<Test.Numberwrapper, Test.Numberwrapper>;
+ return: hash<Dummy.Numberwrapper, Dummy.Numberwrapper>;
}
check_eina_hash_obj_return {
params {
- @in nwk1: Test.Numberwrapper;
- @in nwv1: Test.Numberwrapper;
- @in nwk2: Test.Numberwrapper;
- @in nwv2: Test.Numberwrapper;
+ @in nwk1: Dummy.Numberwrapper;
+ @in nwv1: Dummy.Numberwrapper;
+ @in nwk2: Dummy.Numberwrapper;
+ @in nwv2: Dummy.Numberwrapper;
}
return: bool;
}
eina_hash_obj_return_own {
params {
- @out nwk: Test.Numberwrapper;
- @out nwv: Test.Numberwrapper;
+ @out nwk: Dummy.Numberwrapper;
+ @out nwv: Dummy.Numberwrapper;
}
- return: hash<Test.Numberwrapper, Test.Numberwrapper @owned> @owned;
+ return: hash<Dummy.Numberwrapper, Dummy.Numberwrapper @owned> @owned;
}
check_eina_hash_obj_return_own {
return: bool;
/* Object */
eina_iterator_obj_in {
params {
- @in itr: iterator<Test.Numberwrapper>;
+ @in itr: iterator<Dummy.Numberwrapper>;
}
return: bool;
}
eina_iterator_obj_in_own {
params {
- @in itr: iterator<Test.Numberwrapper @owned> @owned;
+ @in itr: iterator<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_iterator_obj_out {
params {
- @out itr: iterator<Test.Numberwrapper>;
+ @out itr: iterator<Dummy.Numberwrapper>;
}
return: bool;
}
eina_iterator_obj_out_own {
params {
- @out itr: iterator<Test.Numberwrapper @owned> @owned;
+ @out itr: iterator<Dummy.Numberwrapper @owned> @owned;
}
return: bool;
}
eina_iterator_obj_return {
- return: iterator<Test.Numberwrapper>;
+ return: iterator<Dummy.Numberwrapper>;
}
check_eina_iterator_obj_return {
return: bool;
}
eina_iterator_obj_return_own {
- return: iterator<Test.Numberwrapper @owned> @owned;
+ return: iterator<Dummy.Numberwrapper @owned> @owned;
}
/* Function Pointer */
set_callback {
params {
- cb: Test.SimpleCb;
+ cb: Dummy.SimpleCb;
}
}
struct_simple_in {
params {
- @in simple: Test.StructSimple;
+ @in simple: Dummy.StructSimple;
}
return: bool;
}
struct_simple_ptr_in {
params {
- @in simple: ptr(Test.StructSimple);
+ @in simple: ptr(Dummy.StructSimple);
}
return: bool;
}
struct_simple_ptr_in_own {
params {
- @in simple: ptr(Test.StructSimple) @owned;
+ @in simple: ptr(Dummy.StructSimple) @owned;
}
- return: Test.StructSimple;
+ return: Dummy.StructSimple;
}
struct_simple_out {
params {
- @out simple: Test.StructSimple;
+ @out simple: Dummy.StructSimple;
}
return: bool;
}
struct_simple_ptr_out {
params {
- @out simple: ptr(Test.StructSimple);
+ @out simple: ptr(Dummy.StructSimple);
}
- return: Test.StructSimple;
+ return: Dummy.StructSimple;
}
struct_simple_ptr_out_own {
params {
- @out simple: ptr(Test.StructSimple) @owned;
+ @out simple: ptr(Dummy.StructSimple) @owned;
}
- return: Test.StructSimple;
+ return: Dummy.StructSimple;
}
struct_simple_return {
- return: Test.StructSimple;
+ return: Dummy.StructSimple;
}
struct_simple_ptr_return {
- return: ptr(Test.StructSimple);
+ return: ptr(Dummy.StructSimple);
}
struct_simple_ptr_return_own {
- return: ptr(Test.StructSimple) @owned;
+ return: ptr(Dummy.StructSimple) @owned;
}
call_struct_simple_in {
params {
- @in simple: Test.StructSimple;
+ @in simple: Dummy.StructSimple;
}
}
call_struct_simple_ptr_in {
params {
- @in simple: ptr(Test.StructSimple);
+ @in simple: ptr(Dummy.StructSimple);
}
}
call_struct_simple_ptr_in_own {
params {
- @in simple: ptr(Test.StructSimple) @owned;
+ @in simple: ptr(Dummy.StructSimple) @owned;
}
}
call_struct_simple_out {
params {
- @out simple: Test.StructSimple;
+ @out simple: Dummy.StructSimple;
}
}
call_struct_simple_ptr_out {
params {
- @out simple: ptr(Test.StructSimple);
+ @out simple: ptr(Dummy.StructSimple);
}
}
call_struct_simple_ptr_out_own {
params {
- @out simple: ptr(Test.StructSimple) @owned;
+ @out simple: ptr(Dummy.StructSimple) @owned;
}
}
call_struct_simple_return {
- return: Test.StructSimple;
+ return: Dummy.StructSimple;
}
call_struct_simple_ptr_return {
- return: ptr(Test.StructSimple);
+ return: ptr(Dummy.StructSimple);
}
call_struct_simple_ptr_return_own {
- return: ptr(Test.StructSimple) @owned;
+ return: ptr(Dummy.StructSimple) @owned;
}
struct_complex_in {
params {
- @in complex: Test.StructComplex;
+ @in complex: Dummy.StructComplex;
}
return: bool;
}
struct_complex_ptr_in {
params {
- @in complex: ptr(Test.StructComplex);
+ @in complex: ptr(Dummy.StructComplex);
}
return: bool;
}
struct_complex_ptr_in_own {
params {
- @in complex: ptr(Test.StructComplex) @owned;
+ @in complex: ptr(Dummy.StructComplex) @owned;
}
return: bool;
}
struct_complex_out {
params {
- @out complex: Test.StructComplex;
+ @out complex: Dummy.StructComplex;
}
return: bool;
}
// struct_complex_ptr_out {
// params {
- // @out complex: ptr(Test.StructComplex);
+ // @out complex: ptr(Dummy.StructComplex);
// }
// return: bool;
// }
//
// struct_complex_ptr_out_own {
// params {
- // @out complex: ptr(Test.StructComplex) @owned;
+ // @out complex: ptr(Dummy.StructComplex) @owned;
// }
// return: bool;
// }
struct_complex_return {
- return: Test.StructComplex;
+ return: Dummy.StructComplex;
}
// struct_complex_ptr_return {
- // return: ptr(Test.StructComplex);
+ // return: ptr(Dummy.StructComplex);
// }
//
// struct_complex_ptr_return_own {
- // return: ptr(Test.StructComplex) @owned;
+ // return: ptr(Dummy.StructComplex) @owned;
// }
emit_event_with_string {
}
emit_event_with_obj {
params {
- @in data: Test.Testing;
+ @in data: Dummy.Test_Object;
}
}
emit_event_with_struct {
params {
- @in data: Test.StructSimple;
+ @in data: Dummy.StructSimple;
}
}
params {
@in str: strbuf;
@in value: const(any_value);
- @in func: Test.FormatCb;
+ @in func: Dummy.FormatCb;
}
}
bypass_typedef {
params {
- @in data: Test.MyInt;
- @out receiver: Test.MyInt;
+ @in data: Dummy.MyInt;
+ @out receiver: Dummy.MyInt;
}
- return: Test.MyInt;
+ return: Dummy.MyInt;
}
@property klass_prop @class {
class.destructor;
Efl.Object.constructor;
Efl.Part.part_get;
+ Dummy.Test_Iface.emit_test_conflicted;
+ Dummy.Test_Iface.emit_nonconflicted;
+ Dummy.Another_Iface.emit_another_conflicted;
}
events {
evt,with,string @hot: string;
evt,with,bool: bool;
evt,with,int @hot: int;
evt,with,uint @hot: uint;
- evt,with,obj @hot: Test.Testing;
+ evt,with,obj @hot: Dummy.Test_Object;
evt,with,error @hot: Eina.Error;
- evt,with,struct @hot: Test.StructSimple;
+ evt,with,struct @hot: Dummy.StructSimple;
}
}
# endif
#endif
-#include "test_numberwrapper.eo.h"
-#include "test_testing.eo.h"
+#include "dummy_numberwrapper.eo.h"
+#include "dummy_test_object.eo.h"
+#include "dummy_test_iface.eo.h"
+#include "dummy_another_iface.eo.h"
#include <interfaces/efl_part.eo.h>
#define EQUAL(a, b) ((a) == (b) ? 1 : (fprintf(stderr, "NOT EQUAL! %s:%i (%s)", __FILE__, __LINE__, __FUNCTION__), fflush(stderr), 0))
#define STR_EQUAL(a, b) (strcmp((a), (b)) == 0 ? 1 : (fprintf(stderr, "NOT EQUAL! %s:%i (%s) '%s' != '%s'", __FILE__, __LINE__, __FUNCTION__, (a), (b)), fflush(stderr), 0))
-typedef struct Test_Testing_Data
+typedef struct Dummy_Test_Object_Data
{
- Test_SimpleCb cb;
+ Dummy_SimpleCb cb;
void *cb_data;
Eina_Free_Cb free_cb;
Eina_Error error_code;
Eina_Value *stored_value;
- Test_StructSimple stored_struct;
+ Dummy_StructSimple stored_struct;
int stored_int;
- Eo *part1;
- Eo *part2;
+ Eo *part_one;
+ Eo *part_two;
Eina_Promise *promise;
Eina_List *list_for_accessor;
-} Test_Testing_Data;
+} Dummy_Test_Object_Data;
-typedef struct Test_Numberwrapper_Data
+typedef struct Dummy_Numberwrapper_Data
{
int number;
-} Test_Numberwrapper_Data;
+} Dummy_Numberwrapper_Data;
static
}
static
-Test_Numberwrapper *_new_obj(int n)
+Dummy_Numberwrapper *_new_obj(int n)
{
- return efl_add_ref(TEST_NUMBERWRAPPER_CLASS, NULL, test_numberwrapper_number_set(efl_added, n));
+ return efl_add_ref(DUMMY_NUMBERWRAPPER_CLASS, NULL, dummy_numberwrapper_number_set(efl_added, n));
}
static
-Test_Numberwrapper **_new_obj_ref(int n)
+Dummy_Numberwrapper **_new_obj_ref(int n)
{
- static Test_Numberwrapper *r;
+ static Dummy_Numberwrapper *r;
r = _new_obj(n);
return &r;
}
// ############ //
static Efl_Object*
-_test_testing_efl_object_constructor(Eo *obj, Test_Testing_Data *pd)
+_dummy_test_object_efl_object_constructor(Eo *obj, Dummy_Test_Object_Data *pd)
{
- efl_constructor(efl_super(obj, TEST_TESTING_CLASS));
+ efl_constructor(efl_super(obj, DUMMY_TEST_OBJECT_CLASS));
// To avoid an infinite loop calling the same constructor
if (!efl_parent_get(obj))
{
- pd->part1 = efl_add(TEST_TESTING_CLASS, obj, efl_name_set(efl_added, "part1"));
- pd->part2 = efl_add(TEST_TESTING_CLASS, obj, efl_name_set(efl_added, "part2"));
+ pd->part_one = efl_add(DUMMY_TEST_OBJECT_CLASS, obj, efl_name_set(efl_added, "part_one"));
+ pd->part_two = efl_add(DUMMY_TEST_OBJECT_CLASS, obj, efl_name_set(efl_added, "part_two"));
}
return obj;
}
-Efl_Object *_test_testing_return_object(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Efl_Object *_dummy_test_object_return_object(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return obj;
}
-void _test_testing_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, int x, int *y)
+void _dummy_test_object_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, int x, int *y)
{
*y = -x;
}
-void _test_testing_int_ptr_out(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, int x, int **y)
+void _dummy_test_object_int_ptr_out(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, int x, int **y)
{
pd->stored_int = x * 2;
*y = &pd->stored_int;
}
-const char *_test_testing_in_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char *str)
+const char *_dummy_test_object_in_string(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, const char *str)
{
const char *ret = malloc(sizeof(char)*(strlen(str) + 1));
return strcpy((char*)ret, str);
}
-char *_test_testing_in_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, char *str)
+char *_dummy_test_object_in_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, char *str)
{
char *ret = malloc(sizeof(char)*(strlen(str) + 1));
strcpy(ret, str);
return ret;
}
-Eina_Stringshare *_test_testing_return_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Stringshare *_dummy_test_object_return_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Stringshare *str = eina_stringshare_add("stringshare");
return str;
}
-Eina_Stringshare *_test_testing_return_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Stringshare *_dummy_test_object_return_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Stringshare *str = eina_stringshare_add("own_stringshare");
return str;
}
-const char *_test_testing_return_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+const char *_dummy_test_object_return_string(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return "string";
}
-const char *_test_testing_return_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+const char *_dummy_test_object_return_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
static const char* reference = "own_string";
const char *ret = malloc(sizeof(char)*(strlen(reference) + 1));
return strcpy((char*)ret, reference);
}
-void _test_testing_out_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char**str)
+void _dummy_test_object_out_string(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, const char**str)
{
*str = "out_string";
}
-void _test_testing_out_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char**str)
+void _dummy_test_object_out_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, const char**str)
{
static const char* reference = "out_own_string";
*str = malloc(sizeof(char)*(strlen(reference) + 1));
strcpy((char*)*str, reference);
}
-void _test_testing_call_in_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char *str)
+void _dummy_test_object_call_in_string(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, const char *str)
{
- test_testing_in_string(obj, str);
+ dummy_test_object_in_string(obj, str);
}
-void _test_testing_call_in_own_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, char *str)
+void _dummy_test_object_call_in_own_string(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, char *str)
{
- test_testing_in_own_string(obj, str);
+ dummy_test_object_in_own_string(obj, str);
}
-const char *_test_testing_call_return_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+const char *_dummy_test_object_call_return_string(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_return_string(obj);
+ return dummy_test_object_return_string(obj);
}
-const char *_test_testing_call_return_own_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+const char *_dummy_test_object_call_return_own_string(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_return_own_string(obj);
+ return dummy_test_object_return_own_string(obj);
}
-const char *_test_testing_call_out_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+const char *_dummy_test_object_call_out_string(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
const char *ret = NULL;
- test_testing_out_string(obj, &ret);
+ dummy_test_object_out_string(obj, &ret);
return ret;
}
-const char *_test_testing_call_out_own_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+const char *_dummy_test_object_call_out_own_string(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
const char *ret = NULL;
- test_testing_out_own_string(obj, &ret);
+ dummy_test_object_out_own_string(obj, &ret);
return ret;
}
// Stringshare virtual test helpers
-void _test_testing_call_in_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Stringshare *str)
+void _dummy_test_object_call_in_stringshare(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Stringshare *str)
{
- test_testing_in_stringshare(obj, str);
+ dummy_test_object_in_stringshare(obj, str);
}
-void _test_testing_call_in_own_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Stringshare *str)
+void _dummy_test_object_call_in_own_stringshare(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Stringshare *str)
{
- str = test_testing_in_own_stringshare(obj, str);
+ str = dummy_test_object_in_own_stringshare(obj, str);
eina_stringshare_del(str);
}
-Eina_Stringshare *_test_testing_in_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Stringshare *str)
+Eina_Stringshare *_dummy_test_object_in_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Stringshare *str)
{
return eina_stringshare_add(str);
}
-Eina_Stringshare *_test_testing_in_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Stringshare *str)
+Eina_Stringshare *_dummy_test_object_in_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Stringshare *str)
{
return str;
}
-void _test_testing_out_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char**str)
+void _dummy_test_object_out_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, const char**str)
{
// Returning simple string but the binding shouldn't del it as it is not owned by the caller
*str = "out_stringshare";
}
-void _test_testing_out_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char**str)
+void _dummy_test_object_out_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, const char**str)
{
*str = eina_stringshare_add("out_own_stringshare");
}
-Eina_Stringshare *_test_testing_call_return_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Stringshare *_dummy_test_object_call_return_stringshare(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_return_stringshare(obj);
+ return dummy_test_object_return_stringshare(obj);
}
-Eina_Stringshare *_test_testing_call_return_own_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Stringshare *_dummy_test_object_call_return_own_stringshare(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_return_own_stringshare(obj);
+ return dummy_test_object_return_own_stringshare(obj);
}
-Eina_Stringshare *_test_testing_call_out_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Stringshare *_dummy_test_object_call_out_stringshare(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Stringshare *ret = NULL;
- test_testing_out_stringshare(obj, &ret);
+ dummy_test_object_out_stringshare(obj, &ret);
return ret;
}
-Eina_Stringshare *_test_testing_call_out_own_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Stringshare *_dummy_test_object_call_out_own_stringshare(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Stringshare *ret = NULL;
- test_testing_out_own_stringshare(obj, &ret);
+ dummy_test_object_out_own_stringshare(obj, &ret);
return ret;
}
return out;
}
-Eina_Bool _test_testing_eina_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Slice slice)
+Eina_Bool _dummy_test_object_eina_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Slice slice)
{
uint8_t *buf = memdup(slice.mem, slice.len);
free(buf);
return 0 == memcmp(slice.mem, base_seq, slice.len);
}
-Eina_Bool _test_testing_eina_rw_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Rw_Slice slice)
+Eina_Bool _dummy_test_object_eina_rw_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Rw_Slice slice)
{
Eina_Bool r = (0 == memcmp(slice.mem, base_seq, slice.len));
unsigned char *buf = memdup(slice.mem, slice.len);
return r;
}
-Eina_Bool _test_testing_eina_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Slice *slice)
+Eina_Bool _dummy_test_object_eina_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Slice *slice)
{
if (!slice) return EINA_FALSE;
static const Eina_Slice slc = EINA_SLICE_ARRAY(base_seq);
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_rw_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Rw_Slice *slice)
+Eina_Bool _dummy_test_object_eina_rw_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Rw_Slice *slice)
{
if (!slice) return EINA_FALSE;
slice->len = 3;
return EINA_TRUE;
}
-Eina_Slice _test_testing_eina_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Slice _dummy_test_object_eina_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Slice slc = EINA_SLICE_ARRAY(base_seq);
return slc;
}
-Eina_Rw_Slice _test_testing_eina_rw_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Rw_Slice _dummy_test_object_eina_rw_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Rw_Slice slc = { .len = 3, .mem = memdup(base_seq, 3) };
return slc;
}
-Eina_Bool _test_testing_eina_binbuf_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf)
+Eina_Bool _dummy_test_object_eina_binbuf_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Binbuf *binbuf)
{
Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_seq, eina_binbuf_length_get(binbuf)));
eina_binbuf_insert_char(binbuf, 42, 0);
return r;
}
-Eina_Bool _test_testing_call_eina_binbuf_in(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf)
+Eina_Bool _dummy_test_object_call_eina_binbuf_in(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Binbuf *binbuf)
{
- return test_testing_eina_binbuf_in(obj, binbuf);
+ return dummy_test_object_eina_binbuf_in(obj, binbuf);
}
Eina_Binbuf *_binbuf_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf)
+Eina_Bool _dummy_test_object_eina_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Binbuf *binbuf)
{
Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_seq, eina_binbuf_length_get(binbuf)));
eina_binbuf_insert_char(binbuf, 42, 0);
return r;
}
-Eina_Bool _test_testing_call_eina_binbuf_in_own(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf)
+Eina_Bool _dummy_test_object_call_eina_binbuf_in_own(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Binbuf *binbuf)
{
- return test_testing_eina_binbuf_in_own(obj, binbuf);
+ return dummy_test_object_eina_binbuf_in_own(obj, binbuf);
}
-Eina_Bool _test_testing_check_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_binbuf_in_own_to_check) return EINA_FALSE;
const uint8_t mod_seq[] = {43,42,0x0,0x2A,0x42,33};
Eina_Binbuf *_binbuf_out_to_check = NULL;
-Eina_Bool _test_testing_eina_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf **binbuf)
+Eina_Bool _dummy_test_object_eina_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Binbuf **binbuf)
{
if (!binbuf) return EINA_FALSE;
*binbuf = eina_binbuf_new();
return EINA_TRUE;
}
-Eina_Binbuf *_test_testing_call_eina_binbuf_out(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Binbuf *_dummy_test_object_call_eina_binbuf_out(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Binbuf *binbuf = NULL;
- test_testing_eina_binbuf_out(obj, &binbuf);
+ dummy_test_object_eina_binbuf_out(obj, &binbuf);
return binbuf;
}
-Eina_Bool _test_testing_check_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_binbuf_out_to_check) return EINA_FALSE;
return 0 == memcmp(eina_binbuf_string_get(_binbuf_out_to_check), base_seq, eina_binbuf_length_get(_binbuf_out_to_check));
}
-Eina_Bool _test_testing_eina_binbuf_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf **binbuf)
+Eina_Bool _dummy_test_object_eina_binbuf_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Binbuf **binbuf)
{
if (!binbuf) return EINA_FALSE;
*binbuf = eina_binbuf_new();
return EINA_TRUE;
}
-Eina_Binbuf *_test_testing_call_eina_binbuf_out_own(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Binbuf *_dummy_test_object_call_eina_binbuf_out_own(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Binbuf *binbuf = NULL;
- test_testing_eina_binbuf_out_own(obj, &binbuf);
+ dummy_test_object_eina_binbuf_out_own(obj, &binbuf);
return binbuf;
}
Eina_Binbuf *_binbuf_return_to_check = NULL;
-Eina_Binbuf *_test_testing_eina_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Binbuf *_dummy_test_object_eina_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Binbuf *binbuf = eina_binbuf_new();
eina_binbuf_append_char(binbuf, 33);
return binbuf;
}
-Eina_Binbuf *_test_testing_call_eina_binbuf_return(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Binbuf *_dummy_test_object_call_eina_binbuf_return(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_eina_binbuf_return(obj);
+ return dummy_test_object_eina_binbuf_return(obj);
}
-Eina_Bool _test_testing_check_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_binbuf_return_to_check) return EINA_FALSE;
return 0 == memcmp(eina_binbuf_string_get(_binbuf_return_to_check), base_seq, eina_binbuf_length_get(_binbuf_return_to_check));
}
-Eina_Binbuf *_test_testing_eina_binbuf_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Binbuf *_dummy_test_object_eina_binbuf_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Binbuf *binbuf = eina_binbuf_new();
eina_binbuf_append_char(binbuf, 33);
return binbuf;
}
-Eina_Binbuf *_test_testing_call_eina_binbuf_return_own(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Binbuf *_dummy_test_object_call_eina_binbuf_return_own(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_eina_binbuf_return_own(obj);
+ return dummy_test_object_eina_binbuf_return_own(obj);
}
static const char * const modified_seq_str[] = {"0x0","0x2A","0x42","42","43","33"};
static const unsigned int modified_seq_str_size = EINA_C_ARRAY_LENGTH(modified_seq_str);
-static const Test_Numberwrapper *base_seq_obj[] = {NULL,NULL,NULL};
+static const Dummy_Numberwrapper *base_seq_obj[] = {NULL,NULL,NULL};
static const unsigned int base_seq_obj_size = EINA_C_ARRAY_LENGTH(base_seq_str);
-static const Test_Numberwrapper *modified_seq_obj[] = {NULL,NULL,NULL,NULL,NULL,NULL};
+static const Dummy_Numberwrapper *modified_seq_obj[] = {NULL,NULL,NULL,NULL,NULL,NULL};
static const unsigned int modified_seq_obj_size = EINA_C_ARRAY_LENGTH(modified_seq_str);
// //
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_array_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+Eina_Bool _dummy_test_object_eina_array_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
Eina_Bool r = _array_int_equal(arr, base_seq_int, base_seq_int_size);
eina_array_push(arr, _new_int(42));
static Eina_Array *_array_int_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+Eina_Bool _dummy_test_object_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
Eina_Bool r = _array_int_equal(arr, base_seq_int, base_seq_int_size);
eina_array_push(arr, _new_int(42));
return r;
}
-Eina_Bool _test_testing_check_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_int_in_own_to_check) return EINA_FALSE;
Eina_Array *_array_int_out_to_check = NULL;
-Eina_Bool _test_testing_eina_array_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+Eina_Bool _dummy_test_object_eina_array_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_array_new(default_step);
_array_int_out_to_check = *arr;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_array_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_int_out_to_check) return EINA_FALSE;
return r;
}
-Eina_Bool _test_testing_eina_array_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+Eina_Bool _dummy_test_object_eina_array_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_array_new(default_step);
Eina_Array *_array_int_return_to_check = NULL;
-Eina_Array *_test_testing_eina_array_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Array *_dummy_test_object_eina_array_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = eina_array_new(default_step);
eina_array_push(arr, _new_int(0x0));
_array_int_return_to_check = arr;
return arr;
}
-Eina_Bool _test_testing_check_eina_array_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_int_return_to_check) return EINA_FALSE;
return r;
}
-Eina_Array *_test_testing_eina_array_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Array *_dummy_test_object_eina_array_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = eina_array_new(default_step);
eina_array_push(arr, _new_int(0x0));
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_array_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+Eina_Bool _dummy_test_object_eina_array_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
Eina_Bool r = _array_str_equal(arr, base_seq_str, base_seq_str_size);
eina_array_push(arr, strdup("42"));
static Eina_Array *_array_str_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+Eina_Bool _dummy_test_object_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
Eina_Bool r = _array_str_equal(arr, base_seq_str, base_seq_str_size);
eina_array_push(arr, strdup("42"));
return r;
}
-Eina_Bool _test_testing_check_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_str_in_own_to_check) return EINA_FALSE;
Eina_Array *_array_str_out_to_check = NULL;
-Eina_Bool _test_testing_eina_array_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+Eina_Bool _dummy_test_object_eina_array_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_array_new(default_step);
_array_str_out_to_check = *arr;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_array_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_str_out_to_check) return EINA_FALSE;
return r;
}
-Eina_Bool _test_testing_eina_array_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+Eina_Bool _dummy_test_object_eina_array_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_array_new(default_step);
Eina_Array *_array_str_return_to_check = NULL;
-Eina_Array *_test_testing_eina_array_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Array *_dummy_test_object_eina_array_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = eina_array_new(default_step);
eina_array_push(arr, strdup("0x0"));
_array_str_return_to_check = arr;
return arr;
}
-Eina_Bool _test_testing_check_eina_array_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_str_return_to_check) return EINA_FALSE;
return r;
}
-Eina_Array *_test_testing_eina_array_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Array *_dummy_test_object_eina_array_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = eina_array_new(default_step);
eina_array_push(arr, strdup("0x0"));
// Object
-Eina_Bool _array_obj_equal(const Eina_Array *arr, const Test_Numberwrapper * const base[], unsigned int len)
+Eina_Bool _array_obj_equal(const Eina_Array *arr, const Dummy_Numberwrapper * const base[], unsigned int len)
{
if (eina_array_count(arr) != len)
return EINA_FALSE;
for (unsigned int i = 0; i < len; ++i)
{
- const Test_Numberwrapper *eo = eina_array_data_get(arr, i);
- int a = test_numberwrapper_number_get(eo);
- int b = test_numberwrapper_number_get(base[i]);
+ const Dummy_Numberwrapper *eo = eina_array_data_get(arr, i);
+ int a = dummy_numberwrapper_number_get(eo);
+ int b = dummy_numberwrapper_number_get(base[i]);
if (a != b)
return EINA_FALSE;
}
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_array_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+Eina_Bool _dummy_test_object_eina_array_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
Eina_Bool r = _array_obj_equal(arr, base_seq_obj, base_seq_obj_size);
if (!r) return r;
static Eina_Array *_array_obj_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+Eina_Bool _dummy_test_object_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
Eina_Bool r = _array_obj_equal(arr, base_seq_obj, base_seq_obj_size);
if (!r) return r;
return r;
}
-Eina_Bool _test_testing_check_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_obj_in_own_to_check) return EINA_FALSE;
if (!r) return r;
unsigned int i;
- Test_Numberwrapper *ele;
+ Dummy_Numberwrapper *ele;
Eina_Array_Iterator it;
EINA_ARRAY_ITER_NEXT(_array_obj_in_own_to_check, i, ele, it)
efl_unref(ele);
Eina_Array *_array_obj_out_to_check = NULL;
-Eina_Bool _test_testing_eina_array_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+Eina_Bool _dummy_test_object_eina_array_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_array_new(default_step);
_array_obj_out_to_check = *arr;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_array_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_obj_out_to_check) return EINA_FALSE;
if (!r) return r;
unsigned int i;
- Test_Numberwrapper *ele;
+ Dummy_Numberwrapper *ele;
Eina_Array_Iterator it;
EINA_ARRAY_ITER_NEXT(_array_obj_out_to_check, i, ele, it)
efl_unref(ele);
return r;
}
-Eina_Bool _test_testing_eina_array_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+Eina_Bool _dummy_test_object_eina_array_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_array_new(default_step);
Eina_Array *_array_obj_return_to_check = NULL;
-Eina_Array *_test_testing_eina_array_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Array *_dummy_test_object_eina_array_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = eina_array_new(default_step);
eina_array_push(arr, _new_obj(0x0));
_array_obj_return_to_check = arr;
return arr;
}
-Eina_Bool _test_testing_check_eina_array_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_array_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_obj_return_to_check) return EINA_FALSE;
if (!r) return r;
unsigned int i;
- Test_Numberwrapper *ele;
+ Dummy_Numberwrapper *ele;
Eina_Array_Iterator it;
EINA_ARRAY_ITER_NEXT(_array_obj_return_to_check, i, ele, it)
efl_unref(ele);
return r;
}
-Eina_Array *_test_testing_eina_array_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Array *_dummy_test_object_eina_array_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = eina_array_new(default_step);
eina_array_push(arr, _new_obj(0x0));
return arr;
}
-Eina_Array *_test_testing_eina_array_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+Eina_Array *_dummy_test_object_eina_array_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
return arr;
}
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_inarray_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+Eina_Bool _dummy_test_object_eina_inarray_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray *arr)
{
Eina_Bool r = _inarray_int_equal(arr, base_seq_int, base_seq_int_size);
eina_inarray_push(arr, _int_ref(42));
static Eina_Inarray *_inarray_int_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+Eina_Bool _dummy_test_object_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray *arr)
{
Eina_Bool r = _inarray_int_equal(arr, base_seq_int, base_seq_int_size);
eina_inarray_push(arr, _int_ref(42));
_inarray_int_in_own_to_check = arr;
return r;
}
-Eina_Bool _test_testing_check_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_int_in_own_to_check) return EINA_FALSE;
Eina_Inarray *_inarray_int_out_to_check = NULL;
-Eina_Bool _test_testing_eina_inarray_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+Eina_Bool _dummy_test_object_eina_inarray_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_inarray_new(sizeof(int), 0);
_inarray_int_out_to_check = *arr;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_inarray_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_int_out_to_check) return EINA_FALSE;
return r;
}
-Eina_Bool _test_testing_eina_inarray_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+Eina_Bool _dummy_test_object_eina_inarray_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_inarray_new(sizeof(int), 0);
Eina_Inarray *_inarray_int_return_to_check = NULL;
-Eina_Inarray *_test_testing_eina_inarray_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inarray *_dummy_test_object_eina_inarray_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inarray *arr = eina_inarray_new(sizeof(int), 0);
eina_inarray_push(arr, _int_ref(0x0));
_inarray_int_return_to_check = arr;
return arr;
}
-Eina_Bool _test_testing_check_eina_inarray_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_int_return_to_check) return EINA_FALSE;
return r;
}
-Eina_Inarray *_test_testing_eina_inarray_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inarray *_dummy_test_object_eina_inarray_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inarray *arr = eina_inarray_new(sizeof(int), 0);
eina_inarray_push(arr, _int_ref(0x0));
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_inarray_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+Eina_Bool _dummy_test_object_eina_inarray_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray *arr)
{
Eina_Bool r = _inarray_str_equal(arr, base_seq_str, base_seq_str_size);
eina_inarray_push(arr, _new_str_ref("42"));
static Eina_Inarray *_inarray_str_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+Eina_Bool _dummy_test_object_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray *arr)
{
Eina_Bool r = _inarray_str_equal(arr, base_seq_str, base_seq_str_size);
eina_inarray_push(arr, _new_str_ref("42"));
return r;
}
-Eina_Bool _test_testing_check_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_str_in_own_to_check) return EINA_FALSE;
Eina_Inarray *_inarray_str_out_to_check = NULL;
-Eina_Bool _test_testing_eina_inarray_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+Eina_Bool _dummy_test_object_eina_inarray_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_inarray_new(sizeof(char*), 0);
_inarray_str_out_to_check = *arr;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_inarray_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_str_out_to_check) return EINA_FALSE;
return r;
}
-Eina_Bool _test_testing_eina_inarray_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+Eina_Bool _dummy_test_object_eina_inarray_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_inarray_new(sizeof(char*), 0);
Eina_Inarray *_inarray_str_return_to_check = NULL;
-Eina_Inarray *_test_testing_eina_inarray_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inarray *_dummy_test_object_eina_inarray_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inarray *arr = eina_inarray_new(sizeof(char*), 0);
eina_inarray_push(arr, _new_str_ref("0x0"));
_inarray_str_return_to_check = arr;
return arr;
}
-Eina_Bool _test_testing_check_eina_inarray_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_str_return_to_check) return EINA_FALSE;
return r;
}
-Eina_Inarray *_test_testing_eina_inarray_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inarray *_dummy_test_object_eina_inarray_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inarray *arr = eina_inarray_new(sizeof(char*), 0);
eina_inarray_push(arr, _new_str_ref("0x0"));
// Object
-Eina_Bool _inarray_obj_equal(const Eina_Inarray *arr, const Test_Numberwrapper * const base[], unsigned int len)
+Eina_Bool _inarray_obj_equal(const Eina_Inarray *arr, const Dummy_Numberwrapper * const base[], unsigned int len)
{
if (eina_inarray_count(arr) != len)
return EINA_FALSE;
for (unsigned int i = 0; i < len; ++i)
{
- const Test_Numberwrapper **eo = eina_inarray_nth(arr, i);
- int a = test_numberwrapper_number_get(*eo);
- int b = test_numberwrapper_number_get(base[i]);
+ const Dummy_Numberwrapper **eo = eina_inarray_nth(arr, i);
+ int a = dummy_numberwrapper_number_get(*eo);
+ int b = dummy_numberwrapper_number_get(base[i]);
if (a != b)
return EINA_FALSE;
}
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_inarray_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+Eina_Bool _dummy_test_object_eina_inarray_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray *arr)
{
Eina_Bool r = _inarray_obj_equal(arr, base_seq_obj, base_seq_obj_size);
if (!r) return r;
static Eina_Inarray *_inarray_obj_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+Eina_Bool _dummy_test_object_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray *arr)
{
Eina_Bool r = _inarray_obj_equal(arr, base_seq_obj, base_seq_obj_size);
if (!r) return r;
_inarray_obj_in_own_to_check = arr;
return r;
}
-Eina_Bool _test_testing_check_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_obj_in_own_to_check) return EINA_FALSE;
Eina_Bool r = _inarray_obj_equal(_inarray_obj_in_own_to_check, modified_seq_obj, modified_seq_obj_size);
if (!r) return r;
- Test_Numberwrapper **ele;
+ Dummy_Numberwrapper **ele;
EINA_INARRAY_FOREACH(_inarray_obj_in_own_to_check, ele)
efl_unref(*ele);
Eina_Inarray *_inarray_obj_out_to_check = NULL;
-Eina_Bool _test_testing_eina_inarray_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+Eina_Bool _dummy_test_object_eina_inarray_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_inarray_new(sizeof(Eo*), 0);
_inarray_obj_out_to_check = *arr;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_inarray_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_obj_out_to_check) return EINA_FALSE;
Eina_Bool r = _inarray_obj_equal(_inarray_obj_out_to_check, modified_seq_obj, modified_seq_obj_size);
if (!r) return r;
- Test_Numberwrapper **ele;
+ Dummy_Numberwrapper **ele;
EINA_INARRAY_FOREACH(_inarray_obj_out_to_check, ele)
efl_unref(*ele);
return r;
}
-Eina_Bool _test_testing_eina_inarray_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+Eina_Bool _dummy_test_object_eina_inarray_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_inarray_new(sizeof(Eo*), 0);
Eina_Inarray *_inarray_obj_return_to_check = NULL;
-Eina_Inarray *_test_testing_eina_inarray_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inarray *_dummy_test_object_eina_inarray_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inarray *arr = eina_inarray_new(sizeof(Eo*), 0);
eina_inarray_push(arr, _new_obj_ref(0x0));
_inarray_obj_return_to_check = arr;
return arr;
}
-Eina_Bool _test_testing_check_eina_inarray_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inarray_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_inarray_obj_return_to_check) return EINA_FALSE;
Eina_Bool r = _inarray_obj_equal(_inarray_obj_return_to_check, modified_seq_obj, modified_seq_obj_size);
if (!r) return r;
- Test_Numberwrapper **ele;
+ Dummy_Numberwrapper **ele;
EINA_INARRAY_FOREACH(_inarray_obj_return_to_check, ele)
efl_unref(*ele);
return r;
}
-Eina_Inarray *_test_testing_eina_inarray_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inarray *_dummy_test_object_eina_inarray_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inarray *arr = eina_inarray_new(sizeof(Eo*), 0);
eina_inarray_push(arr, _new_obj_ref(0x0));
return arr;
}
-Eina_Inarray *_test_testing_eina_inarray_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+Eina_Inarray *_dummy_test_object_eina_inarray_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inarray *arr)
{
return arr;
}
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_list_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+Eina_Bool _dummy_test_object_eina_list_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
Eina_Bool r = _list_int_equal(lst, base_seq_int, base_seq_int_size);
return r;
static Eina_List *_list_int_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+Eina_Bool _dummy_test_object_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
Eina_Bool r = _list_int_equal(lst, base_seq_int, base_seq_int_size);
if (!r) return r;
return r;
}
-Eina_Bool _test_testing_check_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_int_in_own_to_check) return EINA_FALSE;
Eina_List *_list_int_out_to_check = NULL;
-Eina_Bool _test_testing_eina_list_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+Eina_Bool _dummy_test_object_eina_list_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_list_append(*lst, _new_int(0x0));
_list_int_out_to_check = *lst;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_list_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_int_out_to_check) return EINA_FALSE;
return r;
}
-Eina_Bool _test_testing_eina_list_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+Eina_Bool _dummy_test_object_eina_list_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_list_append(*lst, _new_int(0x0));
Eina_List *_list_int_return_to_check = NULL;
-Eina_List *_test_testing_eina_list_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_List *_dummy_test_object_eina_list_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_List *lst = NULL;
lst = eina_list_append(lst, _new_int(0x0));
_list_int_return_to_check = lst;
return lst;
}
-Eina_Bool _test_testing_check_eina_list_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_int_return_to_check) return EINA_FALSE;
return r;
}
-Eina_List *_test_testing_eina_list_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_List *_dummy_test_object_eina_list_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_List *lst = NULL;
lst = eina_list_append(lst, _new_int(0x0));
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_list_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+Eina_Bool _dummy_test_object_eina_list_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
Eina_Bool r = _list_str_equal(lst, base_seq_str, base_seq_str_size);
return r;
static Eina_List *_list_str_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+Eina_Bool _dummy_test_object_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
Eina_Bool r = _list_str_equal(lst, base_seq_str, base_seq_str_size);
if (!r) return r;
return r;
}
-Eina_Bool _test_testing_check_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_str_in_own_to_check) return EINA_FALSE;
Eina_List *_list_str_out_to_check = NULL;
-Eina_Bool _test_testing_eina_list_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+Eina_Bool _dummy_test_object_eina_list_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_list_append(*lst, strdup("0x0"));
_list_str_out_to_check = *lst;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_list_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_str_out_to_check) return EINA_FALSE;
return r;
}
-Eina_Bool _test_testing_eina_list_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+Eina_Bool _dummy_test_object_eina_list_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_list_append(*lst, strdup("0x0"));
Eina_List *_list_str_return_to_check = NULL;
-Eina_List *_test_testing_eina_list_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_List *_dummy_test_object_eina_list_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_List *lst = NULL;
lst = eina_list_append(lst, strdup("0x0"));
_list_str_return_to_check = lst;
return lst;
}
-Eina_Bool _test_testing_check_eina_list_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_str_return_to_check) return EINA_FALSE;
return r;
}
-Eina_List *_test_testing_eina_list_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_List *_dummy_test_object_eina_list_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_List *lst = NULL;
lst = eina_list_append(lst, strdup("0x0"));
// Object
-Eina_Bool _list_obj_equal(const Eina_List *lst, const Test_Numberwrapper * const base[], unsigned int len)
+Eina_Bool _list_obj_equal(const Eina_List *lst, const Dummy_Numberwrapper * const base[], unsigned int len)
{
if (eina_list_count(lst) != len)
return EINA_FALSE;
const Eina_List *l;
- Test_Numberwrapper *eo;
+ Dummy_Numberwrapper *eo;
int i = 0;
EINA_LIST_FOREACH(lst, l, eo)
{
- int a = test_numberwrapper_number_get(eo);
- int b = test_numberwrapper_number_get(base[i]);
+ int a = dummy_numberwrapper_number_get(eo);
+ int b = dummy_numberwrapper_number_get(base[i]);
if (a != b)
return EINA_FALSE;
++i;
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_list_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+Eina_Bool _dummy_test_object_eina_list_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
Eina_Bool r = _list_obj_equal(lst, base_seq_obj, base_seq_obj_size);
return r;
static Eina_List *_list_obj_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+Eina_Bool _dummy_test_object_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
Eina_Bool r = _list_obj_equal(lst, base_seq_obj, base_seq_obj_size);
if (!r) return r;
return r;
}
-Eina_Bool _test_testing_check_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_obj_in_own_to_check) return EINA_FALSE;
Eina_Bool r = _list_obj_equal(_list_obj_in_own_to_check, modified_seq_obj, modified_seq_obj_size);
if (!r) return r;
- Test_Numberwrapper *ele;
+ Dummy_Numberwrapper *ele;
EINA_LIST_FREE(_list_obj_in_own_to_check, ele)
efl_unref(ele);
Eina_List *_list_obj_out_to_check = NULL;
-Eina_Bool _test_testing_eina_list_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+Eina_Bool _dummy_test_object_eina_list_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_list_append(*lst, _new_obj(0x0));
_list_obj_out_to_check = *lst;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_list_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_obj_out_to_check) return EINA_FALSE;
Eina_Bool r = _list_obj_equal(_list_obj_out_to_check, base_seq_obj, base_seq_obj_size);
if (!r) return r;
- Test_Numberwrapper *ele;
+ Dummy_Numberwrapper *ele;
EINA_LIST_FREE(_list_obj_out_to_check, ele)
efl_unref(ele);
return r;
}
-Eina_Bool _test_testing_eina_list_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+Eina_Bool _dummy_test_object_eina_list_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_list_append(*lst, _new_obj(0x0));
Eina_List *_list_obj_return_to_check = NULL;
-Eina_List *_test_testing_eina_list_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_List *_dummy_test_object_eina_list_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_List *lst = NULL;
lst = eina_list_append(lst, _new_obj(0x0));
_list_obj_return_to_check = lst;
return lst;
}
-Eina_Bool _test_testing_check_eina_list_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_list_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_obj_return_to_check) return EINA_FALSE;
Eina_Bool r = _list_obj_equal(_list_obj_return_to_check, base_seq_obj, base_seq_obj_size);
if (!r) return r;
- Test_Numberwrapper *ele;
+ Dummy_Numberwrapper *ele;
EINA_LIST_FREE(_list_obj_return_to_check, ele)
efl_unref(ele);
return r;
}
-Eina_List *_test_testing_eina_list_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_List *_dummy_test_object_eina_list_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_List *lst = NULL;
lst = eina_list_append(lst, _new_obj(0x0));
return lst;
}
-Eina_List *_test_testing_eina_list_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+Eina_List *_dummy_test_object_eina_list_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
return lst;
}
// Integer
-typedef struct _Test_Inlist_Node_Int
+typedef struct _Dummy_Inlist_Node_Int
{
EINA_INLIST;
int val;
-} Test_Inlist_Node_Int;
+} Dummy_Inlist_Node_Int;
Eina_Inlist *_new_inlist_int(int v)
{
- Test_Inlist_Node_Int *node = malloc(sizeof(Test_Inlist_Node_Int));
+ Dummy_Inlist_Node_Int *node = malloc(sizeof(Dummy_Inlist_Node_Int));
node->val = v;
return EINA_INLIST_GET(node);
}
if (eina_inlist_count(lst) != len)
return EINA_FALSE;
- const Test_Inlist_Node_Int *node;
+ const Dummy_Inlist_Node_Int *node;
int i = 0;
EINA_INLIST_FOREACH(lst, node)
{
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_inlist_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+Eina_Bool _dummy_test_object_eina_inlist_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
return r;
static Eina_Inlist *_inlist_int_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+Eina_Bool _dummy_test_object_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
if (!r) return r;
return r;
}
-Eina_Bool _test_testing_check_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_int_in_own_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_int_equal(lst, modified_seq_int, modified_seq_int_size);
if (!r) return r;
- Test_Inlist_Node_Int *node;
+ Dummy_Inlist_Node_Int *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
Eina_Inlist *_inlist_int_out_to_check = NULL;
-Eina_Bool _test_testing_eina_inlist_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+Eina_Bool _dummy_test_object_eina_inlist_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_inlist_append(*lst, _new_inlist_int(0x0));
_inlist_int_out_to_check = *lst;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_inlist_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_int_out_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
if (!r) return r;
- Test_Inlist_Node_Int *node;
+ Dummy_Inlist_Node_Int *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
return r;
}
-Eina_Bool _test_testing_eina_inlist_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+Eina_Bool _dummy_test_object_eina_inlist_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_inlist_append(*lst, _new_inlist_int(0x0));
Eina_Inlist *_inlist_int_return_to_check = NULL;
-Eina_Inlist *_test_testing_eina_inlist_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inlist *_dummy_test_object_eina_inlist_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = NULL;
lst = eina_inlist_append(lst, _new_inlist_int(0x0));
_inlist_int_return_to_check = lst;
return lst;
}
-Eina_Bool _test_testing_check_eina_inlist_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_int_return_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
if (!r) return r;
- Test_Inlist_Node_Int *node;
+ Dummy_Inlist_Node_Int *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
return r;
}
-Eina_Inlist *_test_testing_eina_inlist_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inlist *_dummy_test_object_eina_inlist_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = NULL;
lst = eina_inlist_append(lst, _new_inlist_int(0x0));
// String
-typedef struct _Test_Inlist_Node_Str
+typedef struct _Dummy_Inlist_Node_Str
{
EINA_INLIST;
char *val;
-} Test_Inlist_Node_Str;
+} Dummy_Inlist_Node_Str;
Eina_Inlist *_new_inlist_str(const char *v)
{
- Test_Inlist_Node_Str *node = malloc(sizeof(Test_Inlist_Node_Str));
+ Dummy_Inlist_Node_Str *node = malloc(sizeof(Dummy_Inlist_Node_Str));
node->val = strdup(v);
return EINA_INLIST_GET(node);
}
if (eina_inlist_count(lst) != len)
return EINA_FALSE;
- const Test_Inlist_Node_Str *node;
+ const Dummy_Inlist_Node_Str *node;
int i = 0;
EINA_INLIST_FOREACH(lst, node)
{
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_inlist_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+Eina_Bool _dummy_test_object_eina_inlist_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
return r;
static Eina_Inlist *_inlist_str_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+Eina_Bool _dummy_test_object_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
if (!r) return r;
return r;
}
-Eina_Bool _test_testing_check_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_str_in_own_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_str_equal(lst, modified_seq_str, modified_seq_str_size);
if (!r) return r;
- Test_Inlist_Node_Str *node;
+ Dummy_Inlist_Node_Str *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
Eina_Inlist *_inlist_str_out_to_check = NULL;
-Eina_Bool _test_testing_eina_inlist_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+Eina_Bool _dummy_test_object_eina_inlist_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_inlist_append(*lst, _new_inlist_str("0x0"));
_inlist_str_out_to_check = *lst;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_inlist_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_str_out_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
if (!r) return r;
- Test_Inlist_Node_Str *node;
+ Dummy_Inlist_Node_Str *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
return r;
}
-Eina_Bool _test_testing_eina_inlist_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+Eina_Bool _dummy_test_object_eina_inlist_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_inlist_append(*lst, _new_inlist_str("0x0"));
Eina_Inlist *_inlist_str_return_to_check = NULL;
-Eina_Inlist *_test_testing_eina_inlist_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inlist *_dummy_test_object_eina_inlist_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = NULL;
lst = eina_inlist_append(lst, _new_inlist_str("0x0"));
_inlist_str_return_to_check = lst;
return lst;
}
-Eina_Bool _test_testing_check_eina_inlist_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_str_return_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
if (!r) return r;
- Test_Inlist_Node_Str *node;
+ Dummy_Inlist_Node_Str *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
return r;
}
-Eina_Inlist *_test_testing_eina_inlist_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inlist *_dummy_test_object_eina_inlist_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = NULL;
lst = eina_inlist_append(lst, _new_inlist_str("0x0"));
// Object
-typedef struct _Test_Inlist_Node_Obj
+typedef struct _Dummy_Inlist_Node_Obj
{
EINA_INLIST;
- Test_Numberwrapper *val;
-} Test_Inlist_Node_Obj;
+ Dummy_Numberwrapper *val;
+} Dummy_Inlist_Node_Obj;
Eina_Inlist *_new_inlist_obj(int v)
{
- Test_Inlist_Node_Obj *node = malloc(sizeof(Test_Inlist_Node_Obj));
+ Dummy_Inlist_Node_Obj *node = malloc(sizeof(Dummy_Inlist_Node_Obj));
node->val = _new_obj(v);
return EINA_INLIST_GET(node);
}
-Eina_Bool _inlist_obj_equal(const Eina_Inlist *lst, const Test_Numberwrapper * const base[], unsigned int len)
+Eina_Bool _inlist_obj_equal(const Eina_Inlist *lst, const Dummy_Numberwrapper * const base[], unsigned int len)
{
if (eina_inlist_count(lst) != len)
return EINA_FALSE;
- const Test_Inlist_Node_Obj *node;
+ const Dummy_Inlist_Node_Obj *node;
int i = 0;
EINA_INLIST_FOREACH(lst, node)
{
- int a = test_numberwrapper_number_get(node->val);
- int b = test_numberwrapper_number_get(base[i]);
+ int a = dummy_numberwrapper_number_get(node->val);
+ int b = dummy_numberwrapper_number_get(base[i]);
if (a != b)
return EINA_FALSE;
++i;
return EINA_TRUE;
}
-Eina_Bool _test_testing_eina_inlist_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+Eina_Bool _dummy_test_object_eina_inlist_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
return r;
static Eina_Inlist *_inlist_obj_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+Eina_Bool _dummy_test_object_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
if (!r) return r;
return r;
}
-Eina_Bool _test_testing_check_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_obj_in_own_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_obj_equal(lst, modified_seq_obj, modified_seq_obj_size);
if (!r) return r;
- Test_Inlist_Node_Obj *node;
+ Dummy_Inlist_Node_Obj *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
Eina_Inlist *_inlist_obj_out_to_check = NULL;
-Eina_Bool _test_testing_eina_inlist_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+Eina_Bool _dummy_test_object_eina_inlist_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_inlist_append(*lst, _new_inlist_obj(0x0));
_inlist_obj_out_to_check = *lst;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_inlist_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_obj_out_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
if (!r) return r;
- Test_Inlist_Node_Obj *node;
+ Dummy_Inlist_Node_Obj *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
return r;
}
-Eina_Bool _test_testing_eina_inlist_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+Eina_Bool _dummy_test_object_eina_inlist_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_inlist_append(*lst, _new_inlist_obj(0x0));
Eina_Inlist *_inlist_obj_return_to_check = NULL;
-Eina_Inlist *_test_testing_eina_inlist_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inlist *_dummy_test_object_eina_inlist_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = NULL;
lst = eina_inlist_append(lst, _new_inlist_obj(0x0));
_inlist_obj_return_to_check = lst;
return lst;
}
-Eina_Bool _test_testing_check_eina_inlist_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_inlist_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_obj_return_to_check;
if (!lst) return EINA_FALSE;
Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
if (!r) return r;
- Test_Inlist_Node_Obj *node;
+ Dummy_Inlist_Node_Obj *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
return r;
}
-Eina_Inlist *_test_testing_eina_inlist_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Inlist *_dummy_test_object_eina_inlist_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = NULL;
lst = eina_inlist_append(lst, _new_inlist_obj(0x0));
return lst;
}
-Eina_Inlist *_test_testing_eina_inlist_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+Eina_Inlist *_dummy_test_object_eina_inlist_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
return lst;
}
// int in
-Eina_Bool _test_testing_eina_hash_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh)
+Eina_Bool _dummy_test_object_eina_hash_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash *hsh)
{
if (!_hash_int_check(hsh, 22, 222))
return EINA_FALSE;
}
static Eina_Hash *_hash_int_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_hash_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh)
+Eina_Bool _dummy_test_object_eina_hash_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash *hsh)
{
eina_hash_free_cb_set(hsh, _hash_int_in_own_free_cb);
int key = 44;
return eina_hash_add(hsh, &key, _new_int(444));
}
-Eina_Bool _test_testing_check_eina_hash_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_int_in_own_to_check) return EINA_FALSE;
}
Eina_Hash *_hash_int_out_to_check = NULL;
-Eina_Bool _test_testing_eina_hash_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh)
+Eina_Bool _dummy_test_object_eina_hash_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash **hsh)
{
if (!hsh) return EINA_FALSE;
int key = 22;
return eina_hash_add(*hsh, &key, _new_int(222));
}
-Eina_Bool _test_testing_check_eina_hash_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_int_out_to_check) return EINA_FALSE;
_hash_int_out_own_free_flag = EINA_TRUE;
free(data);
}
-Eina_Bool _test_testing_eina_hash_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh)
+Eina_Bool _dummy_test_object_eina_hash_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash **hsh)
{
if (!hsh) return EINA_FALSE;
int key = 22;
return eina_hash_add(*hsh, &key, _new_int(222));
}
-Eina_Bool _test_testing_check_eina_hash_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return !_hash_int_out_own_free_flag;
}
}
Eina_Hash *_hash_int_return_to_check = NULL;
-Eina_Hash *_test_testing_eina_hash_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Hash *_dummy_test_object_eina_hash_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Hash *hsh = eina_hash_int32_new(_hash_int_return_free_cb);
return hsh;
}
-Eina_Bool _test_testing_check_eina_hash_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_int_return_to_check) return EINA_FALSE;
_hash_int_return_own_free_flag = EINA_TRUE;
free(data);
}
-Eina_Hash *_test_testing_eina_hash_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Hash *_dummy_test_object_eina_hash_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Hash *hsh = eina_hash_int32_new(_hash_int_return_own_free_cb);
return hsh;
}
-Eina_Bool _test_testing_check_eina_hash_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return !_hash_int_return_own_free_flag;
}
// str in
-Eina_Bool _test_testing_eina_hash_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh)
+Eina_Bool _dummy_test_object_eina_hash_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash *hsh)
{
if (!_hash_str_check(hsh, "aa", "aaa"))
return EINA_FALSE;
}
static Eina_Hash *_hash_str_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_hash_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh)
+Eina_Bool _dummy_test_object_eina_hash_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash *hsh)
{
eina_hash_free_cb_set(hsh, _hash_str_in_own_free_cb);
return eina_hash_add(hsh, "bb", strdup("bbb"));
}
-Eina_Bool _test_testing_check_eina_hash_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_str_in_own_to_check) return EINA_FALSE;
}
Eina_Hash *_hash_str_out_to_check = NULL;
-Eina_Bool _test_testing_eina_hash_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh)
+Eina_Bool _dummy_test_object_eina_hash_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash **hsh)
{
if (!hsh) return EINA_FALSE;
return eina_hash_add(*hsh, "aa", strdup("aaa"));
}
-Eina_Bool _test_testing_check_eina_hash_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_str_out_to_check) return EINA_FALSE;
_hash_str_out_own_free_flag = EINA_TRUE;
free(data);
}
-Eina_Bool _test_testing_eina_hash_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh)
+Eina_Bool _dummy_test_object_eina_hash_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash **hsh)
{
if (!hsh) return EINA_FALSE;
return eina_hash_add(*hsh, "aa", strdup("aaa"));
}
-Eina_Bool _test_testing_check_eina_hash_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return !_hash_str_out_own_free_flag;
}
}
Eina_Hash *_hash_str_return_to_check = NULL;
-Eina_Hash *_test_testing_eina_hash_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Hash *_dummy_test_object_eina_hash_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Hash *hsh = eina_hash_string_superfast_new(_hash_str_return_free_cb);
return hsh;
}
-Eina_Bool _test_testing_check_eina_hash_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_str_return_to_check) return EINA_FALSE;
_hash_str_return_own_free_flag = EINA_TRUE;
free(data);
}
-Eina_Hash *_test_testing_eina_hash_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Hash *_dummy_test_object_eina_hash_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Hash *hsh = eina_hash_string_superfast_new(_hash_str_return_own_free_cb);
return hsh;
}
-Eina_Bool _test_testing_check_eina_hash_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return !_hash_str_return_own_free_flag;
}
// Object //
-Eina_Bool _hash_obj_check(const Eina_Hash *hsh, Test_Numberwrapper *key, Test_Numberwrapper *expected_val, int knum, int vnum)
+Eina_Bool _hash_obj_check(const Eina_Hash *hsh, Dummy_Numberwrapper *key, Dummy_Numberwrapper *expected_val, int knum, int vnum)
{
- Test_Numberwrapper *val = eina_hash_find(hsh, &key);
- return val && (val == expected_val) && (test_numberwrapper_number_get(key) == knum) && (test_numberwrapper_number_get(val) == vnum);
+ Dummy_Numberwrapper *val = eina_hash_find(hsh, &key);
+ return val && (val == expected_val) && (dummy_numberwrapper_number_get(key) == knum) && (dummy_numberwrapper_number_get(val) == vnum);
}
// obj in
-Eina_Bool _test_testing_eina_hash_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper **nwk2, Test_Numberwrapper **nwv2)
+Eina_Bool _dummy_test_object_eina_hash_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash *hsh, Dummy_Numberwrapper *nwk1, Dummy_Numberwrapper *nwv1, Dummy_Numberwrapper **nwk2, Dummy_Numberwrapper **nwv2)
{
if (!_hash_obj_check(hsh, nwk1, nwv1, 22, 222))
return EINA_FALSE;
}
static Eina_Hash *_hash_obj_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_hash_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper **nwk2, Test_Numberwrapper **nwv2)
+Eina_Bool _dummy_test_object_eina_hash_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash *hsh, Dummy_Numberwrapper *nwk1, Dummy_Numberwrapper *nwv1, Dummy_Numberwrapper **nwk2, Dummy_Numberwrapper **nwv2)
{
eina_hash_free_cb_set(hsh, _hash_obj_in_own_free_cb);
return eina_hash_add(hsh, nwk2, *nwv2);
}
-Eina_Bool _test_testing_check_eina_hash_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper *nwk2, Test_Numberwrapper *nwv2)
+Eina_Bool _dummy_test_object_check_eina_hash_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_Numberwrapper *nwk1, Dummy_Numberwrapper *nwv1, Dummy_Numberwrapper *nwk2, Dummy_Numberwrapper *nwv2)
{
if (!_hash_obj_in_own_to_check) return EINA_FALSE;
}
Eina_Hash *_hash_obj_out_to_check = NULL;
-Eina_Bool _test_testing_eina_hash_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh, Test_Numberwrapper **nwk, Test_Numberwrapper **nwv)
+Eina_Bool _dummy_test_object_eina_hash_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash **hsh, Dummy_Numberwrapper **nwk, Dummy_Numberwrapper **nwv)
{
if (!hsh) return EINA_FALSE;
*nwv = _new_obj(222);
return eina_hash_add(*hsh, nwk, *nwv);
}
-Eina_Bool _test_testing_check_eina_hash_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper *nwk2, Test_Numberwrapper *nwv2)
+Eina_Bool _dummy_test_object_check_eina_hash_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_Numberwrapper *nwk1, Dummy_Numberwrapper *nwv1, Dummy_Numberwrapper *nwk2, Dummy_Numberwrapper *nwv2)
{
if (!_hash_obj_out_to_check) return EINA_FALSE;
_hash_obj_out_own_free_flag = EINA_TRUE;
efl_unref(data);
}
-Eina_Bool _test_testing_eina_hash_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh, Test_Numberwrapper **nwk, Test_Numberwrapper **nwv)
+Eina_Bool _dummy_test_object_eina_hash_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash **hsh, Dummy_Numberwrapper **nwk, Dummy_Numberwrapper **nwv)
{
if (!hsh) return EINA_FALSE;
*nwv = _new_obj(222);
return eina_hash_add(*hsh, nwk, *nwv);
}
-Eina_Bool _test_testing_check_eina_hash_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return !_hash_obj_out_own_free_flag;
}
}
Eina_Hash *_hash_obj_return_to_check = NULL;
-Eina_Hash *_test_testing_eina_hash_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper **nwk, Test_Numberwrapper **nwv)
+Eina_Hash *_dummy_test_object_eina_hash_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_Numberwrapper **nwk, Dummy_Numberwrapper **nwv)
{
Eina_Hash *hsh = eina_hash_pointer_new(_hash_obj_return_free_cb);
return hsh;
}
-Eina_Bool _test_testing_check_eina_hash_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper *nwk2, Test_Numberwrapper *nwv2)
+Eina_Bool _dummy_test_object_check_eina_hash_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_Numberwrapper *nwk1, Dummy_Numberwrapper *nwv1, Dummy_Numberwrapper *nwk2, Dummy_Numberwrapper *nwv2)
{
if (!_hash_obj_return_to_check) return EINA_FALSE;
_hash_obj_return_own_free_flag = EINA_TRUE;
efl_unref(data);
}
-Eina_Hash *_test_testing_eina_hash_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper **nwk, Test_Numberwrapper **nwv)
+Eina_Hash *_dummy_test_object_eina_hash_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_Numberwrapper **nwk, Dummy_Numberwrapper **nwv)
{
Eina_Hash *hsh = eina_hash_pointer_new(_hash_obj_return_own_free_cb);
return hsh;
}
-Eina_Bool _test_testing_check_eina_hash_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_hash_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return !_hash_obj_return_own_free_flag;
}
// <int> in
-Eina_Bool _test_testing_eina_iterator_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+Eina_Bool _dummy_test_object_eina_iterator_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_int_equal(itr, base_seq_int, base_seq_int_size, EINA_FALSE);
return r;
static Eina_Iterator *_iterator_int_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_iterator_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+Eina_Bool _dummy_test_object_eina_iterator_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_int_equal(itr, base_seq_int, base_seq_int_size, EINA_TRUE);
_iterator_int_in_own_to_check = itr;
return r;
}
-Eina_Bool _test_testing_check_eina_iterator_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
eina_iterator_free(_iterator_int_in_own_to_check);
_iterator_int_in_own_to_check = NULL;
Eina_Iterator *_iterator_int_out_to_check = NULL;
Eina_Array *_iterator_int_out_array = NULL;
-Eina_Bool _test_testing_eina_iterator_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+Eina_Bool _dummy_test_object_eina_iterator_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator **itr)
{
if (!itr) return EINA_FALSE;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_iterator_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Iterator *itr = _iterator_int_out_to_check;
if (!itr) return EINA_FALSE;
// <int> out own
-Eina_Bool _test_testing_eina_iterator_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+Eina_Bool _dummy_test_object_eina_iterator_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator **itr)
{
if (!itr) return EINA_FALSE;
Eina_Iterator *_iterator_int_return_to_check = NULL;
Eina_Array *_iterator_int_return_array = NULL;
-Eina_Iterator *_test_testing_eina_iterator_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Iterator *_dummy_test_object_eina_iterator_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
_iterator_int_return_array = _iterator_int_eina_array_new();
_iterator_int_return_to_check = eina_array_iterator_new(_iterator_int_return_array);
return _iterator_int_return_to_check;
}
-Eina_Bool _test_testing_check_eina_iterator_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Iterator *itr = _iterator_int_return_to_check;
if (!itr) return EINA_FALSE;
// <int> return own
-Eina_Iterator *_test_testing_eina_iterator_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Iterator *_dummy_test_object_eina_iterator_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = _iterator_int_eina_array_new();
return eina_array_iterator_new(arr);
// <str> in
-Eina_Bool _test_testing_eina_iterator_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+Eina_Bool _dummy_test_object_eina_iterator_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_str_equal(itr, base_seq_str, base_seq_str_size, EINA_FALSE);
return r;
static Eina_Iterator *_iterator_str_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_iterator_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+Eina_Bool _dummy_test_object_eina_iterator_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_str_equal(itr, base_seq_str, base_seq_str_size, EINA_TRUE);
_iterator_str_in_own_to_check = itr;
return r;
}
-Eina_Bool _test_testing_check_eina_iterator_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
eina_iterator_free(_iterator_str_in_own_to_check);
_iterator_str_in_own_to_check = NULL;
Eina_Iterator *_iterator_str_out_to_check = NULL;
Eina_Array *_iterator_str_out_array = NULL;
-Eina_Bool _test_testing_eina_iterator_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+Eina_Bool _dummy_test_object_eina_iterator_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator **itr)
{
if (!itr) return EINA_FALSE;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_iterator_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Iterator *itr = _iterator_str_out_to_check;
if (!itr) return EINA_FALSE;
// <str> out own
-Eina_Bool _test_testing_eina_iterator_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+Eina_Bool _dummy_test_object_eina_iterator_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator **itr)
{
if (!itr) return EINA_FALSE;
Eina_Iterator *_iterator_str_return_to_check = NULL;
Eina_Array *_iterator_str_return_array = NULL;
-Eina_Iterator *_test_testing_eina_iterator_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Iterator *_dummy_test_object_eina_iterator_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
_iterator_str_return_array = _iterator_str_eina_array_new();
_iterator_str_return_to_check = eina_array_iterator_new(_iterator_str_return_array);
return _iterator_str_return_to_check;
}
-Eina_Bool _test_testing_check_eina_iterator_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Iterator *itr = _iterator_str_return_to_check;
if (!itr) return EINA_FALSE;
// <str> return own
-Eina_Iterator *_test_testing_eina_iterator_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Iterator *_dummy_test_object_eina_iterator_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = _iterator_str_eina_array_new();
return eina_array_iterator_new(arr);
// Object //
-Eina_Bool _iterator_obj_equal(Eina_Iterator *itr, const Test_Numberwrapper * const base[], unsigned int len, Eina_Bool release)
+Eina_Bool _iterator_obj_equal(Eina_Iterator *itr, const Dummy_Numberwrapper * const base[], unsigned int len, Eina_Bool release)
{
- Test_Numberwrapper *data;
+ Dummy_Numberwrapper *data;
unsigned i = 0;
EINA_ITERATOR_FOREACH(itr, data)
{
- int a = test_numberwrapper_number_get(data);
- int b = test_numberwrapper_number_get(base[i]);
+ int a = dummy_numberwrapper_number_get(data);
+ int b = dummy_numberwrapper_number_get(base[i]);
if (a != b)
return EINA_FALSE;
if (release)
Eina_Array *arr = eina_array_new(32);
for (unsigned i = 0; i < base_seq_obj_size; ++i)
{
- eina_array_push(arr, _new_obj(test_numberwrapper_number_get(base_seq_obj[i])));
+ eina_array_push(arr, _new_obj(dummy_numberwrapper_number_get(base_seq_obj[i])));
}
return arr;
}
for (unsigned i = 0; i < base_seq_obj_size; ++i)
{
- Test_Numberwrapper *data = eina_array_data_get(arr, i);
- int a = test_numberwrapper_number_get(data);
- int b = test_numberwrapper_number_get(base_seq_obj[i]);
+ Dummy_Numberwrapper *data = eina_array_data_get(arr, i);
+ int a = dummy_numberwrapper_number_get(data);
+ int b = dummy_numberwrapper_number_get(base_seq_obj[i]);
if (a != b)
return EINA_FALSE;
efl_unref(data);
// <obj> in
-Eina_Bool _test_testing_eina_iterator_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+Eina_Bool _dummy_test_object_eina_iterator_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_obj_equal(itr, base_seq_obj, base_seq_obj_size, EINA_FALSE);
return r;
static Eina_Iterator *_iterator_obj_in_own_to_check = NULL;
-Eina_Bool _test_testing_eina_iterator_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+Eina_Bool _dummy_test_object_eina_iterator_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_obj_equal(itr, base_seq_obj, base_seq_obj_size, EINA_TRUE);
_iterator_obj_in_own_to_check = itr;
return r;
}
-Eina_Bool _test_testing_check_eina_iterator_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
eina_iterator_free(_iterator_obj_in_own_to_check);
_iterator_obj_in_own_to_check = NULL;
Eina_Iterator *_iterator_obj_out_to_check = NULL;
Eina_Array *_iterator_obj_out_array = NULL;
-Eina_Bool _test_testing_eina_iterator_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+Eina_Bool _dummy_test_object_eina_iterator_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator **itr)
{
if (!itr) return EINA_FALSE;
return EINA_TRUE;
}
-Eina_Bool _test_testing_check_eina_iterator_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Iterator *itr = _iterator_obj_out_to_check;
if (!itr) return EINA_FALSE;
// <obj> out own
-Eina_Bool _test_testing_eina_iterator_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+Eina_Bool _dummy_test_object_eina_iterator_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator **itr)
{
if (!itr) return EINA_FALSE;
Eina_Iterator *_iterator_obj_return_to_check = NULL;
Eina_Array *_iterator_obj_return_array = NULL;
-Eina_Iterator *_test_testing_eina_iterator_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Iterator *_dummy_test_object_eina_iterator_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
_iterator_obj_return_array = _iterator_obj_eina_array_new();
_iterator_obj_return_to_check = eina_array_iterator_new(_iterator_obj_return_array);
return _iterator_obj_return_to_check;
}
-Eina_Bool _test_testing_check_eina_iterator_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Bool _dummy_test_object_check_eina_iterator_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Iterator *itr = _iterator_obj_return_to_check;
if (!itr) return EINA_FALSE;
// <obj> return own
-Eina_Iterator *_test_testing_eina_iterator_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Eina_Iterator *_dummy_test_object_eina_iterator_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = _iterator_obj_eina_array_new();
return eina_array_iterator_new(arr);
// Callbacks and Function Pointers //
// //
-void _test_testing_set_callback(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, void *cb_data, Test_SimpleCb cb, Eina_Free_Cb cb_free_cb)
+void _dummy_test_object_set_callback(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, void *cb_data, Dummy_SimpleCb cb, Eina_Free_Cb cb_free_cb)
{
if (!pd)
{
pd->free_cb = cb_free_cb;
}
-int _test_testing_call_callback(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, int a)
+int _dummy_test_object_call_callback(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, int a)
{
if (!pd->cb)
{
return a * 3;
}
-void _test_testing_call_set_callback(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+void _dummy_test_object_call_set_callback(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- test_testing_set_callback(obj, efl_ref(obj), _wrapper_cb, _free_callback);
+ dummy_test_object_set_callback(obj, efl_ref(obj), _wrapper_cb, _free_callback);
}
-void _test_testing_raises_eina_error(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+void _dummy_test_object_raises_eina_error(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
eina_error_set(EIO);
}
-void _test_testing_children_raise_error(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+void _dummy_test_object_children_raise_error(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
// Native method shouldn't throw any error. Children must raise it.
}
-void _test_testing_call_children_raise_error(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+void _dummy_test_object_call_children_raise_error(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- test_testing_children_raise_error(obj);
+ dummy_test_object_children_raise_error(obj);
}
-void _test_testing_error_ret_set(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Error error)
+void _dummy_test_object_error_ret_set(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Error error)
{
pd->error_code = error;
}
-Eina_Error _test_testing_returns_error(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+Eina_Error _dummy_test_object_returns_error(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd)
{
return pd->error_code;
}
// auxiliary functions
static
-void struct_simple_with_values(Test_StructSimple *simple)
+void struct_simple_with_values(Dummy_StructSimple *simple)
{
simple->fbyte = -126;
simple->fubyte = 254u;
simple->fdouble = -9007199254740992.0;
simple->fbool = EINA_TRUE;
simple->fvoid_ptr = (void*) 0xFE;
- simple->fenum = TEST_SAMPLEENUM_V2;
+ simple->fenum = DUMMY_SAMPLEENUM_V2;
simple->fstring = "test/string";
simple->fmstring = strdup("test/mstring");
simple->fstringshare = eina_stringshare_add("test/stringshare");
}
static
-Eina_Bool check_and_modify_struct_simple(Test_StructSimple *simple)
+Eina_Bool check_and_modify_struct_simple(Dummy_StructSimple *simple)
{
Eina_Bool ret =
EQUAL(simple->fbyte, -126)
&& EQUAL(simple->fdouble, -9007199254740992.0)
&& EQUAL(simple->fbool, EINA_TRUE)
&& EQUAL(simple->fvoid_ptr, (void*) 0xFE)
- && EQUAL(simple->fenum, TEST_SAMPLEENUM_V2)
+ && EQUAL(simple->fenum, DUMMY_SAMPLEENUM_V2)
&& STR_EQUAL(simple->fstring, "test/string")
&& STR_EQUAL(simple->fmstring, "test/mstring")
&& STR_EQUAL(simple->fstringshare, "test/stringshare")
}
static
-void struct_complex_with_values(Test_StructComplex *complex)
+void struct_complex_with_values(Dummy_StructComplex *complex)
{
complex->farray = eina_array_new(4);
eina_array_push(complex->farray, _new_int(0x0));
}
static
-Eina_Bool check_and_modify_struct_complex(Test_StructComplex *complex)
+Eina_Bool check_and_modify_struct_complex(Dummy_StructComplex *complex)
{
if (!_array_int_equal(complex->farray, base_seq_int, base_seq_int_size))
return EINA_FALSE;
if (complex->fslice.len != 1 || *(char*)complex->fslice.mem != 125)
return EINA_FALSE;
- if (complex->fobj == NULL || test_numberwrapper_number_get(complex->fobj) != 42)
+ if (complex->fobj == NULL || dummy_numberwrapper_number_get(complex->fobj) != 42)
return EINA_FALSE;
return EINA_TRUE;
// with simple types
EOLIAN
-Eina_Bool _test_testing_struct_simple_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple simple)
+Eina_Bool _dummy_test_object_struct_simple_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple simple)
{
return check_and_modify_struct_simple(&simple);
}
}
EOLIAN
-Eina_Bool _test_testing_struct_simple_ptr_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple *simple)
+Eina_Bool _dummy_test_object_struct_simple_ptr_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple *simple)
{
simple->fint = -simple->fint;
_reverse_string(simple->fmstring);
}
EOLIAN
-Test_StructSimple _test_testing_struct_simple_ptr_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple *simple)
+Dummy_StructSimple _dummy_test_object_struct_simple_ptr_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple *simple)
{
- Test_StructSimple ret = *simple;
+ Dummy_StructSimple ret = *simple;
free(simple);
ret.fint = -ret.fint;
_reverse_string(ret.fmstring);
}
EOLIAN
-Eina_Bool _test_testing_struct_simple_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple *simple)
+Eina_Bool _dummy_test_object_struct_simple_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple *simple)
{
if (!simple)
{
}
EOLIAN
-Test_StructSimple _test_testing_struct_simple_ptr_out(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Test_StructSimple **simple)
+Dummy_StructSimple _dummy_test_object_struct_simple_ptr_out(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Dummy_StructSimple **simple)
{
struct_simple_with_values(&pd->stored_struct);
*simple = &pd->stored_struct;
}
EOLIAN
-Test_StructSimple _test_testing_struct_simple_ptr_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple **simple)
+Dummy_StructSimple _dummy_test_object_struct_simple_ptr_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple **simple)
{
- *simple = malloc(sizeof(Test_StructSimple));
+ *simple = malloc(sizeof(Dummy_StructSimple));
struct_simple_with_values(*simple);
(*simple)->fstring = "Ptr Out Own";
return **simple;
}
EOLIAN
-Test_StructSimple _test_testing_struct_simple_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructSimple _dummy_test_object_struct_simple_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- Test_StructSimple simple = {0,};
+ Dummy_StructSimple simple = {0,};
struct_simple_with_values(&simple);
return simple;
}
EOLIAN
-Test_StructSimple *_test_testing_struct_simple_ptr_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructSimple *_dummy_test_object_struct_simple_ptr_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
struct_simple_with_values(&pd->stored_struct);
pd->stored_struct.fstring = "Ret Ptr";
}
EOLIAN
-Test_StructSimple *_test_testing_struct_simple_ptr_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructSimple *_dummy_test_object_struct_simple_ptr_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- Test_StructSimple *ret = malloc(sizeof(Test_StructSimple));
+ Dummy_StructSimple *ret = malloc(sizeof(Dummy_StructSimple));
struct_simple_with_values(ret);
ret->fstring = "Ret Ptr Own";
return ret;
}
EOLIAN
-void _test_testing_call_struct_simple_in(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple simple)
+void _dummy_test_object_call_struct_simple_in(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple simple)
{
- test_testing_struct_simple_in(obj, simple);
+ dummy_test_object_struct_simple_in(obj, simple);
}
EOLIAN
-void _test_testing_call_struct_simple_ptr_in(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple *simple)
+void _dummy_test_object_call_struct_simple_ptr_in(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple *simple)
{
- test_testing_struct_simple_ptr_in(obj, simple);
+ dummy_test_object_struct_simple_ptr_in(obj, simple);
}
EOLIAN
-void _test_testing_call_struct_simple_ptr_in_own(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple *simple)
+void _dummy_test_object_call_struct_simple_ptr_in_own(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple *simple)
{
- test_testing_struct_simple_ptr_in_own(obj, simple);
+ dummy_test_object_struct_simple_ptr_in_own(obj, simple);
}
EOLIAN
-void _test_testing_call_struct_simple_out(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple *simple)
+void _dummy_test_object_call_struct_simple_out(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple *simple)
{
- test_testing_struct_simple_out(obj, simple);
+ dummy_test_object_struct_simple_out(obj, simple);
}
EOLIAN
-void _test_testing_call_struct_simple_ptr_out(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple **simple)
+void _dummy_test_object_call_struct_simple_ptr_out(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple **simple)
{
- test_testing_struct_simple_ptr_out(obj, simple);
+ dummy_test_object_struct_simple_ptr_out(obj, simple);
}
EOLIAN
-void _test_testing_call_struct_simple_ptr_out_own(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple **simple)
+void _dummy_test_object_call_struct_simple_ptr_out_own(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple **simple)
{
- test_testing_struct_simple_ptr_out_own(obj, simple);
+ dummy_test_object_struct_simple_ptr_out_own(obj, simple);
}
EOLIAN
-Test_StructSimple _test_testing_call_struct_simple_return(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructSimple _dummy_test_object_call_struct_simple_return(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_struct_simple_return(obj);
+ return dummy_test_object_struct_simple_return(obj);
}
EOLIAN
-Test_StructSimple *_test_testing_call_struct_simple_ptr_return(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructSimple *_dummy_test_object_call_struct_simple_ptr_return(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_struct_simple_ptr_return(obj);
+ return dummy_test_object_struct_simple_ptr_return(obj);
}
EOLIAN
-Test_StructSimple *_test_testing_call_struct_simple_ptr_return_own(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructSimple *_dummy_test_object_call_struct_simple_ptr_return_own(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- return test_testing_struct_simple_ptr_return_own(obj);
+ return dummy_test_object_struct_simple_ptr_return_own(obj);
}
// with complex types
EOLIAN
-Eina_Bool _test_testing_struct_complex_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructComplex complex)
+Eina_Bool _dummy_test_object_struct_complex_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructComplex complex)
{
return check_and_modify_struct_complex(&complex);
}
EOLIAN
-Eina_Bool _test_testing_struct_complex_ptr_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructComplex *complex)
+Eina_Bool _dummy_test_object_struct_complex_ptr_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructComplex *complex)
{
(void) complex;
EINA_LOG_ERR("Not implemented!");
}
EOLIAN
-Eina_Bool _test_testing_struct_complex_ptr_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructComplex *complex)
+Eina_Bool _dummy_test_object_struct_complex_ptr_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructComplex *complex)
{
(void) complex;
EINA_LOG_ERR("Not implemented!");
}
EOLIAN
-Eina_Bool _test_testing_struct_complex_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructComplex *complex)
+Eina_Bool _dummy_test_object_struct_complex_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructComplex *complex)
{
if (!complex)
{
}
EOLIAN
-Eina_Bool _test_testing_struct_complex_ptr_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructComplex **complex)
+Eina_Bool _dummy_test_object_struct_complex_ptr_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructComplex **complex)
{
(void) complex;
EINA_LOG_ERR("Not implemented!");
}
EOLIAN
-Eina_Bool _test_testing_struct_complex_ptr_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructComplex **complex)
+Eina_Bool _dummy_test_object_struct_complex_ptr_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructComplex **complex)
{
(void) complex;
EINA_LOG_ERR("Not implemented!");
}
EOLIAN
-Test_StructComplex _test_testing_struct_complex_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructComplex _dummy_test_object_struct_complex_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
- Test_StructComplex complex = {0,};
+ Dummy_StructComplex complex = {0,};
struct_complex_with_values(&complex);
return complex;
}
EOLIAN
-Test_StructComplex* _test_testing_struct_complex_ptr_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructComplex* _dummy_test_object_struct_complex_ptr_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
EINA_LOG_ERR("Not implemented!");
return NULL;
}
EOLIAN
-Test_StructComplex* _test_testing_struct_complex_ptr_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+Dummy_StructComplex* _dummy_test_object_struct_complex_ptr_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
EINA_LOG_ERR("Not implemented!");
return NULL;
// Class constructor
// //
EOLIAN static void
-_test_testing_class_constructor(Efl_Class *klass)
+_dummy_test_object_class_constructor(Efl_Class *klass)
{
(void)klass;
modified_seq_obj[0] = base_seq_obj[0] = _new_obj(0x0);
}
EOLIAN static void
-_test_testing_class_destructor(Efl_Class *klass)
+_dummy_test_object_class_destructor(Efl_Class *klass)
{
(void)klass;
for (unsigned i = 0; i < base_seq_obj_size; ++i)
// ################## //
-void _test_numberwrapper_number_set(EINA_UNUSED Eo *obj, Test_Numberwrapper_Data *pd, int n)
+void _dummy_numberwrapper_number_set(EINA_UNUSED Eo *obj, Dummy_Numberwrapper_Data *pd, int n)
{
pd->number = n;
}
-int _test_numberwrapper_number_get(EINA_UNUSED const Eo *obj, Test_Numberwrapper_Data *pd)
+int _dummy_numberwrapper_number_get(EINA_UNUSED const Eo *obj, Dummy_Numberwrapper_Data *pd)
{
return pd->number;
}
-void _test_testing_set_value_ptr(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value *value)
+void _dummy_test_object_set_value_ptr(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Value *value)
{
if (pd->stored_value) {
eina_value_free(pd->stored_value);
eina_value_copy(value, pd->stored_value);
}
-void _test_testing_set_value_ptr_own(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value *value)
+void _dummy_test_object_set_value_ptr_own(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Value *value)
{
if (pd->stored_value) {
eina_value_free(pd->stored_value);
pd->stored_value = value;
}
-void _test_testing_set_value(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value value)
+void _dummy_test_object_set_value(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Value value)
{
if (pd->stored_value) {
eina_value_free(pd->stored_value);
eina_value_copy(&value, pd->stored_value);
}
-void _test_testing_call_set_value(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const Eina_Value v)
+void _dummy_test_object_call_set_value(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, const Eina_Value v)
{
- test_testing_set_value(obj, v);
+ dummy_test_object_set_value(obj, v);
}
-Eina_Value *_test_testing_get_value_ptr_own(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+Eina_Value *_dummy_test_object_get_value_ptr_own(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd)
{
Eina_Value *val = pd->stored_value;
pd->stored_value = NULL;
return val;
}
-Eina_Value *_test_testing_get_value_ptr(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+Eina_Value *_dummy_test_object_get_value_ptr(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd)
{
return pd->stored_value;
}
-void _test_testing_clear_value(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+void _dummy_test_object_clear_value(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd)
{
if (pd->stored_value) {
eina_value_free(pd->stored_value);
}
}
-void _test_testing_out_value_ptr(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value **value)
+void _dummy_test_object_out_value_ptr(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Value **value)
{
*value = pd->stored_value;
}
-void _test_testing_out_value_ptr_own(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value **value)
+void _dummy_test_object_out_value_ptr_own(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Value **value)
{
*value = pd->stored_value;
pd->stored_value = NULL;
}
-void _test_testing_out_value(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value *value)
+void _dummy_test_object_out_value(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Value *value)
{
*value = *pd->stored_value;
}
-void _test_testing_emit_event_with_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char *data)
+void _dummy_test_object_emit_event_with_string(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, const char *data)
{
char *ptr = strdup(data);
- efl_event_callback_legacy_call(obj, TEST_TESTING_EVENT_EVT_WITH_STRING, ptr);
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_OBJECT_EVENT_EVT_WITH_STRING, ptr);
free(ptr);
}
-void _test_testing_emit_event_with_bool(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Bool data)
+void _dummy_test_object_emit_event_with_bool(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Bool data)
{
- efl_event_callback_legacy_call(obj, TEST_TESTING_EVENT_EVT_WITH_BOOL, (void *) (uintptr_t) data);
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_OBJECT_EVENT_EVT_WITH_BOOL, (void *) (uintptr_t) data);
}
-void _test_testing_emit_event_with_int(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, int data)
+void _dummy_test_object_emit_event_with_int(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, int data)
{
- efl_event_callback_legacy_call(obj, TEST_TESTING_EVENT_EVT_WITH_INT, (void *) (uintptr_t) data);
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_OBJECT_EVENT_EVT_WITH_INT, (void *) (uintptr_t) data);
}
-void _test_testing_emit_event_with_uint(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, unsigned int data)
+void _dummy_test_object_emit_event_with_uint(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, unsigned int data)
{
- efl_event_callback_legacy_call(obj, TEST_TESTING_EVENT_EVT_WITH_UINT, (void *) (uintptr_t) data);
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_OBJECT_EVENT_EVT_WITH_UINT, (void *) (uintptr_t) data);
}
-void _test_testing_emit_event_with_obj(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eo *data)
+void _dummy_test_object_emit_event_with_obj(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eo *data)
{
- efl_event_callback_legacy_call(obj, TEST_TESTING_EVENT_EVT_WITH_OBJ, data);
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_OBJECT_EVENT_EVT_WITH_OBJ, data);
}
-void _test_testing_emit_event_with_error(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Error data)
+void _dummy_test_object_emit_event_with_error(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Error data)
{
- efl_event_callback_legacy_call(obj, TEST_TESTING_EVENT_EVT_WITH_ERROR, &data);
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_OBJECT_EVENT_EVT_WITH_ERROR, &data);
}
-void _test_testing_emit_event_with_struct(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_StructSimple data)
+void _dummy_test_object_emit_event_with_struct(Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_StructSimple data)
{
- efl_event_callback_legacy_call(obj, TEST_TESTING_EVENT_EVT_WITH_STRUCT, &data);
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_OBJECT_EVENT_EVT_WITH_STRUCT, &data);
}
-Efl_Object *_test_testing_efl_part_part_get(EINA_UNUSED const Eo *obj, Test_Testing_Data *pd, const char *name)
+Efl_Object *_dummy_test_object_efl_part_part_get(EINA_UNUSED const Eo *obj, Dummy_Test_Object_Data *pd, const char *name)
{
- if (!strcmp(name, "part1"))
- return pd->part1;
- else if (!strcmp(name, "part2"))
- return pd->part2;
+ if (!strcmp(name, "part_one"))
+ return pd->part_one;
+ else if (!strcmp(name, "part_two"))
+ return pd->part_two;
else
return NULL;
}
-void _test_testing_append_to_strbuf(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Strbuf *buf, const char *str)
+void _dummy_test_object_append_to_strbuf(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Strbuf *buf, const char *str)
{
eina_strbuf_append(buf, str);
}
-void _test_testing_call_append_to_strbuf(Eo * obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Strbuf *buf, const char *str)
+void _dummy_test_object_call_append_to_strbuf(Eo * obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Strbuf *buf, const char *str)
{
- test_testing_append_to_strbuf(obj, buf, str);
+ dummy_test_object_append_to_strbuf(obj, buf, str);
}
-void _test_testing_call_format_cb(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Strbuf *buf, const Eina_Value value,
- void *func_data, Test_FormatCb func, Eina_Free_Cb func_free_cb)
+void _dummy_test_object_call_format_cb(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Strbuf *buf, const Eina_Value value,
+ void *func_data, Dummy_FormatCb func, Eina_Free_Cb func_free_cb)
{
func(func_data, buf, value);
func_free_cb(func_data);
}
-Test_MyInt _test_testing_bypass_typedef(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_MyInt data, Test_MyInt *receiver)
+Dummy_MyInt _dummy_test_object_bypass_typedef(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Dummy_MyInt data, Dummy_MyInt *receiver)
{
*receiver = data;
return data;
}
/* Class Properties */
-static int _test_testing_klass_prop = 0;
+static int _dummy_test_object_klass_prop = 0;
-int _test_testing_klass_prop_get(const Eo *klass, EINA_UNUSED void *pd)
+int _dummy_test_object_klass_prop_get(const Eo *klass, EINA_UNUSED void *pd)
{
EINA_LOG_ERR("FAIL on GET");
- if (klass != test_testing_class_get())
+ if (klass != dummy_test_object_class_get())
{
eina_error_set(EINVAL);
return -1;
}
- return _test_testing_klass_prop;
+ return _dummy_test_object_klass_prop;
}
-void _test_testing_klass_prop_set(Eo *klass, EINA_UNUSED void *pd, int value)
+void _dummy_test_object_klass_prop_set(Eo *klass, EINA_UNUSED void *pd, int value)
{
EINA_LOG_ERR("FAIL on SET");
- if (klass != test_testing_class_get())
+ if (klass != dummy_test_object_class_get())
{
eina_error_set(EINVAL);
}
- _test_testing_klass_prop = value;
+ _dummy_test_object_klass_prop = value;
}
static void _promise_cancelled(void *data, EINA_UNUSED const Eina_Promise *p)
{
- Test_Testing_Data *pd = data;
+ Dummy_Test_Object_Data *pd = data;
pd->promise = NULL;
}
-Eina_Future* _test_testing_get_future(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+Eina_Future* _dummy_test_object_get_future(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd)
{
if (pd->promise == NULL)
{
return eina_future_new(pd->promise);
}
-void _test_testing_fulfill_promise(Eo *obj, Test_Testing_Data *pd, int data)
+void _dummy_test_object_fulfill_promise(Eo *obj, Dummy_Test_Object_Data *pd, int data)
{
if (pd->promise == NULL)
{
eina_promise_resolve(pd->promise, v);
}
-void _test_testing_reject_promise(Eo *obj, Test_Testing_Data *pd, Eina_Error err)
+void _dummy_test_object_reject_promise(Eo *obj, Dummy_Test_Object_Data *pd, Eina_Error err)
{
if (pd->promise == NULL)
{
eina_promise_reject(pd->promise, err);
}
-Eina_Accessor *_test_testing_clone_accessor(Eo *obj, Test_Testing_Data *pd, Eina_Accessor *acc)
+Eina_Accessor *_dummy_test_object_clone_accessor(Eo *obj, Dummy_Test_Object_Data *pd, Eina_Accessor *acc)
{
if (pd->list_for_accessor)
eina_list_free(pd->list_for_accessor);
return eina_list_accessor_new(pd->list_for_accessor);
}
-#include "test_testing.eo.c"
-#include "test_numberwrapper.eo.c"
+void _dummy_test_object_dummy_test_iface_emit_test_conflicted(Eo *obj, Dummy_Test_Object_Data *pd)
+{
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_IFACE_EVENT_CONFLICTED, NULL);
+}
+
+void _dummy_test_object_dummy_test_iface_emit_nonconflicted(Eo *obj, Dummy_Test_Object_Data *pd)
+{
+ efl_event_callback_legacy_call(obj, DUMMY_TEST_IFACE_EVENT_NONCONFLICTED, NULL);
+}
+
+void _dummy_test_object_dummy_another_iface_emit_another_conflicted(Eo *obj, Dummy_Test_Object_Data *pd)
+{
+ efl_event_callback_legacy_call(obj, DUMMY_ANOTHER_IFACE_EVENT_CONFLICTED, NULL);
+}
+
+
+
+#include "dummy_test_object.eo.c"
+#include "dummy_numberwrapper.eo.c"
+#include "dummy_test_iface.eo.c"
+#include "dummy_another_iface.eo.c"
-eo_files = ['test_child.eo', 'test_numberwrapper.eo', 'test_testing.eo']
+eo_files = ['dummy_child.eo', 'dummy_numberwrapper.eo', 'dummy_test_object.eo', 'dummy_test_iface.eo', 'dummy_another_iface.eo']
eo_file_targets = []
projects / platform / upstream / efl.git / commitdiff