gfx/thebes/test/gfxFontSelectionTest.cpp

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Mozilla Corporation code.
  16  *
  17  * The Initial Developer of the Original Code is Mozilla Corporation.
  18  * Portions created by the Initial Developer are Copyright (C) 2007
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *   Vladimir Vukicevic <vladimir@pobox.com>
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include "nsCOMPtr.h"
  39 #include "nsTArray.h"
  40 #include "nsString.h"
  41 #include "nsDependentString.h"
  42
  43 #include "nsServiceManagerUtils.h"
  44 #include "nsIPrefService.h"
  45 #include "nsIPrefBranch.h"
  46
  47 #include "gfxContext.h"
  48 #include "gfxFont.h"
  49 #include "gfxPlatform.h"
  50 #include "gfxTextRunWordCache.h"
  51
  52 #include "gfxFontTest.h"
  53
  54 #if defined(XP_MACOSX)
  55 #include "gfxTestCocoaHelper.h"
  56 #endif
  57
  58 #ifdef MOZ_WIDGET_GTK2
  59 #include "gtk/gtk.h"
  60 #endif
  61
  62 enum {
  63     S_UTF8 = 0,
  64     S_ASCII = 1
  65 };
  66
  67 class FrameTextRunCache;
  68
  69 static gfxTextRunWordCache *gTextRunCache;
  70
  71 struct LiteralArray {
  72     LiteralArray (unsigned long l1) {
  73         data.AppendElement(l1);
  74     }
  75     LiteralArray (unsigned long l1, unsigned long l2) {
  76         data.AppendElement(l1);
  77         data.AppendElement(l2);
  78     }
  79     LiteralArray (unsigned long l1, unsigned long l2, unsigned long l3) {
  80         data.AppendElement(l1);
  81         data.AppendElement(l2);
  82         data.AppendElement(l3);
  83     }
  84     LiteralArray (unsigned long l1, unsigned long l2, unsigned long l3, unsigned long l4) {
  85         data.AppendElement(l1);
  86         data.AppendElement(l2);
  87         data.AppendElement(l3);
  88         data.AppendElement(l4);
  89     }
  90     LiteralArray (unsigned long l1, unsigned long l2, unsigned long l3, unsigned long l4, unsigned long l5) {
  91         data.AppendElement(l1);
  92         data.AppendElement(l2);
  93         data.AppendElement(l3);
  94         data.AppendElement(l4);
  95         data.AppendElement(l5);
  96     }
  97
  98     LiteralArray (const LiteralArray& other) {
  99         data = other.data;
 100     }
 101
 102     nsTArray<unsigned long> data;
 103 };
 104
 105 #define GLYPHS LiteralArray
 106
 107 struct TestEntry {
 108     TestEntry (char *aUTF8FamilyString,
 109                const gfxFontStyle& aFontStyle,
 110                char *aString)
 111         : utf8FamilyString(aUTF8FamilyString),
 112           fontStyle(aFontStyle),
 113           stringType(S_ASCII),
 114           string(aString),
 115           isRTL(PR_FALSE)
 116     {
 117     }
 118
 119     TestEntry (char *aUTF8FamilyString,
 120                const gfxFontStyle& aFontStyle,
 121                int stringType,
 122                char *aString)
 123         : utf8FamilyString(aUTF8FamilyString),
 124           fontStyle(aFontStyle),
 125           stringType(stringType),
 126           string(aString),
 127           isRTL(PR_FALSE)
 128     {
 129     }
 130
 131     struct ExpectItem {
 132         ExpectItem(const nsCString& aFontName,
 133                    const LiteralArray& aGlyphs)
 134             : fontName(aFontName), glyphs(aGlyphs)
 135         { }
 136
 137         PRBool Compare(const nsCString& aFontName,
 138                        cairo_glyph_t *aGlyphs,
 139                        int num_glyphs)
 140         {
 141             // bit that allowed for empty fontname to match all is commented
 142             // out
 143             if (/*!fontName.IsEmpty() &&*/ !fontName.Equals(aFontName))
 144                 return PR_FALSE;
 145
 146             if (num_glyphs != int(glyphs.data.Length()))
 147                 return PR_FALSE;
 148
 149             for (int j = 0; j < num_glyphs; j++) {
 150                 if (glyphs.data[j] != aGlyphs[j].index)
 151                 return PR_FALSE;
 152             }
 153
 154             return PR_TRUE;
 155         }
 156
 157         nsCString fontName;
 158         LiteralArray glyphs;
 159     };
 160
 161     void SetRTL()
 162     {
 163         isRTL = PR_TRUE;
 164     }
 165
 166     // empty/NULL fontName means ignore font name
 167     void Expect (const char *platform,
 168                  const char *fontName,
 169                  const LiteralArray& glyphs)
 170     {
 171         if (fontName)
 172             Expect (platform, nsDependentCString(fontName), glyphs);
 173         else
 174             Expect (platform, nsCString(), glyphs);
 175     }
 176
 177     void Expect (const char *platform,
 178                  const nsCString& fontName,
 179                  const LiteralArray& glyphs)
 180     {
 181 #if defined(XP_WIN)
 182         if (strcmp(platform, "win32"))
 183             return;
 184 #elif defined(XP_MACOSX)
 185         if (strcmp(platform, "macosx"))
 186             return;
 187 #elif defined(XP_UNIX)
 188         if (strcmp(platform, "gtk2-pango"))
 189             return;
 190 #else
 191         return;
 192 #endif
 193
 194         expectItems.AppendElement(ExpectItem(fontName, glyphs));
 195     }
 196
 197     PRBool Check (gfxFontTestStore *store) {
 198         if (expectItems.Length() == 0 ||
 199             store->items.Length() != expectItems.Length())
 200         {
 201             return PR_FALSE;
 202         }
 203
 204         for (PRUint32 i = 0; i < expectItems.Length(); i++) {
 205             if (!expectItems[i].Compare(store->items[i].platformFont,
 206                                         store->items[i].glyphs,
 207                                         store->items[i].num_glyphs))
 208                 return PR_FALSE;
 209         }
 210
 211         return PR_TRUE;
 212     }
 213
 214     char *utf8FamilyString;
 215     gfxFontStyle fontStyle;
 216
 217     int stringType;
 218     char *string;
 219     PRPackedBool isRTL;
 220
 221     nsTArray<ExpectItem> expectItems;
 222 };
 223
 224 nsTArray<TestEntry> testList;
 225
 226 already_AddRefed<gfxContext>
 227 MakeContext ()
 228 {
 229     const int size = 200;
 230
 231     nsRefPtr<gfxASurface> surface;
 232
 233     surface = gfxPlatform::GetPlatform()->CreateOffscreenSurface(gfxIntSize(size, size), gfxASurface::ImageFormatRGB24);
 234     gfxContext *ctx = new gfxContext(surface);
 235     NS_IF_ADDREF(ctx);
 236     return ctx;
 237 }
 238
 239 TestEntry*
 240 AddTest (char *utf8FamilyString,
 241          const gfxFontStyle& fontStyle,
 242          int stringType,
 243          char *string)
 244 {
 245     TestEntry te (utf8FamilyString,
 246                   fontStyle,
 247                   stringType,
 248                   string);
 249
 250     testList.AppendElement(te);
 251
 252     return &(testList[testList.Length()-1]);
 253 }
 254
 255 void SetupTests();
 256
 257 void
 258 DumpStore (gfxFontTestStore *store) {
 259     if (store->items.Length() == 0) {
 260         printf ("(empty)\n");
 261     }
 262
 263     for (PRUint32 i = 0;
 264          i < store->items.Length();
 265          i++)
 266     {
 267         printf ("Run[% 2d]: '%s' ", i, nsPromiseFlatCString(store->items[i].platformFont).get());
 268
 269         for (int j = 0; j < store->items[i].num_glyphs; j++)
 270             printf ("%d ", int(store->items[i].glyphs[j].index));
 271
 272         printf ("\n");
 273     }
 274 }
 275
 276 void
 277 DumpTestExpect (TestEntry *test) {
 278     for (PRUint32 i = 0; i < test->expectItems.Length(); i++) {
 279         printf ("Run[% 2d]: '%s' ", i, nsPromiseFlatCString(test->expectItems[i].fontName).get());
 280         for (PRUint32 j = 0; j < test->expectItems[i].glyphs.data.Length(); j++)
 281             printf ("%d ", int(test->expectItems[i].glyphs.data[j]));
 282
 283         printf ("\n");
 284     }
 285 }
 286
 287 PRBool
 288 RunTest (TestEntry *test, gfxContext *ctx) {
 289     nsRefPtr<gfxFontGroup> fontGroup;
 290
 291     fontGroup = gfxPlatform::GetPlatform()->CreateFontGroup(NS_ConvertUTF8toUTF16(test->utf8FamilyString), &test->fontStyle, nsnull);
 292
 293     nsAutoPtr<gfxTextRun> textRun;
 294     gfxTextRunFactory::Parameters params = {
 295       ctx, nsnull, nsnull, nsnull, 0, 60
 296     };
 297     PRUint32 flags = gfxTextRunFactory::TEXT_IS_PERSISTENT;
 298     if (test->isRTL) {
 299         flags |= gfxTextRunFactory::TEXT_IS_RTL;
 300     }
 301     PRUint32 length;
 302     if (test->stringType == S_ASCII) {
 303         flags |= gfxTextRunFactory::TEXT_IS_ASCII | gfxTextRunFactory::TEXT_IS_8BIT;
 304         length = strlen(test->string);
 305         textRun = gfxTextRunWordCache::MakeTextRun(reinterpret_cast<PRUint8*>(test->string), length, fontGroup, &params, flags);
 306     } else {
 307         flags |= gfxTextRunFactory::TEXT_HAS_SURROGATES; // just in case
 308         NS_ConvertUTF8toUTF16 str(nsDependentCString(test->string));
 309         length = str.Length();
 310         textRun = gfxTextRunWordCache::MakeTextRun(str.get(), length, fontGroup, &params, flags);
 311     }
 312
 313     gfxFontTestStore::NewStore();
 314     textRun->Draw(ctx, gfxPoint(0,0), 0, length, nsnull, nsnull, nsnull);
 315     gfxFontTestStore *s = gfxFontTestStore::CurrentStore();
 316
 317     gTextRunCache->RemoveTextRun(textRun);
 318
 319     if (!test->Check(s)) {
 320         DumpStore(s);
 321         printf ("  expected:\n");
 322         DumpTestExpect(test);
 323         return PR_FALSE;
 324     }
 325
 326     return PR_TRUE;
 327 }
 328
 329 int
 330 main (int argc, char **argv) {
 331     int passed = 0;
 332     int failed = 0;
 333
 334 #ifdef MOZ_WIDGET_GTK2
 335     gtk_init(&argc, &argv);
 336 #endif
 337 #ifdef XP_MACOSX
 338     CocoaPoolInit();
 339 #endif
 340
 341     // Initialize XPCOM
 342     nsresult rv = NS_InitXPCOM2(nsnull, nsnull, nsnull);
 343     if (NS_FAILED(rv))
 344         return -1;
 345
 346     rv = gfxPlatform::Init();
 347     if (NS_FAILED(rv))
 348         return -1;
 349
 350     gTextRunCache = new gfxTextRunWordCache();
 351
 352     // let's get all the xpcom goop out of the system
 353     fflush (stderr);
 354     fflush (stdout);
 355
 356     // don't need to query, we might need to set up some prefs later
 357     if (0) {
 358         nsresult rv;
 359
 360         nsCOMPtr<nsIPrefService> prefsvc = do_GetService(NS_PREFSERVICE_CONTRACTID);
 361         if (!prefsvc) {
 362             printf ("Pref svc get failed!\n");
 363         }
 364
 365         nsCOMPtr<nsIPrefBranch> branch;
 366         rv = prefsvc->GetBranch(nsnull, getter_AddRefs(branch));
 367         if (NS_FAILED(rv))
 368             printf ("Failed 0x%08x\n", rv);
 369
 370         nsXPIDLCString str;
 371         rv = branch->GetCharPref("font.name.sans-serif.x-western", getter_Copies(str));
 372         if (NS_FAILED(rv))
 373             printf ("Failed[2] 0x%08x\n", rv);
 374
 375         printf ("sans-serif.x-western: %s\n", nsPromiseFlatCString(str).get());
 376     }
 377
 378     // set up the tests
 379     SetupTests();
 380
 381     nsRefPtr<gfxContext> context = MakeContext();
 382
 383     for (uint test = 0;
 384          test < testList.Length();
 385          test++)
 386     {
 387         printf ("==== Test %d\n", test);
 388         PRBool result = RunTest (&testList[test], context);
 389         if (result) {
 390             printf ("Test %d succeeded\n", test);
 391             passed++;
 392         } else {
 393             printf ("Test %d failed\n", test);
 394             failed++;
 395         }
 396     }
 397
 398     printf ("PASSED: %d FAILED: %d\n", passed, failed);
 399     fflush (stderr);
 400     fflush (stdout);
 401 }
 402
 403 // The tests themselves
 404
 405 #include "gfxFontSelectionTests.h"