automated-tests/dali-test-suite-utils/test-platform-abstraction.h

   1 #ifndef __DALI_TEST_PLATFORM_ABSTRACTION_H__
   2 #define __DALI_TEST_PLATFORM_ABSTRACTION_H__
   3
   4 //
   5 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6 //
   7 // Licensed under the Flora License, Version 1.0 (the License);
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //     http://floralicense.org/license/
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an AS IS BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19
  20 // EXTERNAL INCLUDES
  21 #include <set>
  22 #include <stdint.h>
  23 #include <cstring>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/integration-api/platform-abstraction.h>
  27
  28 #include <dali/integration-api/glyph-set.h>
  29 #include <test-trace-call-stack.h>
  30
  31 namespace Dali
  32 {
  33
  34 /**
  35  * Concrete implementation of the platform abstraction class.
  36  */
  37 class DALI_IMPORT_API TestPlatformAbstraction : public Dali::Integration::PlatformAbstraction
  38 {
  39
  40 public:
  41
  42   struct Resources
  43   {
  44     bool                         loaded;
  45     Integration::ResourceId      loadedId;
  46     Integration::ResourceTypeId  loadedType;
  47     Integration::ResourcePointer loadedResource;
  48
  49     bool                         loadFailed;
  50     Integration::ResourceId      loadFailedId;
  51     Integration::ResourceFailure loadFailure;
  52
  53     bool                         saved;
  54     Integration::ResourceId      savedId;
  55     Integration::ResourceTypeId  savedType;
  56
  57     bool                         saveFailed;
  58     Integration::ResourceId      saveFailedId;
  59     Integration::ResourceFailure saveFailure;
  60   };
  61
  62   struct LoadFileResult
  63   {
  64     LoadFileResult()
  65     : loadResult(false)
  66     {
  67
  68     }
  69
  70     bool loadResult;
  71     std::vector< unsigned char> buffer;
  72   };
  73
  74
  75   /**
  76    * Constructor
  77    */
  78   TestPlatformAbstraction() : mRequest(0)
  79   {
  80     Initialize();
  81   }
  82
  83   /**
  84    * Destructor
  85    */
  86   virtual ~TestPlatformAbstraction()
  87   {
  88   }
  89
  90   /**
  91    * @copydoc PlatformAbstraction::GetTimeMicroseconds()
  92    */
  93   virtual void GetTimeMicroseconds(unsigned int &seconds, unsigned int &microSeconds)
  94   {
  95     seconds = mSeconds;
  96     microSeconds = mMicroSeconds;
  97     mTrace.PushCall("GetTimeMicroseconds", "");
  98   }
  99
 100   /**
 101    * @copydoc PlatformAbstraction::Suspend()
 102    */
 103   virtual void Suspend()
 104   {
 105     mTrace.PushCall("Suspend", "");
 106   }
 107
 108   /**
 109    * @copydoc PlatformAbstraction::Resume()
 110    */
 111   virtual void Resume()
 112   {
 113     mTrace.PushCall("Resume", "");
 114   }
 115
 116   virtual void GetClosestImageSize( const std::string& filename,
 117                                     const ImageAttributes& attributes,
 118                                     Vector2& closestSize)
 119   {
 120     closestSize = mClosestSize;
 121     mTrace.PushCall("GetClosestImageSize", "");
 122   }
 123
 124   virtual void GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
 125                                     const ImageAttributes& attributes,
 126                                     Vector2& closestSize)
 127   {
 128     closestSize = mClosestSize;
 129     mTrace.PushCall("GetClosestImageSize", "");
 130   }
 131
 132
 133   /**
 134    * @copydoc PlatformAbstraction::LoadResource()
 135    */
 136   virtual void LoadResource(const Integration::ResourceRequest& request)
 137   {
 138     mTrace.PushCall("LoadResource", "");
 139     if(mRequest != NULL)
 140     {
 141       delete mRequest;
 142       tet_infoline ("Warning: multiple resource requests not handled by Test Suite. You may see unexpected errors");
 143     }
 144     mRequest = new Integration::ResourceRequest(request);
 145   }
 146
 147   /**
 148    * @copydoc PlatformAbstraction::SaveResource()
 149    */
 150   virtual void SaveResource(const Integration::ResourceRequest& request)
 151   {
 152     mTrace.PushCall("SaveResource", "");
 153     if(mRequest != NULL)
 154     {
 155       delete mRequest;
 156       tet_infoline ("Warning: multiple resource requests not handled by Test Suite. You may see unexpected errors");
 157     }
 158     mRequest = new Integration::ResourceRequest(request);
 159   }
 160
 161   /**
 162    * @copydoc PlatformAbstraction::CancelLoad()
 163    */
 164   virtual void CancelLoad(Integration::ResourceId id, Integration::ResourceTypeId typeId)
 165   {
 166     mTrace.PushCall("CancelLoad", "");
 167   }
 168
 169   /**
 170    * @copydoc PlatformAbstraction::GetResources()
 171    */
 172   virtual void GetResources(Integration::ResourceCache& cache)
 173   {
 174     mTrace.PushCall("GetResources", "");
 175
 176     if(mResources.loaded)
 177     {
 178       cache.LoadResponse( mResources.loadedId, mResources.loadedType, mResources.loadedResource, Integration::RESOURCE_COMPLETELY_LOADED );
 179     }
 180     if(mResources.loadFailed)
 181     {
 182       cache.LoadFailed( mResources.loadFailedId, mResources.loadFailure );
 183     }
 184     if(mResources.saved)
 185     {
 186       cache.SaveComplete( mResources.savedId, mResources.savedType );
 187     }
 188     if(mResources.saveFailed)
 189     {
 190       cache.SaveFailed( mResources.saveFailedId, mResources.saveFailure );
 191     }
 192   }
 193
 194   /**
 195    * @copydoc PlatformAbstraction::IsLoading()
 196    */
 197   virtual bool IsLoading()
 198   {
 199     mTrace.PushCall("IsLoading", "");
 200     return mIsLoadingResult;
 201   }
 202
 203   /**
 204    * @copydoc PlatformAbstraction::GetDefaultFontFamily()
 205    */
 206   virtual std::string GetDefaultFontFamily() const
 207   {
 208     mTrace.PushCall("GetDefaultFontFamily", "");
 209     return mGetDefaultFontFamilyResult;
 210   }
 211
 212   /**
 213    * @copydoc PlatformAbstraction::GetDefaultFontSize()
 214    */
 215   virtual const float GetDefaultFontSize() const
 216   {
 217     mTrace.PushCall("GetDefaultFontSize", "");
 218     return mGetDefaultFontSizeResult;
 219   }
 220
 221   virtual const PixelSize GetFontLineHeightFromCapsHeight(const std::string fontFamily, const std::string& fontStyle, const CapsHeight& capsHeight) const
 222   {
 223     mTrace.PushCall("GetFontLineHeightFromCapsHeight", "");
 224     // LineHeight will be bigger than CapsHeight, so return capsHeight + 1
 225     return PixelSize(capsHeight + 1);
 226   }
 227
 228   /**
 229    * @copydoc PlatformAbstraction::GetGlyphData()
 230    */
 231
 232   virtual Integration::GlyphSet* GetGlyphData ( const Integration::TextResourceType& textRequest,
 233                                                 const std::string& fontFamily,
 234                                                 bool getBitmap) const
 235   {
 236     if( getBitmap )
 237     {
 238       mTrace.PushCall("GetGlyphData", "getBitmap:true");
 239     }
 240     else
 241     {
 242       mTrace.PushCall("GetGlyphData", "getBitmap:false");
 243     }
 244
 245     // It creates fake metrics for the received characters.
 246
 247     Integration::GlyphSet* set = new Dali::Integration::GlyphSet();
 248     Integration::BitmapPtr bitmapData;
 249
 250     std::set<uint32_t> characters;
 251
 252     for( Integration::TextResourceType::CharacterList::const_iterator it = textRequest.mCharacterList.begin(), endIt = textRequest.mCharacterList.end(); it != endIt; ++it )
 253     {
 254       if( characters.find( it->character ) == characters.end() )
 255       {
 256         characters.insert( it->character );
 257         Integration::GlyphMetrics character = {it->character, Integration::GlyphMetrics::LOW_QUALITY,  10.0f,  10.0f, 9.0f, 1.0f, 10.0f, it->xPosition, it->yPosition };
 258
 259         if( getBitmap )
 260         {
 261           bitmapData = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, true);
 262           bitmapData->GetPackedPixelsProfile()->ReserveBuffer(Pixel::A8, 64, 64);
 263           Integration::PixelBuffer* pixelBuffer = bitmapData->GetBuffer();
 264           memset( pixelBuffer, it->character, 64*64 );
 265         }
 266
 267         set->AddCharacter(bitmapData, character);
 268       }
 269     }
 270
 271     set->mLineHeight = 10.0f;
 272     set->mAscender = 9.0f;
 273     set->mUnitsPerEM = 2048.0f/64.0f;
 274     set->SetAtlasResourceId( textRequest.mTextureAtlasId );
 275     set->mFontHash = textRequest.mFontHash;
 276
 277     return set;
 278   }
 279
 280   /**
 281    * @copydoc PlatformAbstraction::GetCachedGlyphData()
 282    */
 283
 284   virtual Integration::GlyphSet* GetCachedGlyphData( const Integration::TextResourceType& textRequest,
 285                                                      const std::string& fontFamily ) const
 286   {
 287     mTrace.PushCall("GetCachedGlyphData", "");
 288
 289     // It creates fake metrics and bitmap for received numeric characters '0' through '9'.
 290     Integration::GlyphSet* set = new Dali::Integration::GlyphSet();
 291     Integration::BitmapPtr bitmapData;
 292
 293     std::set<uint32_t> characters;
 294
 295     for( Integration::TextResourceType::CharacterList::const_iterator it = textRequest.mCharacterList.begin(), endIt = textRequest.mCharacterList.end(); it != endIt; ++it )
 296     {
 297       if( it->character >= '0' && it->character <= '9' && characters.find( it->character ) == characters.end() )
 298       {
 299         characters.insert( it->character );
 300         Integration::GlyphMetrics character = {it->character, Integration::GlyphMetrics::HIGH_QUALITY,  10.0f,  10.0f, 9.0f, 1.0f, 10.0f, it->xPosition, it->yPosition };
 301
 302         bitmapData = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, true);
 303         bitmapData->GetPackedPixelsProfile()->ReserveBuffer(Pixel::A8, 64, 64);
 304         Integration::PixelBuffer* pixelBuffer = bitmapData->GetBuffer();
 305         memset( pixelBuffer, it->character, 64*64 );
 306         set->AddCharacter(bitmapData, character);
 307       }
 308     }
 309
 310     set->mLineHeight = 10.0f;
 311     set->mAscender = 9.0f;
 312     set->mUnitsPerEM = 2048.0f/64.0f;
 313     set->SetAtlasResourceId( textRequest.mTextureAtlasId );
 314     set->mFontHash = textRequest.mFontHash;
 315
 316     return set;
 317   }
 318
 319
 320   /**
 321    * @copydoc PlatformAbstraction::GetGlobalMetrics()
 322    */
 323   virtual void GetGlobalMetrics( const std::string& fontFamily,
 324                                  const std::string& fontStyle,
 325                                  Integration::GlobalMetrics& globalMetrics ) const
 326   {
 327     globalMetrics.lineHeight = 10.0f;
 328     globalMetrics.ascender = 9.0f;
 329     globalMetrics.unitsPerEM = 2048.0f/64.0f;
 330     globalMetrics.underlineThickness = 2.f;
 331     globalMetrics.underlinePosition = 1.f;
 332   }
 333
 334   /**
 335    * @copydoc PlatformAbstraction::GetFontPath()
 336    */
 337   virtual std::string GetFontPath(const std::string& family, bool bold, bool italic) const
 338   {
 339     mTrace.PushCall("GetFontPath", "");
 340     return mGetFontPathResult;
 341
 342     // Do nothing with arguments
 343   }
 344
 345   /**
 346    * @copydoc PlatformAbstraction::SetDpi()
 347    */
 348   virtual void SetDpi (unsigned int dpiHorizontal, unsigned int dpiVertical)
 349   {
 350     mTrace.PushCall("SetDpi", "");
 351   }
 352
 353   /**
 354    * @copydoc PlatformAbstraction::GetFontFamilyForChars()
 355    */
 356   virtual std::string GetFontFamilyForChars(const TextArray& charsRequested) const
 357   {
 358     mTrace.PushCall("GetFontFamilyForChars", "");
 359     return mGetDefaultFontFamilyResult;
 360   }
 361
 362   /**
 363    * @copydoc PlatformAbstraction::AllGlyphsSupported()
 364    */
 365   virtual bool AllGlyphsSupported(const std::string& name, const std::string& fontStyle, const TextArray& text) const
 366   {
 367     mTrace.PushCall("AllGlyphsSupported", "");
 368     return true;
 369   }
 370
 371   /**
 372    * @copydoc PlatformAbstraction::ValidateFontFamilyName()
 373    */
 374   virtual bool ValidateFontFamilyName(const std::string& fontFamily, const std::string& fontStyle, bool& isDefaultSystemFont, std::string& closestMatch, std::string& closestStyleMatch) const
 375   {
 376     mTrace.PushCall("ValidateFontFamilyName", "");
 377     return true;
 378   }
 379
 380   /**
 381    * @copydoc PlatformAbstraction::GetFontList()
 382    */
 383   virtual std::vector<std::string> GetFontList( FontListMode mode ) const
 384   {
 385     mFontListMode = mode;
 386     mTrace.PushCall("ValidateGetFontList", "");
 387     std::vector<std::string> fontList;
 388     return fontList;
 389   }
 390
 391   /**
 392    * @copydoc PlatformAbstraction::LoadFile()
 393    */
 394   virtual bool LoadFile( const std::string& filename, std::vector< unsigned char >& buffer ) const
 395   {
 396     mTrace.PushCall("LoadFile", "");
 397     if( mLoadFileResult.loadResult )
 398     {
 399       buffer = mLoadFileResult.buffer;
 400     }
 401
 402     return mLoadFileResult.loadResult;
 403   }
 404
 405   /**
 406    * @copydoc PlatformAbstraction::SaveFile()
 407    */
 408   virtual bool SaveFile(const std::string& filename, std::vector< unsigned char >& buffer) const
 409   {
 410     mTrace.PushCall("SaveFile", "");
 411     return false;
 412   }
 413
 414   virtual void JoinLoaderThreads()
 415   {
 416     mTrace.PushCall("JoinLoaderThreads", "");
 417   }
 418
 419   virtual void UpdateDefaultsFromDevice()
 420   {
 421     mTrace.PushCall("UpdateDefaultsFromDevice", "");
 422     mGetDefaultFontFamilyResult+=1.0f;
 423   }
 424
 425   virtual Integration::DynamicsFactory* GetDynamicsFactory()
 426   {
 427     mTrace.PushCall("GetDynamicsFactory", "");
 428     return NULL;
 429   }
 430
 431   virtual bool ReadGlobalMetricsFromCache( const std::string& fontFamily,
 432                                            const std::string& fontStyle,
 433                                            Integration::GlobalMetrics& globalMetrics )
 434   {
 435     mTrace.PushCall("ReadGlobalMetricsFromCacheFile", "");
 436     globalMetrics = mReadGlobalMetrics; // Want to copy contents...
 437     return mReadGlobalMetricsResult; // Default false (will be set to true on subsequent write)
 438   }
 439
 440   virtual void WriteGlobalMetricsToCache( const std::string& fontFamily,
 441                                           const std::string& fontStyle,
 442                                           const Integration::GlobalMetrics& globalMetrics )
 443   {
 444     // Copy so next read uses written values. TODO: Could add method
 445     // to turn this behaviour off for more extensive testing.
 446     mReadGlobalMetrics = globalMetrics;
 447     mReadGlobalMetricsResult = true;
 448
 449     mTrace.PushCall("WriteGlobalMetricsToCacheFile", "");
 450   }
 451
 452   virtual bool ReadMetricsFromCache( const std::string& fontFamily,
 453                                      const std::string& fontStyle,
 454                                      std::vector<Integration::GlyphMetrics>& glyphMetricsContainer )
 455   {
 456     mTrace.PushCall("ReadMetricsFromCacheFile", "");
 457     glyphMetricsContainer = mReadMetrics;
 458     return mReadMetricsResult; // Default false (will be set to true on subsequent write)
 459   }
 460
 461   virtual void WriteMetricsToCache( const std::string& fontFamily,
 462                                     const std::string& fontStyle,
 463                                     const Integration::GlyphSet& glyphSet )
 464   {
 465     // Copy so next read uses written values. TODO: Could add method
 466     // to turn this behaviour off for more extensive testing.
 467     const Integration::GlyphSet::CharacterList& charList =  glyphSet.GetCharacterList();
 468     mReadMetrics.clear();
 469     for(std::size_t i=0, end=charList.size(); i<end; ++i)
 470     {
 471       mReadMetrics.push_back(charList[i].second);
 472     }
 473     mReadMetricsResult = true;
 474
 475     mTrace.PushCall("WriteMetricsToCacheFile", "");
 476   }
 477
 478 public: // TEST FUNCTIONS
 479
 480   // Enumeration of Platform Abstraction methods
 481   typedef enum
 482   {
 483     GetTimeMicrosecondsFunc,
 484     SuspendFunc,
 485     ResumeFunc,
 486     LoadResourceFunc,
 487     SaveResourceFunc,
 488     SaveFileFunc,
 489     LoadFileFunc,
 490     CancelLoadFunc,
 491     GetResourcesFunc,
 492     IsLoadingFunc,
 493     GetDefaultFontFamilyFunc,
 494     GetDefaultFontSizeFunc,
 495     GetFontLineHeightFromCapsHeightFunc,
 496     GetGlyphDataFunc,
 497     GetCachedGlyphDataFunc,
 498     SetDpiFunc,
 499     GetFontPathFunc,
 500     JoinLoaderThreadsFunc,
 501     GetFontFamilyForCharsFunc,
 502     AllGlyphsSupportedFunc,
 503     ValidateFontFamilyNameFunc,
 504     UpdateDefaultsFromDeviceFunc,
 505     GetDynamicsFactoryFunc,
 506     ValidateGetFontListFunc,
 507     ReadGlobalMetricsFromCacheFileFunc,
 508     WriteGlobalMetricsToCacheFileFunc,
 509     ReadMetricsFromCacheFileFunc,
 510     WriteMetricsToCacheFileFunc,
 511   } TestFuncEnum;
 512
 513   /** Call this every test */
 514   void Initialize()
 515   {
 516     mTrace.Reset();
 517     mTrace.Enable(true);
 518     memset(&mResources, 0, sizeof(Resources));
 519     memset(&mReadGlobalMetrics, 0, sizeof(Integration::GlobalMetrics));
 520     mSeconds=0;
 521     mMicroSeconds=0;
 522     mIsLoadingResult=false;
 523     mGetDefaultFontFamilyResult = "HelveticaNeue";
 524     mGetDefaultFontSizeResult=12.0f;
 525     mGetFontPathResult="helvetica-12";
 526     mReadMetricsResult=false;
 527     mReadGlobalMetricsResult=false;
 528
 529     if(mRequest)
 530     {
 531       delete mRequest;
 532       mRequest = 0;
 533     }
 534   }
 535
 536   void EnableTrace(bool enable) { mTrace.Enable(enable); }
 537   void ResetTrace() { mTrace.Reset(); }
 538   TraceCallStack& GetTrace() { return mTrace; }
 539
 540   bool WasCalled(TestFuncEnum func)
 541   {
 542     switch(func)
 543     {
 544       case GetTimeMicrosecondsFunc:             return mTrace.FindMethod("GetTimeMicroseconds");
 545       case SuspendFunc:                         return mTrace.FindMethod("Suspend");
 546       case ResumeFunc:                          return mTrace.FindMethod("Resume");
 547       case LoadResourceFunc:                    return mTrace.FindMethod("LoadResource");
 548       case SaveResourceFunc:                    return mTrace.FindMethod("SaveResource");
 549       case LoadFileFunc:                        return mTrace.FindMethod("LoadFile");
 550       case SaveFileFunc:                        return mTrace.FindMethod("SaveFile");
 551       case CancelLoadFunc:                      return mTrace.FindMethod("CancelLoad");
 552       case GetResourcesFunc:                    return mTrace.FindMethod("GetResources");
 553       case IsLoadingFunc:                       return mTrace.FindMethod("IsLoading");
 554       case GetDefaultFontFamilyFunc:            return mTrace.FindMethod("GetDefaultFontFamily");
 555       case GetDefaultFontSizeFunc:              return mTrace.FindMethod("GetDefaultFontSize");
 556       case GetFontLineHeightFromCapsHeightFunc: return mTrace.FindMethod("GetFontLineHeightFromCapsHeight");
 557       case GetGlyphDataFunc:                    return mTrace.FindMethod("GetGlyphData");
 558       case GetCachedGlyphDataFunc:              return mTrace.FindMethod("GetCachedGlyphData");
 559       case GetFontPathFunc:                     return mTrace.FindMethod("GetFontPath");
 560       case SetDpiFunc:                          return mTrace.FindMethod("SetDpi");
 561       case JoinLoaderThreadsFunc:               return mTrace.FindMethod("JoinLoaderThreads");
 562       case GetFontFamilyForCharsFunc:           return mTrace.FindMethod("GetFontFamilyForChars");
 563       case AllGlyphsSupportedFunc:              return mTrace.FindMethod("AllGlyphsSupported");
 564       case ValidateFontFamilyNameFunc:          return mTrace.FindMethod("ValidateFontFamilyName");
 565       case UpdateDefaultsFromDeviceFunc:        return mTrace.FindMethod("UpdateDefaultsFromDevice");
 566       case GetDynamicsFactoryFunc:              return mTrace.FindMethod("GetDynamicsFactory");
 567       case ValidateGetFontListFunc:             return mTrace.FindMethod("ValidateGetFontList");
 568       case ReadGlobalMetricsFromCacheFileFunc:  return mTrace.FindMethod("ReadGlobalMetricsFromCacheFile");
 569       case WriteGlobalMetricsToCacheFileFunc:   return mTrace.FindMethod("WriteGlobalMetricsToCacheFile");
 570       case ReadMetricsFromCacheFileFunc:        return mTrace.FindMethod("ReadMetricsFromCacheFile");
 571       case WriteMetricsToCacheFileFunc:         return mTrace.FindMethod("WriteMetricsToCacheFile");
 572     }
 573     return false;
 574   }
 575
 576   void SetGetTimeMicrosecondsResult(size_t sec, size_t usec)
 577   {
 578     mSeconds = sec;
 579     mMicroSeconds = usec;
 580   }
 581
 582   void IncrementGetTimeResult(size_t milliseconds)
 583   {
 584     mMicroSeconds += milliseconds * 1000u;
 585     unsigned int additionalSeconds = mMicroSeconds / 1000000u;
 586
 587     mSeconds += additionalSeconds;
 588     mMicroSeconds -= additionalSeconds * 1000000u;
 589   }
 590
 591   void SetIsLoadingResult(bool result)
 592   {
 593     mIsLoadingResult = result;
 594   }
 595
 596   void SetGetDefaultFontFamilyResult(std::string result)
 597   {
 598     mGetDefaultFontFamilyResult = result;
 599   }
 600
 601   void SetGetDefaultFontSizeResult(float result)
 602   {
 603     mGetDefaultFontSizeResult = result;
 604   }
 605
 606   void SetGetFontPathResult(std::string& result)
 607   {
 608     mGetFontPathResult = result;
 609   }
 610
 611   void ClearReadyResources()
 612   {
 613     memset(&mResources, 0, sizeof(Resources));
 614   }
 615
 616   void SetResourceLoaded(Integration::ResourceId  loadedId,
 617                          Integration::ResourceTypeId  loadedType,
 618                          Integration::ResourcePointer loadedResource)
 619   {
 620     mResources.loaded = true;
 621     mResources.loadedId = loadedId;
 622     mResources.loadedType = loadedType;
 623     mResources.loadedResource = loadedResource;
 624   }
 625
 626   void SetResourceLoadFailed(Integration::ResourceId  id,
 627                              Integration::ResourceFailure failure)
 628   {
 629     mResources.loadFailed = true;
 630     mResources.loadFailedId = id;
 631     mResources.loadFailure = failure;
 632   }
 633
 634   void SetResourceSaved(Integration::ResourceId      savedId,
 635                         Integration::ResourceTypeId  savedType)
 636   {
 637     mResources.saved = true;
 638     mResources.savedId = savedId;
 639     mResources.savedType = savedType;
 640   }
 641
 642   void SetResourceSaveFailed(Integration::ResourceId  id,
 643                              Integration::ResourceFailure failure)
 644   {
 645     mResources.saveFailed = true;
 646     mResources.saveFailedId = id;
 647     mResources.saveFailure = failure;
 648   }
 649
 650   Integration::ResourceRequest* GetRequest()
 651   {
 652     return mRequest;
 653   }
 654
 655   void DiscardRequest()
 656   {
 657     delete mRequest;
 658     mRequest = NULL;
 659   }
 660
 661   void SetClosestImageSize(const Vector2& size)
 662   {
 663     mClosestSize = size;
 664   }
 665
 666   void SetLoadFileResult( bool result, std::vector< unsigned char >& buffer )
 667   {
 668     mLoadFileResult.loadResult = result;
 669     if( result )
 670     {
 671       mLoadFileResult.buffer = buffer;
 672     }
 673   }
 674
 675   void SetSaveFileResult( bool result )
 676   {
 677     mSaveFileResult = result;
 678   }
 679
 680   FontListMode GetLastFontListMode( )
 681   {
 682     return mFontListMode;
 683   }
 684
 685   void SetReadGlobalMetricsResult( bool success, Integration::GlobalMetrics& globalMetrics )
 686   {
 687     mReadGlobalMetricsResult = success;
 688     mReadGlobalMetrics = globalMetrics;
 689   }
 690
 691   void SetReadMetricsResult( bool success, std::vector<Integration::GlyphMetrics>& glyphMetricsContainer )
 692   {
 693     mReadMetricsResult = success;
 694     mReadMetrics = glyphMetricsContainer; // copy
 695   }
 696
 697 private:
 698   mutable TraceCallStack        mTrace;
 699   size_t                        mSeconds;
 700   size_t                        mMicroSeconds;
 701   bool                          mIsLoadingResult;
 702   std::string                   mGetDefaultFontFamilyResult;
 703   float                         mGetDefaultFontSizeResult;
 704   std::string                   mGetFontPathResult;
 705   Resources                     mResources;
 706   Integration::ResourceRequest* mRequest;
 707   Vector2                       mSize;
 708   Vector2                       mClosestSize;
 709   bool                          mReadGlobalMetricsResult;
 710   bool                          mReadMetricsResult;
 711   Integration::GlobalMetrics mReadGlobalMetrics;
 712   std::vector<Integration::GlyphMetrics> mReadMetrics;
 713
 714   LoadFileResult                mLoadFileResult;
 715   bool                          mSaveFileResult;
 716   mutable FontListMode          mFontListMode;
 717 };
 718
 719 } // Dali
 720
 721 #endif /* __DALI_TET_PLATFORM_ABSTRACTION_H__ */