diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index ecd938d..9abacdf 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,80 +1,80 @@
 
 #### Qt 4 and 5 ####
 if(QT5_BUILD)
   find_package(ECM 1.1.0 REQUIRED NO_MODULE)
   set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 
   find_package(Qt5Core REQUIRED)
   find_package(Qt5Test REQUIRED)
 
-  include("../cmake/modules/ECMQt4To5Porting.cmake")
   include_directories(${QT_INCLUDES}) # TODO: Port away from this.
 
   if(CMAKE_VERSION VERSION_LESS 2.8.9)
     message(FATAL_ERROR "Akonadi Qt 5 build requires at least CMake version 2.8.9")
   endif()
 
   if (Qt5_POSITION_INDEPENDENT_CODE)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
   endif()
 
-  set(QT_QTTEST_LIBRARIES Qt5::Test)
+  set(QT_QTCORE_LIBRARY Qt5::Core)
+  set(QT_QTTEST_LIBRARY Qt5::Test)
 else()
   set(QT_USE_IMPORTED_TARGETS TRUE) # Qt 4 only
   set(QT_MIN_VERSION 4.6.2)         # Qt 4 only
 
   find_package(Qt4 REQUIRED)
 endif()
 
 
 add_definitions(-DTEST_DATA_PATH="${CMAKE_CURRENT_SOURCE_DIR}")
 
 include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/.. )
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
-include_directories(${QT_INCLUDES} ${QT_INCLUDE_DIR} QtCore)
+include_directories(${QT_INCLUDES} ${QT_INCLUDE_DIR})
 if (NOT APPLE)
     set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--no-undefined" ) 
 endif()
 
 if(PHP_BINDINGS)
     add_test(phptest php -d enable_dl=On -d include_path='.:/usr/share/pear:${CMAKE_BINARY_DIR}/src/php' -d extension=${CMAKE_BINARY_DIR}/src/php/kolabformat.so ${CMAKE_SOURCE_DIR}/src/php/test.php --verbose)
 endif()
 
 if (QT4_FOUND OR Qt5Core_FOUND)
     if (Qt5Core_FOUND)
       set(CMAKE_AUTOMOC ON)
       set(CMAKE_INCLUDE_CURRENT_DIR ON)
     endif()
 
     message("Buildings tests")
     if (QT4_FOUND)
       QT4_AUTOMOC(bindingstest.cpp)
       QT4_AUTOMOC(conversiontest.cpp)
       QT4_AUTOMOC(parsingtest.cpp)
       QT4_AUTOMOC(validationtest.cpp)
       QT4_AUTOMOC(kolabconversationtest.cpp)
      endif()
 
     add_executable(bindingstest bindingstest.cpp ${CMAKE_CURRENT_BINARY_DIR}/${BINDINGSTEST_MOC})
     target_link_libraries(bindingstest ${QT_QTTEST_LIBRARY} ${QT_QTCORE_LIBRARY} kolabxml ${XERCES_C})
     add_test(bindingstest ${CMAKE_CURRENT_BINARY_DIR}/bindingstest)
 
     add_executable(conversiontest conversiontest.cpp ${CMAKE_CURRENT_BINARY_DIR}/${CONVERSIONTEST_MOC})
     target_link_libraries(conversiontest ${QT_QTTEST_LIBRARY} ${QT_QTCORE_LIBRARY} kolabxml ${XERCES_C})
     add_test(conversiontest ${CMAKE_CURRENT_BINARY_DIR}/conversiontest)
 
     add_executable(parsingtest parsingtest.cpp ${CMAKE_CURRENT_BINARY_DIR}/${PARSINGTEST_MOC})
     target_link_libraries(parsingtest ${QT_QTTEST_LIBRARY} ${QT_QTCORE_LIBRARY} kolabxml ${XERCES_C})
     add_test(parsingtest ${CMAKE_CURRENT_BINARY_DIR}/parsingtest)
 
     add_executable(validationtest validationtest.cpp ${CMAKE_CURRENT_BINARY_DIR}/${VALIDATIONTEST_MOC})
     target_link_libraries(validationtest ${QT_QTTEST_LIBRARY} ${QT_QTCORE_LIBRARY} kolabxml ${XERCES_C})
     add_test(validationtest ${CMAKE_CURRENT_BINARY_DIR}/validationtest)
 
     add_executable(kolabconversationtest kolabconversationtest.cpp ${CMAKE_CURRENT_BINARY_DIR}/${KOLABCONVERSATIONTEST_MOC})
     target_link_libraries(kolabconversationtest ${QT_QTTEST_LIBRARY} ${QT_QTCORE_LIBRARY} kolabxml ${XERCES_C})
     add_test(kolabconversationtest ${CMAKE_CURRENT_BINARY_DIR}/kolabconversationtest)
 else()
     message(WARNING "Could not build tests because qt is missing")
 endif()
diff --git a/tests/serializers.h b/tests/serializers.h
index c266b71..7fc9739 100644
--- a/tests/serializers.h
+++ b/tests/serializers.h
@@ -1,218 +1,218 @@
 #ifndef SERIALIZERS_H
 #define SERIALIZERS_H
 
 #include <QByteArray>
 #include <QString>
 #include <src/kolabformat.h>
 
 namespace QTest {
     template<>
     char *toString(const Kolab::cDateTime &dt)
     {
         QByteArray ba = "Kolab::cDateTime(";
         ba += QByteArray::number(dt.year()) + ", " + QByteArray::number(dt.month())+ ", " + QByteArray::number(dt.day()) + ", ";
         ba += QByteArray::number(dt.hour()) + ", " + QByteArray::number(dt.minute()) + ", " + QByteArray::number(dt.second())+ ", ";
-        ba += QString(dt.isUTC()?QString("UTC"):QString("TZ: "+QString::fromStdString(dt.timezone()))).toLatin1();
+        ba += dt.isUTC()?QByteArray("UTC"):QByteArray("TZ: "+QByteArray(dt.timezone().c_str()));
         ba += ")";
         return qstrdup(ba.data());
     }
 
     template<>
     char *toString(const std::vector<Kolab::cDateTime> &v)
     {
         QByteArray ba = "vector<Kolab::cDateTime>(";
         for (std::size_t i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ "\n";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const Kolab::Attendee &a)
     {
         QByteArray ba = "Kolab::Attendee(";
-        ba += QString::fromStdString(a.contact().email()).toLatin1() + ", " + QString::fromStdString(a.contact().name()).toLatin1()+ ", " + 
-        QByteArray::number(a.partStat()) + ", " + QByteArray::number(a.role())  + ", " + QByteArray::number(a.rsvp())  + ", " + 
-        QString::fromStdString(a.contact().uid()).toLatin1();
+        ba += QByteArray(a.contact().email().c_str()) + ", " + QByteArray(a.contact().name().c_str())+ ", " +
+        QByteArray::number(a.partStat()) + ", " + QByteArray::number(a.role())  + ", " + QByteArray::number(a.rsvp())  + ", " +
+        QByteArray(a.contact().uid().c_str());
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const std::vector<Kolab::Attendee> &v)
     {
         QByteArray ba = "vector<Kolab::Attendee>(";
         for (std::size_t i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ ", ";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
      
     template<>
     char *toString(const std::string &s)
     {
         QByteArray ba = "string(";
-        ba += QString::fromStdString(s).toLatin1();
+        ba += QByteArray(s.c_str());
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const std::vector<std::string> &v)
     {
         QByteArray ba = "vector<std::string>(";
         for (std::size_t i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ ", ";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const std::vector<int> &v)
     {
         QByteArray ba = "vector<int>(";
         for (std::size_t i = 0; i < v.size(); i++) {
             ba += QString::number(v.at(i)).toLatin1()+ ", ";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const Kolab::Duration &dt)
     {
         QByteArray ba = "Kolab::Duration(";
         ba += QByteArray::number(dt.weeks()) + ", " + QByteArray::number(dt.days())+ ", " + QByteArray::number(dt.hours()) + ", ";
         ba += QByteArray::number(dt.minutes()) + ", " + QByteArray::number(dt.seconds()) + ", " + QByteArray::number(dt.isNegative());
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const Kolab::DayPos &dt)
     {
         QByteArray ba = "Kolab::DayPos(";
         ba += QByteArray::number(dt.occurence()) + ", " + QByteArray::number(dt.weekday());
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const Kolab::Attachment &a)
     {
         QByteArray ba = "Kolab::Attachment(";
-        ba += QString::fromStdString(a.uri()).toLatin1() + ", " + QString::fromStdString(a.mimetype()).toLatin1()+ ", " + 
-        QString::fromStdString(a.label()).toLatin1();
+        ba += QByteArray(a.uri().c_str()) + ", " + QByteArray(a.mimetype().c_str())+ ", " +
+        QByteArray(a.label().c_str());
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const std::vector<Kolab::Attachment> &v)
     {
         QByteArray ba = "vector<Kolab::Attachment>(";
         for (std::size_t i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ "\n";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const Kolab::ContactReference &a)
     {
         QByteArray ba = "Kolab::ContactReference(";
-        ba += QString::fromStdString(a.email()).toLatin1()+ ", ";
-        ba += QString::fromStdString(a.name()).toLatin1()+ ", ";
-        ba += QString::fromStdString(a.uid()).toLatin1();
+        ba += QByteArray(a.email().c_str())+ ", ";
+        ba += QByteArray(a.name().c_str())+ ", ";
+        ba += QByteArray(a.uid().c_str());
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const std::vector<Kolab::ContactReference> &v)
     {
         QByteArray ba = "vector<Kolab::ContactReference>(";
         for (std::size_t i = 0; i < v.size(); i++) {
                 ba += QByteArray(toString(v.at(i)))+ "\n";
             }
             ba += ")";
             return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const Kolab::Alarm &a)
     {
         QByteArray ba = "Kolab::Alarm(";
-        ba += QByteArray::number(a.type()) + "\n " + QString::fromStdString(a.summary())+ "\n " + 
-        QString::fromStdString(a.text())+"\n " +toString(a.duration()) + "\n " + QByteArray::number(a.numrepeat())+  "\n " + toString(a.start()) + "\n " +
-        toString(a.relativeStart())  + "\n " +  QByteArray::number(a.relativeTo()) + "\n " + toString(a.audioFile()) +  "\n " + toString(a.attendees()) + "\n ";
+        ba += QByteArray::number(a.type()) + "\n " + QByteArray(a.summary().c_str())+ "\n " +
+        QByteArray(a.text().c_str())+"\n " +QByteArray(toString(a.duration())) + "\n " + QByteArray::number(a.numrepeat())+  "\n " + QByteArray(toString(a.start())) + "\n " +
+        QByteArray(toString(a.relativeStart())) + "\n " + QByteArray::number(a.relativeTo()) + "\n " + QByteArray(toString(a.audioFile())) +  "\n " + QByteArray(toString(a.attendees())) + "\n ";
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const std::vector<Kolab::Alarm> &v)
     {
         QByteArray ba = "vector<Kolab::Alarm>(";
         for (std::size_t i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ "\n";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const Kolab::Related &a)
     {
         QByteArray ba = "Kolab::Related(";
-        ba += QString::fromStdString(a.text()).toLatin1()+ "\n " + 
-        QString::fromStdString(a.uri()).toLatin1()+"\n " +
+        ba += QByteArray(a.text().c_str())+ "\n " +
+        QByteArray(a.uri().c_str())+"\n " +
         QByteArray::number(a.relationTypes()) + "\n " +
         QByteArray::number(a.type()) + "\n ";
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const std::vector<Kolab::Related> &v)
     {
         QByteArray ba = "vector<Kolab::Related>(";
         for (std::size_t i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ "\n";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const Kolab::Affiliation &a)
     {
         QByteArray ba = "Kolab::Affiliation(";
-        ba += QString::fromStdString(a.organisation()).toLatin1()+ "\n " + 
-        QString::fromStdString(a.logo())+"\n " + "\n " + toString(a.roles())+  "\n " + toString(a.relateds()) + "\n " +
-        toString(a.addresses())  + "\n ";
+        ba += QByteArray(a.organisation().c_str())+ "\n " +
+        QByteArray(a.logo().c_str()) + "\n " + "\n " + QByteArray(toString(a.roles())) + "\n " + QByteArray(toString(a.relateds())) + "\n " +
+        QByteArray(toString(a.addresses())) + "\n ";
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
     char *toString(const std::vector<Kolab::Affiliation> &v)
     {
         QByteArray ba = "vector<Kolab::Affiliation>(";
         for (std::size_t i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ "\n";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
     
 
 
  }
  
 #endif