/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "ut_transformcontactdata.h"

#include "cnttransformemail.h"

#include "cnttransformname.h"

#include "cnttransformnickname.h"

#include "cnttransformphonenumber.h"

#include "cnttransformaddress.h"

#include "cnttransformurl.h"

#include "cnttransformbirthday.h"

#include "cnttransformonlineaccount.h"

#include "cnttransformorganisation.h"

#include "cnttransformavatar.h"

#include "cnttransformsynctarget.h"

#include "cnttransformgender.h"

#include "cnttransformanniversary.h"

#include "cnttransformgeolocation.h"

#include "cnttransformnote.h"

#include "cnttransformfamily.h"

#include "cntmodelextuids.h"

#include <QtTest/QtTest>

#include <qglobal.h>

void TestCntTransformContactData::initTestCase()

{

}

void TestCntTransformContactData::cleanupTestCase()

{

}

void TestCntTransformContactData::executeCntTransformEmail()

{

    TRAPD(err, validateCntTransformEmailL(_L("dummyemail"), QString("dummyemail"));

        validateCntTransformEmailL(_L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformName()

{

    TRAPD(err, validateCntTransformNameL(_L("dummyprefix"), QString("dummyprefix"),

                          _L("dummyfirst"), QString("dummyfirst"),

                          _L("dummymiddle"), QString("dummymiddle"),

                          _L("dummylast"), QString("dummylast"),

                          _L("dummysuffix"), QString("dummysuffix"),

                          _L("dummylabel"), QString("dummylabel"));

        validateCntTransformNameL(_L(""), QString(""),

                          _L(""), QString(""),

                          _L(""), QString(""),

                          _L(""), QString(""),

                          _L(""), QString(""),

                          _L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformNickname()

{

    TRAPD(err, validateCntTransformNicknameL(_L("dummynickname"), QString("dummynickname"));

        validateCntTransformNicknameL(_L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformPhonenumber()

{

    TRAPD(err, validateCntTransformPhonenumberL(_L("dummyphonenumber"), QString("dummyphonenumber"));

        validateCntTransformPhonenumberL(_L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformAddress()

{

    TRAPD(err, validateCntTransformAddressL(_L("dummycountry"), QString("dummycountry"),

                             _L("dummypostcode"), QString("dummypostcode"),

                             _L("dummystreet"), QString("dummystreet"),

                             _L("dummylocality"), QString("dummylocality"),

                             _L("dummyregion"), QString("dummyregion"),

                             _L("dummypostofficebox"), QString("dummypostofficebox"));

        validateCntTransformAddressL(_L(""), QString(""),

                             _L(""), QString(""),

                             _L(""), QString(""),

                             _L(""), QString(""),

                             _L(""), QString(""),

                             _L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformUrl()

{

    TRAPD(err, validateCntTransformUrlL(_L("dummyurl"), QString("dummyurl"));

        validateCntTransformUrlL(_L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformBithday()

{

    TDateTime dateTime(2009, ESeptember, 27, 0, 0, 0, 0);

    TTime field(dateTime);

    QDate detail(2009, 9, 28);

    TRAPD(err, validateCntTransformBirthdayL(field, detail););

    QVERIFY(err == 0);

}

#ifdef SYMBIAN_BACKEND_USE_SQLITE

void TestCntTransformContactData::executeCntTransformOnlineAccount()

{

    TRAPD(err, validateCntTransformOnlineAccountL(_L("dummysip"), QString("dummysip"),

                                                  _L("nokia"), QString("nokia"),

                                                  _L("Available"), QString("Available"),

                                                  _L("Sleeping.."), QString("Sleeping.."));

        validateCntTransformOnlineAccountL(_L(""), QString(""),

                                           _L(""), QString(""),

                                           _L(""), QString(""),

                                           _L(""), QString(""));

        );

    QVERIFY(err == 0);

}

#endif // SYMBIAN_BACKEND_USE_SQLITE

void TestCntTransformContactData::executeCntTransformOrganisation()

{

    TRAPD(err, validateCntTransformOrganisationL(_L("dummycompany"), QString("dummycompany"),

                                  _L("dummydepartment"), QStringList("dummydepartment"),

                                  _L("dummyjobtitle"), QString("dummyjobtitle"),

                                  _L("dummyassistant"), QString("dummyassistant"));

        validateCntTransformOrganisationL(_L(""), QString(""),

                                  _L(""), QStringList(""),

                                  _L(""), QString(""),

                                  _L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformAvatar()

{

    TRAPD(err, validateCntTransformAvatarL(_L("dummyavatar"), QString("dummyavatar"));

        validateCntTransformAvatarL(_L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformSyncTarget()

{

    TRAPD(err, validateCntTransformSyncTargetL(_L("dummysynctarget"), QString("dummysynctarget"));

        validateCntTransformSyncTargetL(_L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformGender()

{

    TRAPD(err, validateCntTransformGenderL(_L("dummygender"), QString("dummygender"));

        validateCntTransformGenderL(_L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformAnniversary()

{

    QDate dateDetail(2009, 9, 28);

    TRAPD(err, validateCntTransformAnniversaryL(_L("2009-09-28,dummyevent"), dateDetail, QString("dummyevent"));

        validateCntTransformAnniversaryL(_L("dummyevent"), QDate(), QString("dummyevent"));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformGeolocation()

{

    TRAPD(err, validateCntTransformGeolocationL(_L("123.45,765.88"), 123.45, 765.88);

        validateCntTransformGeolocationL(_L("123.45,"), 123.45, -1);

        validateCntTransformGeolocationL(_L(",765.88"), -1, 765.88);

        validateCntTransformGeolocationL(_L(""), -1, -1);

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformNote()

{

    TRAPD(err, validateCntTransformNoteL(_L("dummynote"), QString("dummynote"));

        validateCntTransformNoteL(_L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::executeCntTransformFamily()

{

    TRAPD(err, validateCntTransformFamilyL(_L("dummyspouse"), QString("dummyspouse"),

                            _L("dummychild"), QString("dummychild"));

        validateCntTransformFamilyL(_L(""), QString(""),

                            _L(""), QString(""));

        );

    QVERIFY(err == 0);

}

void TestCntTransformContactData::validateCntTransformEmailL(TPtrC16 field, QString detail)

{

    CntTransformContactData* transformEmail = new CntTransformEmail();

    QVERIFY(transformEmail != 0);

    QVERIFY(transformEmail->supportsField(KUidContactFieldEMail.iUid));

    QVERIFY(!(transformEmail->supportsField(0))); //Test for Wrong value

    QVERIFY(transformEmail->supportsDetail(QContactEmailAddress::DefinitionName));

    QVERIFY(!(transformEmail->supportsDetail("WrongValue")));

    //Test getIdForField

    validateGetIdForField(*transformEmail, QContactEmailAddress::FieldEmailAddress,

                           KUidContactFieldEMail.iUid);

    validateGetIdForField(*transformEmail, "WrongValue",0);

    QVERIFY( !(transformEmail->supportsSubType("WrongValue")));

    //Test supportedSortingFieldTypes

    QList<TUid> uidsToVerify;

    uidsToVerify << KUidContactFieldEMail;

    validateSupportedSortingFieldTypes(*transformEmail,QContactEmailAddress::FieldEmailAddress,uidsToVerify);

    uidsToVerify.clear();

    validateSupportedSortingFieldTypes(*transformEmail,"WrongValue",uidsToVerify);

    validateContextsL(transformEmail);

    QContactEmailAddress email;

    email.setEmailAddress(detail);

    QList<CContactItemField *> fields = transformEmail->transformDetailL(email);

    if(detail.isEmpty()) {

        QVERIFY(fields.count() == 0);

    } else {

        QVERIFY(fields.count() == 1);

        QVERIFY(fields.at(0)->StorageType() == KStorageTypeText);

        QVERIFY(fields.at(0)->ContentType().ContainsFieldType(KUidContactFieldEMail));

        QCOMPARE(fields.at(0)->TextStorage()->Text().CompareF(field), 0);

    }

    CContactItemField* newField = CContactItemField::NewL(KStorageTypeText, KUidContactFieldEMail);

    newField->TextStorage()->SetTextL(field);

    QContact contact;

    QContactDetail* contactDetail = transformEmail->transformItemField(*newField, contact);

    const QContactEmailAddress* emailAddress(static_cast<const QContactEmailAddress*>(contactDetail));

    QCOMPARE(emailAddress->emailAddress(), detail);

    delete contactDetail;

    delete newField;

    delete transformEmail;

}

void TestCntTransformContactData::validateCntTransformNameL(TPtrC16 prefixField, QString prefixDetail,

                           TPtrC16 firstnameField, QString firstnameDetail,

                           TPtrC16 middlenameField, QString middlenameDetail,

                           TPtrC16 lastnameField, QString lastnameDetail,

                           TPtrC16 suffixField, QString suffixDetail,

                           TPtrC16 customLabelField, QString customLabelDetail)

{

    CntTransformContactData* transformName = new CntTransformName();

    QVERIFY(transformName != 0);

    QVERIFY(transformName->supportsField(KUidContactFieldPrefixName.iUid));

    QVERIFY(transformName->supportsField(KUidContactFieldGivenName.iUid));

    QVERIFY(transformName->supportsField(KUidContactFieldAdditionalName.iUid));

    QVERIFY(transformName->supportsField(KUidContactFieldFamilyName.iUid));

    QVERIFY(transformName->supportsField(KUidContactFieldSuffixName.iUid));

    QVERIFY(!(transformName->supportsField(0))); //Test for Wrong value

    QVERIFY(transformName->supportsDetail(QContactName::DefinitionName));

    QVERIFY(!(transformName->supportsDetail("WrongValue")));

    validateGetIdForField(*transformName, QContactName::FieldPrefix,KUidContactFieldPrefixName.iUid);

    validateGetIdForField(*transformName, QContactName::FieldFirstName, KUidContactFieldGivenName.iUid);

    validateGetIdForField(*transformName, QContactName::FieldMiddleName,KUidContactFieldAdditionalName.iUid);

    validateGetIdForField(*transformName, QContactName::FieldLastName,KUidContactFieldFamilyName.iUid);

    validateGetIdForField(*transformName, QContactName::FieldSuffix,KUidContactFieldSuffixName.iUid);

    validateGetIdForField(*transformName, "WrongValue", 0);

    QVERIFY( !(transformName->supportsSubType("WrongValue")));

    //Test supportedSortingFieldTypes

    //supportedSortingFieldTypes - FieldPrefix

    QList<TUid> uidsToVerify;

    uidsToVerify << KUidContactFieldPrefixName;

    validateSupportedSortingFieldTypes(*transformName,QContactName::FieldPrefix,uidsToVerify);

    //supportedSortingFieldTypes - FieldFirst

    uidsToVerify.clear();

    uidsToVerify << KUidContactFieldGivenName;

    validateSupportedSortingFieldTypes(*transformName,QContactName::FieldFirstName,uidsToVerify);

    //supportedSortingFieldTypes - FieldMiddle

    uidsToVerify.clear();

    uidsToVerify << KUidContactFieldAdditionalName;

    validateSupportedSortingFieldTypes(*transformName,QContactName::FieldMiddleName,uidsToVerify);

    //supportedSortingFieldTypes - FieldLast

    uidsToVerify.clear();

    uidsToVerify << KUidContactFieldFamilyName;

    validateSupportedSortingFieldTypes(*transformName,QContactName::FieldLastName,uidsToVerify);

    //supportedSortingFieldTypes - FieldSuffix

    uidsToVerify.clear();

    uidsToVerify << KUidContactFieldSuffixName;

    validateSupportedSortingFieldTypes(*transformName,QContactName::FieldSuffix,uidsToVerify);

    //supportedSortingFieldTypes - Wrongfieldvalue

    uidsToVerify.clear();

    validateSupportedSortingFieldTypes(*transformName,"WrongValue",uidsToVerify);

    validateContextsL(transformName);

    QContactName name;

    name.setPrefix(prefixDetail);

    name.setFirstName(firstnameDetail);

    name.setLastName(lastnameDetail);

    name.setMiddleName(middlenameDetail);

    name.setSuffix(suffixDetail);

    name.setCustomLabel(customLabelDetail);

    QList<CContactItemField *> fields = transformName->transformDetailL(name);

    // Assume zero or 6 details

    if(prefixDetail.isEmpty()) {

        QVERIFY(fields.count() == 0);

    } else {

        QVERIFY(fields.count() == 6);

        QVERIFY(fields.at(0)->StorageType() == KStorageTypeText);

        QVERIFY(fields.at(0)->ContentType().ContainsFieldType(KUidContactFieldPrefixName));

        QCOMPARE(fields.at(0)->TextStorage()->Text().CompareF(prefixField), 0);

        QVERIFY(fields.at(1)->StorageType() == KStorageTypeText);

        QVERIFY(fields.at(1)->ContentType().ContainsFieldType(KUidContactFieldGivenName));

        QCOMPARE(fields.at(1)->TextStorage()->Text().CompareF(firstnameField), 0);

        QVERIFY(fields.at(2)->StorageType() == KStorageTypeText);

        QVERIFY(fields.at(2)->ContentType().ContainsFieldType(KUidContactFieldAdditionalName));

        QCOMPARE(fields.at(2)->TextStorage()->Text().CompareF(middlenameField), 0);

        QVERIFY(fields.at(3)->StorageType() == KStorageTypeText);

        QVERIFY(fields.at(3)->ContentType().ContainsFieldType(KUidContactFieldFamilyName));

        QCOMPARE(fields.at(3)->TextStorage()->Text().CompareF(lastnameField), 0);

        QVERIFY(fields.at(4)->StorageType() == KStorageTypeText);

        QVERIFY(fields.at(4)->ContentType().ContainsFieldType(KUidContactFieldSuffixName));

        QCOMPARE(fields.at(4)->TextStorage()->Text().CompareF(suffixField), 0);

        QVERIFY(fields.at(5)->StorageType() == KStorageTypeText);

        QVERIFY(fields.at(5)->ContentType().ContainsFieldType(KUidContactFieldTemplateLabel));

        QCOMPARE(fields.at(5)->TextStorage()->Text().CompareF(customLabelField), 0);

    }

    CContactItemField* newField = CContactItemField::NewL(KStorageTypeText, KUidContactFieldPrefixName);

    newField->TextStorage()->SetTextL(prefixField);

    QContact contact;

    QContactDetail* contactDetail = transformName->transformItemField(*newField, contact);

    const QContactName* nameInfo1(static_cast<const QContactName*>(contactDetail));

    QCOMPARE(nameInfo1->prefix(), prefixDetail);

    delete contactDetail;

    contactDetail = 0;

    delete newField;

    newField = 0;

    newField = CContactItemField::NewL(KStorageTypeText, KUidContactFieldGivenName);

    newField->TextStorage()->SetTextL(firstnameField);

    contactDetail = transformName->transformItemField(*newField, contact);

    const QContactName* nameInfo2(static_cast<const QContactName*>(contactDetail));

    QCOMPARE(nameInfo2->firstName(), firstnameDetail);

    delete contactDetail;

    contactDetail = 0;

    delete newField;

    newField = 0;

    newField = CContactItemField::NewL(KStorageTypeText, KUidContactFieldAdditionalName);

    newField->TextStorage()->SetTextL(middlenameField);

    contactDetail = transformName->transformItemField(*newField, contact);

    const QContactName* nameInfo3(static_cast<const QContactName*>(contactDetail));

    QCOMPARE(nameInfo3->middleName(), middlenameDetail);

    delete contactDetail;

    contactDetail = 0;

    delete newField;

    newField = 0;

    newField = CContactItemField::NewL(KStorageTypeText, KUidContactFieldFamilyName);

    newField->TextStorage()->SetTextL(lastnameField);

    contactDetail = transformName->transformItemField(*newField, contact);

    const QContactName* nameInfo4(static_cast<const QContactName*>(contactDetail));

    QCOMPARE(nameInfo4->lastName(), lastnameDetail);

    delete contactDetail;

    contactDetail = 0;

    delete newField;

    newField = 0;

    newField = CContactItemField::NewL(KStorageTypeText, KUidContactFieldSuffixName);

    newField->TextStorage()->SetTextL(suffixField);

    contactDetail = transformName->transformItemField(*newField, contact);

    const QContactName* nameInfo5(static_cast<const QContactName*>(contactDetail));

    QCOMPARE(nameInfo5->suffix(), suffixDetail);

    delete contactDetail;

    contactDetail = 0;

    delete newField;

    newField = 0;

    delete transformName;

}

void TestCntTransformContactData::validateCntTransformNicknameL(TPtrC16 field, QString detail)

{

    CntTransformContactData* transformNickname = new CntTransformNickname();

    QVERIFY(transformNickname != 0);

    QVERIFY(transformNickname->supportsField(KUidContactFieldSecondName.iUid));

    QVERIFY(!(transformNickname->supportsField(0))); //Test for Wrong value

    QVERIFY(transformNickname->supportsDetail(QContactNickname::DefinitionName));

    QVERIFY(!(transformNickname->supportsDetail("WrongValue")));

    validateGetIdForField(*transformNickname, QContactNickname::FieldNickname,KUidContactFieldSecondName.iUid);

    validateGetIdForField(*transformNickname, "WrongValue", 0);

    QVERIFY( !(transformNickname->supportsSubType("WrongValue")));

    //Test supportedSortingFieldTypes

    QList<TUid> uidsToVerify;

    uidsToVerify << KUidContactFieldSecondName;

    validateSupportedSortingFieldTypes(*transformNickname,QContactNickname::FieldNickname,uidsToVerify);

    uidsToVerify.clear();

    validateSupportedSortingFieldTypes(*transformNickname,"WrongValue",uidsToVerify);

    validateContextsL(transformNickname);

    QContactNickname nickname;

    nickname.setNickname(detail);

    QList<CContactItemField *> fields = transformNickname->transformDetailL(nickname);

    if(detail.isEmpty()) {

        QVERIFY(fields.count() == 0);

    } else {

        QVERIFY(fields.count() == 1);

        QVERIFY(fields.at(0)->StorageType() == KStorageTypeText);

        QVERIFY(fields.at(0)->ContentType().ContainsFieldType(KUidContactFieldSecondName));

        QCOMPARE(fields.at(0)->TextStorage()->Text().CompareF(field), 0);

    }

    CContactItemField* newField = CContactItemField::NewL(KStorageTypeText, KUidContactFieldSecondName);

    newField->TextStorage()->SetTextL(field);

    QContact contact;

    QContactDetail* contactDetail = transformNickname->transformItemField(*newField, contact);

    const QContactNickname* nicknameInfo(static_cast<const QContactNickname*>(contactDetail));

    QCOMPARE(nicknameInfo->nickname(), detail);

    delete contactDetail;

    delete newField;

    delete transformNickname;

}

void TestCntTransformContactData::validateCntTransformPhonenumberL(TPtrC16 field, QString detail)

{

    CntTransformContactData* transformPhoneNumber = new CntTransformPhoneNumber();

    QVERIFY(transformPhoneNumber != 0);

    QVERIFY(transformPhoneNumber->supportsField(KUidContactFieldPhoneNumber.iUid));

    QVERIFY(transformPhoneNumber->supportsField(KUidContactFieldFax.iUid));

    QVERIFY(transformPhoneNumber->supportsField(KUidContactFieldDTMF.iUid));

    QVERIFY(!(transformPhoneNumber->supportsField(0))); //some wrong value

    QVERIFY(transformPhoneNumber->supportsDetail(QContactPhoneNumber::DefinitionName));

    QVERIFY(!(transformPhoneNumber->supportsDetail("WrongValue")));

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::FieldNumber,0);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeLandline,KUidContactFieldPhoneNumber.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeMobile,KUidContactFieldPhoneNumber.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeFax,KUidContactFieldFax.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypePager,KUidContactFieldPhoneNumber.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeVoice,0);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeModem,KUidContactFieldPhoneNumber.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeVideo,KUidContactFieldPhoneNumber.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeCar,KUidContactFieldPhoneNumber.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeBulletinBoardSystem,KUidContactFieldPhoneNumber.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeMessagingCapable,0);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeAssistant,KUidContactFieldPhoneNumber.iUid);

    validateGetIdForField(*transformPhoneNumber, QContactPhoneNumber::SubTypeDtmfMenu,KUidContactFieldDTMF.iUid);

    validateGetIdForField(*transformPhoneNumber, "WrongValue", 0);

    QVERIFY(transformPhoneNumber->supportsSubType(QContactPhoneNumber::FieldSubTypes));

    QVERIFY( !(transformPhoneNumber->supportsSubType("WrongValue")));

    //Test supportedSortingFieldTypes

    //supportedSortingFieldTypes - FieldPrefix

    QList<TUid> uidsToVerify;

    uidsToVerify << KUidContactFieldPhoneNumber;

    uidsToVerify << KUidContactFieldFax;

    uidsToVerify << KUidContactFieldDTMF;

    validateSupportedSortingFieldTypes(*transformPhoneNumber,QContactPhoneNumber::FieldNumber,uidsToVerify);

    uidsToVerify.clear();

    validateSupportedSortingFieldTypes(*transformPhoneNumber,"WrongValue",uidsToVerify);

    validateContextsL(transformPhoneNumber);

    QContactPhoneNumber phoneNumber1;

    phoneNumber1.setNumber(detail);

    QList<CContactItemField *> fields = transformPhoneNumber->transformDetailL(phoneNumber1);