1 //Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 //All rights reserved.

     3 //This component and the accompanying materials are made available

     4 //under the terms of "Eclipse Public License v1.0"

     5 //which accompanies this distribution, and is available

     6 //at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 

     8 //Initial Contributors:

     9 //Nokia Corporation - initial contribution.

    10 

    11 //Contributors:

    12 

    13 //Description:

    14 

    15 /////////////////////////////////////////////////////////////////////

    16 

    17 // INCLUDED FILES

    18 #include <QtTest/QtTest>

    19 #include "t_tsgraphicfilescalinghandler.h"

    20 

    21 _LIT(KFileName, "c:\\data\\Images\\Pictures\\image_file.png");

    22 _LIT8(KMimeType, "image/png");

    23 QString KFileName2("c:\\data\\Images\\Pictures\\image_file.png");

    24 

    25 const TSize KOriginalSize(480, 236);

    26 const TSize KWanted_TheSameRatio(KOriginalSize.iWidth/2, KOriginalSize.iHeight/2);

    27 const TSize KWanted_LessWidth(KOriginalSize.iWidth/2, KOriginalSize.iHeight);

    28 const TSize KWanted_LessHeight(KOriginalSize.iWidth, KOriginalSize.iHeight/2);

    29 

    30 // -----------------------------------------------------------------------------

    31 // -----------------------------------------------------------------------------

    32 //

    33 QTEST_MAIN(T_CTsGraphicFileScalingHandler)

    34 

    35 // -----------------------------------------------------------------------------

    36 // -----------------------------------------------------------------------------

    37 //

    38 T_CTsGraphicFileScalingHandler::T_CTsGraphicFileScalingHandler(QObject *parent) :

    39     QObject(parent),

    40     mErrorCallBack(KErrNone)

    41 {

    42     User::LeaveIfError(mFs.Connect());

    43     User::LeaveIfError(RFbsSession::Connect(mFs));

    44 }

    45 

    46 // -----------------------------------------------------------------------------

    47 // -----------------------------------------------------------------------------

    48 //

    49 T_CTsGraphicFileScalingHandler::~T_CTsGraphicFileScalingHandler()

    50 {

    51     mFs.Close();

    52     RFbsSession::Disconnect();

    53 }

    54 

    55 // -----------------------------------------------------------------------------

    56 // -----------------------------------------------------------------------------

    57 //

    58 void T_CTsGraphicFileScalingHandler::WaitActive(TInt aTime)

    59 {

    60     CActiveSchedulerWait *wait = new (ELeave)CActiveSchedulerWait();

    61     CPeriodic *periodic = CPeriodic::NewL(CActive::EPriorityIdle);

    62     periodic->Start(aTime, aTime, TCallBack(CallStop, wait));

    63     wait->Start();

    64     delete periodic;

    65     delete wait;

    66 }

    67 

    68 // -----------------------------------------------------------------------------

    69 // -----------------------------------------------------------------------------

    70 //

    71 TInt T_CTsGraphicFileScalingHandler::CallStop(TAny *aWait)

    72 {

    73     (static_cast<CActiveSchedulerWait*>(aWait))->AsyncStop();

    74     return 1;

    75 }

    76 

    77 // -----------------------------------------------------------------------------

    78 // -----------------------------------------------------------------------------

    79 //

    80 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingIgnoreAspectRatio_LessWidth()

    81 {

    82     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

    83 

    84     TRAPD(errNo, screenShotHadnler =

    85         CTsGraphicFileScalingHandler::NewL(*this,

    86                                     mFs,

    87                                     KFileName,

    88                                     KMimeType,

    89                                     KWanted_LessWidth

    90                                     /*CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/));

    91 

    92     QCOMPARE(errNo, KErrNone);

    93     WaitActive(5000000);

    94 

    95     QVERIFY(!mErrorCallBack);

    96     QVERIFY(!mPixMapCallBack.isNull());

    97     QCOMPARE(mPixMapCallBack.width(), KWanted_LessWidth.iWidth);

    98     QCOMPARE(mPixMapCallBack.height(), KWanted_LessWidth.iHeight);

    99     delete screenShotHadnler;

   100 }

   101 

   102 // -----------------------------------------------------------------------------

   103 // -----------------------------------------------------------------------------

   104 //

   105 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingIgnoreAspectRatio_LessHeight()

   106 {

   107     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   108 

   109     TRAPD(errNo, screenShotHadnler =

   110         CTsGraphicFileScalingHandler::NewL(*this,

   111                                     mFs,

   112                                     KFileName,

   113                                     KMimeType,

   114                                     KWanted_LessHeight

   115                                     /*CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/));

   116 

   117     QCOMPARE(errNo, KErrNone);

   118     WaitActive(5000000);

   119 

   120     QVERIFY(!mErrorCallBack);

   121     QVERIFY(!mPixMapCallBack.isNull());

   122     QCOMPARE(mPixMapCallBack.width(), KWanted_LessHeight.iWidth);

   123     QCOMPARE(mPixMapCallBack.height(), KWanted_LessHeight.iHeight);

   124     delete screenShotHadnler;

   125 }

   126 

   127 // -----------------------------------------------------------------------------

   128 // -----------------------------------------------------------------------------

   129 //

   130 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingIgnoreAspectRatio_TheSameRatio()

   131 {

   132     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   133 

   134     TRAPD(errNo, screenShotHadnler =

   135         CTsGraphicFileScalingHandler::NewL(*this,

   136                                     mFs,

   137                                     KFileName,

   138                                     KMimeType,

   139                                     KWanted_TheSameRatio

   140                                     /*CTsGraphicFileScalingHandler::EIgnoreAspectRatio*/));

   141 

   142     QCOMPARE(errNo, KErrNone);

   143     WaitActive(5000000);

   144 

   145     QVERIFY(!mErrorCallBack);

   146     QVERIFY(!mPixMapCallBack.isNull());

   147     QCOMPARE(mPixMapCallBack.width(), KWanted_TheSameRatio.iWidth);

   148     QCOMPARE(mPixMapCallBack.height(), KWanted_TheSameRatio.iHeight);

   149     delete screenShotHadnler;

   150 }

   151 

   152 // -----------------------------------------------------------------------------

   153 // -----------------------------------------------------------------------------

   154 //

   155 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatio_LessWidth()

   156 {

   157     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   158 

   159     TRAPD(errNo, screenShotHadnler =

   160         CTsGraphicFileScalingHandler::NewL(*this,

   161                                     mFs,

   162                                     KFileName,

   163                                     KMimeType,

   164                                     KWanted_LessWidth,

   165                                     CTsGraphicFileScalingHandler::EKeepAspectRatio));

   166 

   167     QCOMPARE(errNo, KErrNone);

   168     WaitActive(5000000);

   169 

   170     QVERIFY(!mErrorCallBack);

   171     QVERIFY(!mPixMapCallBack.isNull());

   172     QVERIFY(mPixMapCallBack.width() <= KWanted_LessWidth.iWidth);

   173     QVERIFY(mPixMapCallBack.height() <= KWanted_LessWidth.iHeight);

   174     delete screenShotHadnler;

   175 }

   176 

   177 // -----------------------------------------------------------------------------

   178 // -----------------------------------------------------------------------------

   179 //

   180 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatio_LessHeight()

   181 {

   182     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   183 

   184     TRAPD(errNo, screenShotHadnler =

   185         CTsGraphicFileScalingHandler::NewL(*this,

   186                                     mFs,

   187                                     KFileName,

   188                                     KMimeType,

   189                                     KWanted_LessHeight,

   190                                     CTsGraphicFileScalingHandler::EKeepAspectRatio));

   191 

   192     QCOMPARE(errNo, KErrNone);

   193     WaitActive(5000000);

   194 

   195     QVERIFY(!mErrorCallBack);

   196     QVERIFY(!mPixMapCallBack.isNull());

   197     QVERIFY(mPixMapCallBack.width() <= KWanted_LessHeight.iWidth);

   198     QVERIFY(mPixMapCallBack.height() <= KWanted_LessHeight.iHeight);

   199     delete screenShotHadnler;

   200 }

   201 

   202 // -----------------------------------------------------------------------------

   203 // -----------------------------------------------------------------------------

   204 //

   205 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatio_TheSameRatio()

   206 {

   207     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   208 

   209     TRAPD(errNo, screenShotHadnler =

   210         CTsGraphicFileScalingHandler::NewL(*this,

   211                                     mFs,

   212                                     KFileName,

   213                                     KMimeType,

   214                                     KWanted_TheSameRatio,

   215                                     CTsGraphicFileScalingHandler::EKeepAspectRatio));

   216 

   217     QCOMPARE(errNo, KErrNone);

   218     WaitActive(5000000);

   219 

   220     QVERIFY(!mErrorCallBack);

   221     QVERIFY(!mPixMapCallBack.isNull());

   222     QVERIFY(mPixMapCallBack.width() <= KWanted_TheSameRatio.iWidth);

   223     QVERIFY(mPixMapCallBack.height() <= KWanted_TheSameRatio.iHeight);

   224     delete screenShotHadnler;

   225 }

   226 

   227 // -----------------------------------------------------------------------------

   228 // -----------------------------------------------------------------------------

   229 //

   230 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatioByExpanding_LessWidth()

   231 {

   232     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   233 

   234     TRAPD(errNo, screenShotHadnler =

   235         CTsGraphicFileScalingHandler::NewL(*this,

   236                                     mFs,

   237                                     KFileName,

   238                                     KMimeType,

   239                                     KWanted_LessWidth,

   240                                     CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding));

   241 

   242     QCOMPARE(errNo, KErrNone);

   243     WaitActive(5000000);

   244 

   245     QVERIFY(!mErrorCallBack);

   246     QVERIFY(!mPixMapCallBack.isNull());

   247     QCOMPARE(mPixMapCallBack.width(), KWanted_LessWidth.iWidth);

   248     QCOMPARE(mPixMapCallBack.height(), KWanted_LessWidth.iHeight);

   249     delete screenShotHadnler;

   250 }

   251 

   252 // -----------------------------------------------------------------------------

   253 // -----------------------------------------------------------------------------

   254 //

   255 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatioByExpanding_LessHeight()

   256 {

   257     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   258 

   259     TRAPD(errNo, screenShotHadnler =

   260         CTsGraphicFileScalingHandler::NewL(*this,

   261                                     mFs,

   262                                     KFileName,

   263                                     KMimeType,

   264                                     KWanted_LessHeight,

   265                                     CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding));

   266 

   267     QCOMPARE(errNo, KErrNone);

   268     WaitActive(5000000);

   269 

   270     QVERIFY(!mErrorCallBack);

   271     QVERIFY(!mPixMapCallBack.isNull());

   272     QCOMPARE(mPixMapCallBack.width(), KWanted_LessHeight.iWidth);

   273     QCOMPARE(mPixMapCallBack.height(), KWanted_LessHeight.iHeight);

   274     delete screenShotHadnler;

   275 }

   276 

   277 // -----------------------------------------------------------------------------

   278 // -----------------------------------------------------------------------------

   279 //

   280 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingKeepAspectRatioByExpanding_TheSameRatio()

   281 {

   282     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   283 

   284     TRAPD(errNo, screenShotHadnler =

   285         CTsGraphicFileScalingHandler::NewL(*this,

   286                                     mFs,

   287                                     KFileName,

   288                                     KMimeType,

   289                                     KWanted_TheSameRatio,

   290                                     CTsGraphicFileScalingHandler::EKeepAspectRatioByExpanding));

   291 

   292     QCOMPARE(errNo, KErrNone);

   293     WaitActive(5000000);

   294 

   295     QVERIFY(!mErrorCallBack);

   296     QVERIFY(!mPixMapCallBack.isNull());

   297     QCOMPARE(mPixMapCallBack.width(), KWanted_TheSameRatio.iWidth);

   298     QCOMPARE(mPixMapCallBack.height(), KWanted_TheSameRatio.iHeight);

   299     delete screenShotHadnler;

   300 }

   301 

   302 // ---------------------------------------------------------------------------

   303 // ---------------------------------------------------------------------------

   304 //

   305 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingInvalidImagePath()

   306 {

   307     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   308     TSize newSize(240, 118);

   309     _LIT(wrongImagePath, "c:\\data\\Images\\Pictures\\<image_file.png");

   310 

   311     TRAPD(errNo, screenShotHadnler =

   312             CTsGraphicFileScalingHandler::NewL(*this,

   313                                         mFs,

   314                                         wrongImagePath,

   315                                         KMimeType,

   316                                         newSize);

   317     );

   318 

   319     QCOMPARE(errNo, KErrPathNotFound);

   320     WaitActive(5000000);

   321     delete screenShotHadnler;

   322 }

   323 

   324 // ---------------------------------------------------------------------------

   325 // ---------------------------------------------------------------------------

   326 //

   327 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingEmptyImagePath()

   328 {

   329     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   330     TSize newSize(240, 118);

   331     _LIT(wrongImagePath, "");

   332 

   333     TRAPD(errNo, screenShotHadnler =

   334             CTsGraphicFileScalingHandler::NewL(*this,

   335                                         mFs,

   336                                         wrongImagePath,

   337                                         KMimeType,

   338                                         newSize);

   339     );

   340 

   341     QCOMPARE(errNo, KErrPathNotFound);

   342     WaitActive(5000000);

   343     delete screenShotHadnler;

   344 }

   345 

   346 // ---------------------------------------------------------------------------

   347 // ---------------------------------------------------------------------------

   348 //

   349 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingEmptyMimeType()

   350 {

   351     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   352     TSize newSize(240, 118);

   353     _LIT8(wrongMimeType, "");

   354 

   355     TRAPD(errNo,

   356         screenShotHadnler = CTsGraphicFileScalingHandler::NewL(*this,

   357                                         mFs,

   358                                         KFileName,

   359                                         wrongMimeType,

   360                                         newSize);

   361     );

   362 

   363     QCOMPARE(errNo, KErrBadName);

   364     WaitActive(5000000);

   365     delete screenShotHadnler;

   366 }

   367 

   368 // ---------------------------------------------------------------------------

   369 // ---------------------------------------------------------------------------

   370 //

   371 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingScalingToIncorrectWidthSize()

   372 {

   373     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   374     TSize newSize(-20, 118);

   375 

   376     TRAPD(errNo, screenShotHadnler =

   377             CTsGraphicFileScalingHandler::NewL(*this,

   378                                         mFs,

   379                                         KFileName,

   380                                         KMimeType,

   381                                         newSize);

   382     );

   383 

   384     QCOMPARE(errNo, KErrCorrupt);

   385     WaitActive(5000000);

   386     delete screenShotHadnler;

   387 }

   388 

   389 // ---------------------------------------------------------------------------

   390 // ---------------------------------------------------------------------------

   391 //

   392 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingScalingToIncorrectHeightSize()

   393 {

   394     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   395     TSize newSize(240, -20);

   396 

   397     TRAPD(errNo, screenShotHadnler =

   398             CTsGraphicFileScalingHandler::NewL(*this,

   399                                         mFs,

   400                                         KFileName,

   401                                         KMimeType,

   402                                         newSize);

   403     );

   404 

   405     QCOMPARE(errNo, KErrCorrupt);

   406     WaitActive(5000000);

   407     delete screenShotHadnler;

   408 }

   409 

   410 // ---------------------------------------------------------------------------

   411 // ---------------------------------------------------------------------------

   412 //

   413 void T_CTsGraphicFileScalingHandler::testGraphicFileScalingScalingToZeroSize()

   414 {

   415     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   416     TSize newSize(0, 0);

   417 

   418     TRAPD(errNo, screenShotHadnler =

   419             CTsGraphicFileScalingHandler::NewL(*this,

   420                                         mFs,

   421                                         KFileName,

   422                                         KMimeType,

   423                                         newSize);

   424     );

   425 

   426     QCOMPARE(errNo, KErrCorrupt);

   427     WaitActive(5000000);

   428     delete screenShotHadnler;

   429 }

   430 

   431 // ---------------------------------------------------------------------------

   432 // ---------------------------------------------------------------------------

   433 //

   434 void T_CTsGraphicFileScalingHandler::testDoCancel()

   435 {

   436     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   437 

   438     TRAPD(errNo, screenShotHadnler =

   439         CTsGraphicFileScalingHandler::NewL(*this,

   440                                     mFs,

   441                                     KFileName,

   442                                     KMimeType,

   443                                     KWanted_LessWidth));

   444 

   445     QCOMPARE(errNo, KErrNone);

   446 

   447     screenShotHadnler->Cancel();

   448 

   449     WaitActive(5000000);

   450     QCOMPARE(mErrorCallBack, KErrCancel);

   451     QVERIFY(mPixMapCallBack.isNull());

   452     delete screenShotHadnler;

   453 }

   454 

   455 // ---------------------------------------------------------------------------

   456 // ---------------------------------------------------------------------------

   457 //

   458 void T_CTsGraphicFileScalingHandler::testCFbsBitmapScalingToCorrectSize()

   459 {

   460     QPixmap imputPixMap(KFileName2);

   461 

   462     CFbsBitmap *cFbsBitmap = new(ELeave)CFbsBitmap();

   463     QVERIFY(cFbsBitmap = imputPixMap.toSymbianCFbsBitmap());

   464 

   465     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   466 

   467     TRAPD(errNoo, screenShotHadnler =

   468         CTsGraphicFileScalingHandler::NewL(*this,

   469                                     *cFbsBitmap,

   470                                     KWanted_LessHeight));

   471 

   472     QCOMPARE(errNoo, KErrNone);

   473     WaitActive(5000000);

   474 

   475     QVERIFY(!mErrorCallBack);

   476     QVERIFY(!mPixMapCallBack.isNull());

   477     QCOMPARE(mPixMapCallBack.width(), KWanted_LessHeight.iWidth);

   478     QCOMPARE(mPixMapCallBack.height(), KWanted_LessHeight.iHeight);

   479 

   480     delete screenShotHadnler;

   481     delete cFbsBitmap;

   482 }

   483 

   484 // ---------------------------------------------------------------------------

   485 // ---------------------------------------------------------------------------

   486 //

   487 void T_CTsGraphicFileScalingHandler::testCFbsBitmapScalinToIncorrectWidthSize()

   488 {

   489     QPixmap imputPixMap(KFileName2);

   490 

   491     CFbsBitmap *cFbsBitmap = new(ELeave)CFbsBitmap();

   492     QVERIFY(cFbsBitmap = imputPixMap.toSymbianCFbsBitmap());

   493 

   494     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   495     TSize newSize(-20, 118);

   496 

   497     TRAPD(errNoo, screenShotHadnler =

   498         CTsGraphicFileScalingHandler::NewL(*this,

   499                                     *cFbsBitmap,

   500                                     newSize));

   501 

   502     QCOMPARE(errNoo, KErrCorrupt);

   503     WaitActive(5000000);

   504 

   505     delete screenShotHadnler;

   506     delete cFbsBitmap;

   507 }

   508 

   509 // ---------------------------------------------------------------------------

   510 // ---------------------------------------------------------------------------

   511 //

   512 void T_CTsGraphicFileScalingHandler::testCFbsBitmapScalinToIncorrectHeightSize()

   513 {

   514     QPixmap imputPixMap(KFileName2);

   515 

   516     CFbsBitmap *cFbsBitmap = new(ELeave)CFbsBitmap();

   517     QVERIFY(cFbsBitmap = imputPixMap.toSymbianCFbsBitmap());

   518 

   519     CTsGraphicFileScalingHandler *screenShotHadnler = 0;

   520     TSize newSize(240, -20);

   521 

   522     TRAPD(errNoo, screenShotHadnler =

   523         CTsGraphicFileScalingHandler::NewL(*this,

   524                                     *cFbsBitmap,

   525                                     newSize));

   526 

   527     QCOMPARE(errNoo, KErrCorrupt);

   528     WaitActive(5000000);

   529 

   530     delete screenShotHadnler;

   531     delete cFbsBitmap;

   532 }

   533 

   534 // -----------------------------------------------------------------------------

   535 // -----------------------------------------------------------------------------

   536 //

   537 void T_CTsGraphicFileScalingHandler::ImageReadyCallBack(TInt error,

   538                                                    const CFbsBitmap *bitmap)

   539 {

   540     CFbsBitmap *retBitmap = const_cast<CFbsBitmap *>(bitmap);

   541 

   542     mErrorCallBack = error;

   543     mPixMapCallBack = QPixmap();

   544 

   545     if (retBitmap && !error) {

   546         mPixMapCallBack = QPixmap::fromSymbianCFbsBitmap(retBitmap);

   547     }

   548 }

   549 

   550 //  End of KFileName