LCOV - Code Coverage - Accounts/utils.cpp

LCOV - code coverage report
Current view: | top level - Accounts - utils.cpp (source / functions) |  |  | Hit | Total | Coverage
Test: | Code Coverage |  | Lines: | 58 | 61 | 95.1 %
Date: | 2013-04-26 |  | Functions: | 5 | 5 | 100.0 %
Legend: | Lines: hit not hit | Branches: + taken - not taken # not executed |  | Branches: | 26 | 30 | 86.7 %

               Branch data     Line data    Source code
           1                 :            : /* vi: set et sw=4 ts=4 cino=t0,(0: */
           2                 :            : /*
           3                 :            :  * This file is part of libaccounts-qt
           4                 :            :  *
           5                 :            :  * Copyright (C) 2012 Canonical Ltd.
           6                 :            :  *
           7                 :            :  * Contact: Alberto Mardegan <alberto.mardegan@canonical.com>
           8                 :            :  *
           9                 :            :  * This library is free software; you can redistribute it and/or
          10                 :            :  * modify it under the terms of the GNU Lesser General Public License
          11                 :            :  * version 2.1 as published by the Free Software Foundation.
          12                 :            :  *
          13                 :            :  * This library is distributed in the hope that it will be useful, but
          14                 :            :  * WITHOUT ANY WARRANTY; without even the implied warranty of
          15                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
          16                 :            :  * Lesser General Public License for more details.
          17                 :            :  *
          18                 :            :  * You should have received a copy of the GNU Lesser General Public
          19                 :            :  * License along with this library; if not, write to the Free Software
          20                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
          21                 :            :  * 02110-1301 USA
          22                 :            :  */
          23                 :            :
          24                 :            : #include "accountscommon.h"
          25                 :            : #include "utils.h"
          26                 :            :
          27                 :            : #include <QStringList>
          28                 :            :
          29                 :            : namespace Accounts {
          30                 :            :
          31                 :          4 : static QVariantMap gVariantToQVariantMap(GVariant *variant)
          32                 :            : {
          33                 :            :     QVariantMap ret;
          34                 :            :     GVariantIter iter;
          35                 :            :     const gchar *key;
          36                 :            :     GVariant *value;
          37                 :            :
          38                 :          4 :     g_variant_iter_init (&iter, variant);
          39         [ +  + ]:         20 :     while (g_variant_iter_next (&iter, "{sv}", &key, &value)) {
          40                 :         16 :         ret.insert(UTF8(key), gVariantToQVariant(value));
          41                 :            :     }
          42                 :            :
          43                 :          4 :     return ret;
          44                 :            : }
          45                 :            :
          46                 :          2 : static GVariant *qStringListToGVariant(const QStringList &stringList)
          47                 :            : {
          48                 :            :     GVariantBuilder builder;
          49                 :            :
          50                 :          2 :     g_variant_builder_init(&builder, G_VARIANT_TYPE_STRING_ARRAY);
          51 [ +  - ][ +  + ]:          8 :     Q_FOREACH (const QString &string, stringList) {
                     [ +  + ]
          52                 :          6 :         g_variant_builder_add(&builder, "s", string.toUtf8().constData());
          53                 :          2 :     }
          54                 :          2 :     return g_variant_builder_end(&builder);
          55                 :            : }
          56                 :            :
          57                 :          4 : static QStringList gVariantToQStringList(GVariant *variant)
          58                 :            : {
          59                 :            :     QStringList ret;
          60                 :            :
          61                 :            :     gsize length;
          62                 :          4 :     const gchar **strings = g_variant_get_strv(variant, &length);
          63         [ +  + ]:         16 :     for (gsize i = 0; i < length; i++) {
          64                 :         12 :         ret.append(UTF8(strings[i]));
          65                 :            :     }
          66                 :            :
          67                 :          4 :     g_free(strings);
          68                 :          4 :     return ret;
          69                 :            : }
          70                 :            :
          71                 :         42 : QVariant gVariantToQVariant(GVariant *value)
          72                 :            : {
          73                 :         42 :     GVariantClass variantClass = g_variant_classify(value);
          74                 :            :
          75                 :            :     QVariant variant;
          76                 :            :
          77   [ +  +  +  +  :         42 :     switch (variantClass)
                 +  +  +  - ]
          78                 :            :     {
          79                 :            :     case G_VARIANT_CLASS_STRING:
          80                 :         14 :         variant = UTF8(g_variant_get_string(value, NULL));
          81                 :         14 :         break;
          82                 :            :     case G_VARIANT_CLASS_INT32:
          83                 :          7 :         variant = g_variant_get_int32(value);
          84                 :          7 :         break;
          85                 :            :     case G_VARIANT_CLASS_UINT32:
          86                 :          3 :         variant = g_variant_get_uint32(value);
          87                 :          3 :         break;
          88                 :            :     case G_VARIANT_CLASS_INT64:
          89                 :          1 :         variant = qint64(g_variant_get_int64(value));
          90                 :          1 :         break;
          91                 :            :     case G_VARIANT_CLASS_UINT64:
          92                 :          3 :         variant = quint64(g_variant_get_uint64(value));
          93                 :          3 :         break;
          94                 :            :     case G_VARIANT_CLASS_BOOLEAN:
          95                 :          6 :         variant = bool(g_variant_get_boolean(value));
          96                 :          6 :         break;
          97                 :            :     case G_VARIANT_CLASS_ARRAY:
          98         [ +  + ]:          8 :         if (g_variant_is_of_type(value, G_VARIANT_TYPE_VARDICT)) {
          99                 :          4 :             variant = gVariantToQVariantMap(value);
         100                 :          4 :             break;
         101         [ +  - ]:          4 :         } else if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING_ARRAY)) {
         102                 :          4 :             variant = gVariantToQStringList(value);
         103                 :          4 :             break;
         104                 :            :         }
         105                 :            :         // fall through
         106                 :            :     default:
         107                 :          0 :         qWarning() << "Unsupported type" << UTF8(g_variant_get_type_string(value));
         108                 :          0 :         break;
         109                 :            :     }
         110                 :            :
         111                 :         42 :     return variant;
         112                 :            : }
         113                 :            :
         114                 :         35 : GVariant *qVariantToGVariant(const QVariant &variant)
         115                 :            : {
         116                 :            :     GVariant *ret = 0;
         117                 :            :     QByteArray tmpvalue;
         118                 :            :
         119   [ +  +  +  +  :         35 :     switch (variant.type())
                 +  +  +  - ]
         120                 :            :     {
         121                 :            :     case QVariant::String:
         122                 :         18 :         tmpvalue = variant.toString().toUtf8();
         123                 :         18 :         ret = g_variant_new_string(tmpvalue.constData());
         124                 :         18 :         break;
         125                 :            :     case QVariant::Int:
         126                 :          5 :         ret = g_variant_new_int32(variant.toInt());
         127                 :          5 :         break;
         128                 :            :     case QVariant::UInt:
         129                 :          3 :         ret = g_variant_new_uint32(variant.toUInt());
         130                 :          3 :         break;
         131                 :            :     case QVariant::LongLong:
         132                 :          1 :         ret = g_variant_new_int64(variant.toLongLong());
         133                 :          1 :         break;
         134                 :            :     case QVariant::ULongLong:
         135                 :          1 :         ret = g_variant_new_uint64(variant.toULongLong());
         136                 :          1 :         break;
         137                 :            :     case QVariant::Bool:
         138                 :          5 :         ret = g_variant_new_boolean(variant.toBool());
         139                 :          5 :         break;
         140                 :            :     case QVariant::StringList:
         141                 :          2 :         ret = qStringListToGVariant(variant.toStringList());
         142                 :          2 :         break;
         143                 :            :     default:
         144                 :          0 :         qWarning() << "Unsupported datatype" << variant.typeName();
         145                 :            :     }
         146                 :            :
         147                 :         35 :     return ret;
         148                 :            : }
         149                 :            :
         150                 :         21 : }; // namespace

Generated by: LCOV version 1.9