diff --git a/src/Makefile_Eina_Cxx.am b/src/Makefile_Eina_Cxx.am
index 0f19276030..60fead4124 100644
--- a/src/Makefile_Eina_Cxx.am
+++ b/src/Makefile_Eina_Cxx.am
@@ -41,7 +41,7 @@ tests/eina_cxx/eina_cxx_test_stringshare.cc \
 tests/eina_cxx/eina_cxx_test_error.cc \
 tests/eina_cxx/eina_cxx_test_accessor.cc \
 tests/eina_cxx/eina_cxx_test_thread.cc \
-tests/eina_cxx/eina_cxx_test_eina_value.cc
+tests/eina_cxx/eina_cxx_test_value.cc
 
 tests_eina_cxx_eina_cxx_suite_CXXFLAGS = -I$(top_builddir)/src/lib/efl \
 -I$(top_builddir)/src/bindings/eina_cxx \
diff --git a/src/bindings/eina_cxx/eina_value.hh b/src/bindings/eina_cxx/eina_value.hh
index b202f2e63e..6226878121 100644
--- a/src/bindings/eina_cxx/eina_value.hh
+++ b/src/bindings/eina_cxx/eina_value.hh
@@ -232,12 +232,12 @@ struct _eina_value_traits<T[], typename eina::enable_if<eina::is_pod<T>::value>:
   }
 };
 
-class eina_value;
+class value;
 
 template <typename T>
-T get(eina_value const& v);
+T get(value const& v);
 
-class eina_value
+class value
 {
   template <typename T>
   void primitive_init(T v)
@@ -246,68 +246,68 @@ class eina_value
     _eina_value_traits<T>::set(_raw, v);
   }
 public:
-  eina_value()
+  value()
     : _raw(_eina_value_traits<char>::create())
   {
   }
   template <typename T>
-  eina_value(T v)
+  value(T v)
   {
     primitive_init(v);
   }
-  eina_value(char v)
+  value(char v)
   {
     primitive_init(v);
   }
-  eina_value(short v)
+  value(short v)
   {
     primitive_init(v);
   }
-  eina_value(int v)
+  value(int v)
   {
     primitive_init(v);
   }
-  eina_value(long v)
+  value(long v)
   {
     primitive_init(v);
   }
-  eina_value(unsigned char v)
+  value(unsigned char v)
   {
     primitive_init(v);
   }
-  eina_value(unsigned short v)
+  value(unsigned short v)
   {
     primitive_init(v);
   }
-  eina_value(unsigned int v)
+  value(unsigned int v)
   {
     primitive_init(v);
   }
-  eina_value(unsigned long v)
+  value(unsigned long v)
   {
     primitive_init(v);
   }
-  eina_value(float v)
+  value(float v)
   {
     primitive_init(v);
   }
-  eina_value(double v)
+  value(double v)
   {
     primitive_init(v);
   }
 
-  ~eina_value()
+  ~value()
   {
     eina_value_free(_raw);
   }
 
-  eina_value(eina_value const& other)
+  value(value const& other)
     : _raw(_eina_value_traits<char>::create())
   {
     if(!eina_value_copy(const_cast<Eina_Value const*>(other._raw), _raw))
       throw eina::system_error(eina::get_error_code());
   }
-  eina_value& operator=(eina_value const& other)
+  value& operator=(value const& other)
   {
     eina_value_flush(_raw);
     if(!eina_value_copy(const_cast<Eina_Value const*>(other._raw), _raw))
@@ -315,7 +315,7 @@ public:
     return *this;
   }
 
-  void swap(eina_value& other)
+  void swap(value& other)
   {
     std::swap(_raw, other._raw);
   }
@@ -334,48 +334,48 @@ private:
   ::Eina_Value* _raw;
 
   template <typename T>
-  friend T get(eina_value const& v)
+  friend T get(value const& v)
   {
     return _eina_value_traits<T>::get(v._raw);
   }
 };
 
-inline void swap(eina_value& lhs, eina_value& rhs)
+inline void swap(value& lhs, value& rhs)
 {
   lhs.swap(rhs);
 }
 
-inline bool operator==(eina_value const& lhs, eina_value const& rhs)
+inline bool operator==(value const& lhs, value const& rhs)
 {
   return lhs.type_info() == rhs.type_info()
     && eina_value_compare(lhs.native_handle(), rhs.native_handle()) == 0;
 }
 
-inline bool operator<(eina_value const& lhs, eina_value const& rhs)
+inline bool operator<(value const& lhs, value const& rhs)
 {
   return std::less<Eina_Value_Type const*>()(lhs.type_info(), rhs.type_info())
     || (lhs.type_info() == rhs.type_info()
         && eina_value_compare(lhs.native_handle(), rhs.native_handle()) < 0);
 }
 
-inline bool operator>(eina_value const& lhs, eina_value const& rhs)
+inline bool operator>(value const& lhs, value const& rhs)
 {
   return std::less<Eina_Value_Type const*>()(rhs.type_info(), lhs.type_info())
     || (rhs.type_info() == lhs.type_info()
         && eina_value_compare(lhs.native_handle(), rhs.native_handle()) > 0);
 }
 
-inline bool operator<=(eina_value const& lhs, eina_value const& rhs)
+inline bool operator<=(value const& lhs, value const& rhs)
 {
   return !(lhs > rhs);
 }
 
-inline bool operator>=(eina_value const& lhs, eina_value const& rhs)
+inline bool operator>=(value const& lhs, value const& rhs)
 {
   return !(lhs < rhs);
 }
 
-inline bool operator!=(eina_value const& lhs, eina_value const& rhs)
+inline bool operator!=(value const& lhs, value const& rhs)
 {
   return !(lhs == rhs);
 }
diff --git a/src/tests/eina_cxx/eina_cxx_suite.cc b/src/tests/eina_cxx/eina_cxx_suite.cc
index a9c20dc61a..a842e00f07 100644
--- a/src/tests/eina_cxx/eina_cxx_suite.cc
+++ b/src/tests/eina_cxx/eina_cxx_suite.cc
@@ -15,7 +15,7 @@ void eina_test_stringshare(TCase* tc);
 void eina_test_error(TCase* tc);
 void eina_test_accessor(TCase* tc);
 void eina_test_thread(TCase* tc);
-void eina_test_eina_value(TCase* tc);
+void eina_test_value(TCase* tc);
 
 typedef struct _Eina_Test_Case Eina_Test_Case;
 struct _Eina_Test_Case
@@ -34,7 +34,7 @@ static const Eina_Test_Case etc[] = {
    { "Error", eina_test_error },
    { "Accessor", eina_test_accessor },
    { "Thread", eina_test_thread },
-   { "EinaValue", eina_test_eina_value },
+   { "Value", eina_test_value },
    { NULL, NULL }
 };
 
diff --git a/src/tests/eina_cxx/eina_cxx_test_eina_value.cc b/src/tests/eina_cxx/eina_cxx_test_value.cc
similarity index 55%
rename from src/tests/eina_cxx/eina_cxx_test_eina_value.cc
rename to src/tests/eina_cxx/eina_cxx_test_value.cc
index f9ddd2e6d4..07bf3e506f 100644
--- a/src/tests/eina_cxx/eina_cxx_test_eina_value.cc
+++ b/src/tests/eina_cxx/eina_cxx_test_value.cc
@@ -3,89 +3,89 @@
 
 #include <check.h>
 
-START_TEST(eina_cxx_eina_value_constructors)
+START_TEST(eina_cxx_value_constructors)
 {
   efl::eina::eina_init init;
 
-  efl::eina::eina_value v;
+  efl::eina::value v;
 
   char c = 'c';
-  efl::eina::eina_value vchar(c);
+  efl::eina::value vchar(c);
 
   short s = 5;
-  efl::eina::eina_value vshort(s);
+  efl::eina::value vshort(s);
 
-  efl::eina::eina_value vint(5);
+  efl::eina::value vint(5);
 
-  efl::eina::eina_value vlong(5l);
+  efl::eina::value vlong(5l);
 
   unsigned char uc = 'b';
-  efl::eina::eina_value vuchar(uc);
+  efl::eina::value vuchar(uc);
 
   unsigned short us = 5;
-  efl::eina::eina_value vushort(us);
+  efl::eina::value vushort(us);
 
-  efl::eina::eina_value vuint(5u);
+  efl::eina::value vuint(5u);
 
-  efl::eina::eina_value vulong(5ul);
+  efl::eina::value vulong(5ul);
 
-  efl::eina::eina_value vu64(uint64_t(5ul));
+  efl::eina::value vu64(uint64_t(5ul));
 
-  efl::eina::eina_value vfloat(5.0f);
+  efl::eina::value vfloat(5.0f);
 
-  efl::eina::eina_value vdouble(5.0);
+  efl::eina::value vdouble(5.0);
 }
 END_TEST
 
-START_TEST(eina_cxx_eina_value_get)
+START_TEST(eina_cxx_value_get)
 {
   efl::eina::eina_init init;
 
   char c = 'c';
-  efl::eina::eina_value vchar(c);
+  efl::eina::value vchar(c);
   ck_assert(efl::eina::get<char>(vchar) == 'c');
 
   short s = 5;
-  efl::eina::eina_value vshort(s);
+  efl::eina::value vshort(s);
   ck_assert(efl::eina::get<short>(vshort) == 5);
 
-  efl::eina::eina_value vint(6);
+  efl::eina::value vint(6);
   ck_assert(efl::eina::get<int>(vint) == 6);
 
-  efl::eina::eina_value vlong(7l);
+  efl::eina::value vlong(7l);
   ck_assert(efl::eina::get<long>(vlong) == 7l);
 
   unsigned char uc = 'b';
-  efl::eina::eina_value vuchar(uc);
+  efl::eina::value vuchar(uc);
   ck_assert(efl::eina::get<unsigned char>(vuchar) == 'b');
 
   unsigned short us = 8;
-  efl::eina::eina_value vushort(us);
+  efl::eina::value vushort(us);
   ck_assert(efl::eina::get<unsigned short>(vushort) == 8);
 
-  efl::eina::eina_value vuint(9u);
+  efl::eina::value vuint(9u);
   ck_assert(efl::eina::get<unsigned int>(vuint) == 9u);
 
-  efl::eina::eina_value vulong(10ul);
+  efl::eina::value vulong(10ul);
   ck_assert(efl::eina::get<unsigned long>(vulong) == 10ul);
 
-  efl::eina::eina_value vu64((uint64_t)10ul);
+  efl::eina::value vu64((uint64_t)10ul);
   ck_assert(efl::eina::get<uint64_t>(vu64) == 10ul);
 
-  efl::eina::eina_value vfloat(11.0f);
+  efl::eina::value vfloat(11.0f);
   ck_assert(efl::eina::get<float>(vfloat) == 11.0f);
 
-  efl::eina::eina_value vdouble(12.0);
+  efl::eina::value vdouble(12.0);
   ck_assert(efl::eina::get<double>(vdouble) == 12.0f);
 }
 END_TEST
 
-START_TEST(eina_cxx_eina_value_wrong_get)
+START_TEST(eina_cxx_value_wrong_get)
 {
   efl::eina::eina_init init;
 
   char c = 'c';
-  efl::eina::eina_value vchar(c);
+  efl::eina::value vchar(c);
   try
   {
     efl::eina::get<int>(vchar);
@@ -97,37 +97,37 @@ START_TEST(eina_cxx_eina_value_wrong_get)
 }
 END_TEST
 
-START_TEST(eina_cxx_eina_value_comparison_operators)
+START_TEST(eina_cxx_value_comparison_operators)
 {
   efl::eina::eina_init init;
 
-  efl::eina::eina_value v;
+  efl::eina::value v;
 
   char c = 5;
-  efl::eina::eina_value vchar(c);
+  efl::eina::value vchar(c);
 
   short s = 5;
-  efl::eina::eina_value vshort(s);
+  efl::eina::value vshort(s);
 
-  efl::eina::eina_value vint(5);
+  efl::eina::value vint(5);
 
-  efl::eina::eina_value vlong(5l);
+  efl::eina::value vlong(5l);
 
   unsigned char uc = 5;
-  efl::eina::eina_value vuchar(uc);
+  efl::eina::value vuchar(uc);
 
   unsigned short us = 5;
-  efl::eina::eina_value vushort(us);
+  efl::eina::value vushort(us);
 
-  efl::eina::eina_value vuint(5u);
+  efl::eina::value vuint(5u);
 
-  efl::eina::eina_value vulong(5ul);
+  efl::eina::value vulong(5ul);
 
-  efl::eina::eina_value vu64((uint64_t)5ul);
+  efl::eina::value vu64((uint64_t)5ul);
 
-  efl::eina::eina_value vfloat(5.0f);
+  efl::eina::value vfloat(5.0f);
 
-  efl::eina::eina_value vdouble(5.0);
+  efl::eina::value vdouble(5.0);
 
   ck_assert(vchar == vchar);
   ck_assert(vshort == vshort);
@@ -161,17 +161,17 @@ START_TEST(eina_cxx_eina_value_comparison_operators)
 }
 END_TEST
 
-START_TEST(eina_cxx_eina_value_copying)
+START_TEST(eina_cxx_value_copying)
 {
   char c = 5;
 
-  efl::eina::eina_value vchar(c);
-  efl::eina::eina_value vchar2(vchar);
+  efl::eina::value vchar(c);
+  efl::eina::value vchar2(vchar);
   ck_assert(vchar == vchar2);
   ck_assert(efl::eina::get<char>(vchar) == 5);
   ck_assert(efl::eina::get<char>(vchar2) == 5);
 
-  efl::eina::eina_value vint(10);
+  efl::eina::value vint(10);
   vchar = vint;
   ck_assert(vchar != vchar2);
   ck_assert(vint == vchar);
@@ -181,11 +181,11 @@ START_TEST(eina_cxx_eina_value_copying)
 END_TEST
 
 void
-eina_test_eina_value(TCase* tc)
+eina_test_value(TCase* tc)
 {
-  tcase_add_test(tc, eina_cxx_eina_value_constructors);
-  tcase_add_test(tc, eina_cxx_eina_value_get);
-  tcase_add_test(tc, eina_cxx_eina_value_wrong_get);
-  tcase_add_test(tc, eina_cxx_eina_value_comparison_operators);
-  tcase_add_test(tc, eina_cxx_eina_value_copying);
+  tcase_add_test(tc, eina_cxx_value_constructors);
+  tcase_add_test(tc, eina_cxx_value_get);
+  tcase_add_test(tc, eina_cxx_value_wrong_get);
+  tcase_add_test(tc, eina_cxx_value_comparison_operators);
+  tcase_add_test(tc, eina_cxx_value_copying);
 }