webfontloader 1.4.0 → 1.4.1

data/spec/core/fontruler_spec.js

@@ -1,10 +1,13 @@
 describe('FontRuler', function () {
-  var FontRuler = webfont.FontRuler,
+  var Font = webfont.Font,
+      FontRuler = webfont.FontRuler,
       DomHelper = webfont.DomHelper,
       Size = webfont.Size,
-      domHelper = null;
+      domHelper = null,
+      font = null;
 
   beforeEach(function () {
+    font = new Font('sans-serif');
     domHelper = new DomHelper(window);
   });
 
@@ -15,8 +18,8 @@ describe('FontRuler', function () {
     fontRulerA.insert();
     fontRulerB.insert();
 
-    fontRulerA.setFont('sans-serif');
-    fontRulerB.setFont('sans-serif');
+    fontRulerA.setFont(font);
+    fontRulerB.setFont(font);
 
     var widthA = fontRulerA.getWidth(),
         widthB = fontRulerB.getWidth();

data/spec/core/fontwatcher_spec.js

@@ -1,5 +1,6 @@
 describe('FontWatcher', function () {
   var FontWatcher = webfont.FontWatcher,
+      Font = webfont.Font,
       UserAgent = webfont.UserAgent,
       BrowserInfo = webfont.BrowserInfo,
       DomHelper = webfont.DomHelper,
@@ -7,12 +8,20 @@ describe('FontWatcher', function () {
       eventDispatcher = {},
       testStrings = null,
       timeout = null,
+      font1 = null,
+      font2 = null,
+      font3 = null,
+      font4 = null,
       userAgent = null,
-      activeFontFamilies = [];
+      activeFonts = [];
 
   beforeEach(function () {
     userAgent = new UserAgent('Firefox', '3.6', 'Gecko', '1.9.3', 'Macintosh', '10.6', undefined, new BrowserInfo(true, false, false));
-    activeFontFamilies = [];
+    font1 = new Font('font1');
+    font2 = new Font('font2');
+    font3 = new Font('font3');
+    font4 = new Font('font4');
+    activeFonts = [];
     testStrings = jasmine.createSpy('testStrings');
     timeout = jasmine.createSpy('timeout');
     eventDispatcher.dispatchLoading = jasmine.createSpy('dispatchLoading');
@@ -24,11 +33,10 @@ describe('FontWatcher', function () {
   });
 
   function FakeFontWatchRunner(activeCallback, inactiveCallback, domHelper,
-    fontFamily, fontDescription, browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
+    font, browserInfo, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
     this.activeCallback = activeCallback;
     this.inactiveCallback = inactiveCallback;
-    this.fontFamily = fontFamily;
-    this.fontDescription = fontDescription;
+    this.font = font;
     timeout(opt_timeout);
 
     if (opt_fontTestString) {
@@ -39,36 +47,43 @@ describe('FontWatcher', function () {
   FakeFontWatchRunner.prototype.start = function () {
     var found = false;
 
-    for (var i = 0; i < activeFontFamilies.length; i += 1) {
-      if (activeFontFamilies[i] === this.fontFamily) {
+    for (var i = 0; i < activeFonts.length; i += 1) {
+      if (activeFonts[i].getName() === this.font.getName()) {
         found = true;
         break;
       }
     }
-
     if (found) {
-      this.activeCallback(this.fontFamily, this.fontDescription);
+      this.activeCallback(this.font);
     } else {
-      this.inactiveCallback(this.fontFamily, this.fontDescription);
+      this.inactiveCallback(this.font);
     }
   };
 
   describe('watch zero fonts', function () {
     it('should call inactive when there are no fonts to load', function () {
-      activeFontFamilies = [];
+      activeFonts = [];
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch([], {}, {}, FakeFontWatchRunner, true);
+      fontWatcher.watch([], {}, FakeFontWatchRunner, true);
       expect(eventDispatcher.dispatchInactive).toHaveBeenCalled();
     });
+
+    it('should not call inactive when there are no fonts to load, but this is not the last set', function () {
+      activeFonts = [];
+      var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
+
+      fontWatcher.watch([], {}, FakeFontWatchRunner, false);
+      expect(eventDispatcher.dispatchInactive).not.toHaveBeenCalled();
+    });
   });
 
   describe('watch one font not last', function () {
     it('should not call font inactive, inactive or active', function () {
-      activeFontFamilies = ['fontFamily1'];
+      activeFonts = [font1];
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch(['fontFamily1'], {}, {}, FakeFontWatchRunner, false);
+      fontWatcher.watch([font1], {}, FakeFontWatchRunner, false);
       expect(eventDispatcher.dispatchFontInactive).not.toHaveBeenCalled();
       expect(eventDispatcher.dispatchActive).not.toHaveBeenCalled();
       expect(eventDispatcher.dispatchInactive).not.toHaveBeenCalled();
@@ -77,12 +92,12 @@ describe('FontWatcher', function () {
 
   describe('watch one font active', function () {
     it('should call font active and active', function () {
-      activeFontFamilies = ['fontFamily1'];
+      activeFonts = [font1];
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch(['fontFamily1'], {}, {}, FakeFontWatchRunner, true);
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily1', 'n4');
-      expect(eventDispatcher.dispatchFontActive).toHaveBeenCalledWith('fontFamily1', 'n4');
+      fontWatcher.watch([font1], {}, FakeFontWatchRunner, true);
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font1);
+      expect(eventDispatcher.dispatchFontActive).toHaveBeenCalledWith(font1);
       expect(eventDispatcher.dispatchFontInactive).not.toHaveBeenCalled();
       expect(eventDispatcher.dispatchActive).toHaveBeenCalled();
       expect(eventDispatcher.dispatchInactive).not.toHaveBeenCalled();
@@ -91,13 +106,13 @@ describe('FontWatcher', function () {
 
   describe('watch one font inactive', function () {
     it('should call inactive', function () {
-      activeFontFamilies = [];
+      activeFonts = [];
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch(['fontFamily1'], {}, {}, FakeFontWatchRunner, true);
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily1', 'n4');
+      fontWatcher.watch([font1], {}, FakeFontWatchRunner, true);
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font1);
       expect(eventDispatcher.dispatchFontActive).not.toHaveBeenCalled();
-      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith('fontFamily1', 'n4');
+      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith(font1);
       expect(eventDispatcher.dispatchActive).not.toHaveBeenCalled();
       expect(eventDispatcher.dispatchInactive).toHaveBeenCalled();
     });
@@ -105,12 +120,12 @@ describe('FontWatcher', function () {
 
   describe('watch multiple fonts active', function () {
     it('should call font active and active', function () {
-      activeFontFamilies = ['fontFamily1', 'fontFamily2', 'fontFamily3'];
+      activeFonts = [font1, font2, font3];
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch(['fontFamily1', 'fontFamily2', 'fontFamily3'], {}, {}, FakeFontWatchRunner, true);
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily1', 'n4');
-      expect(eventDispatcher.dispatchFontActive).toHaveBeenCalledWith('fontFamily1', 'n4');
+      fontWatcher.watch([font1, font2, font3], {}, FakeFontWatchRunner, true);
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font1);
+      expect(eventDispatcher.dispatchFontActive).toHaveBeenCalledWith(font1);
       expect(eventDispatcher.dispatchFontInactive).not.toHaveBeenCalled();
       expect(eventDispatcher.dispatchActive).toHaveBeenCalled();
       expect(eventDispatcher.dispatchInactive).not.toHaveBeenCalled();
@@ -119,13 +134,13 @@ describe('FontWatcher', function () {
 
   describe('watch multiple fonts inactive', function () {
     it('should call inactive', function () {
-      activeFontFamilies = [];
+      activeFonts = [];
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch(['fontFamily1', 'fontFamily2', 'fontFamily3'], {}, {}, FakeFontWatchRunner, true);
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily1', 'n4');
+      fontWatcher.watch([font1, font2, font3], {}, FakeFontWatchRunner, true);
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font1);
       expect(eventDispatcher.dispatchFontActive).not.toHaveBeenCalled();
-      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith('fontFamily1', 'n4');
+      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith(font1);
       expect(eventDispatcher.dispatchActive).not.toHaveBeenCalled();
       expect(eventDispatcher.dispatchInactive).toHaveBeenCalled();
     });
@@ -133,21 +148,21 @@ describe('FontWatcher', function () {
 
   describe('watch multiple fonts mixed', function () {
     it('should call the correct callbacks', function () {
-      activeFontFamilies = ['fontFamily1', 'fontFamily3'];
+      activeFonts = [font1, font3];
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch(['fontFamily1', 'fontFamily2', 'fontFamily3'], {}, {}, FakeFontWatchRunner, true);
+      fontWatcher.watch([font1, font2, font3], {}, FakeFontWatchRunner, true);
       expect(eventDispatcher.dispatchFontLoading.callCount).toEqual(3);
-      expect(eventDispatcher.dispatchFontLoading.calls[0].args[0]).toEqual('fontFamily1');
-      expect(eventDispatcher.dispatchFontLoading.calls[1].args[0]).toEqual('fontFamily2');
-      expect(eventDispatcher.dispatchFontLoading.calls[2].args[0]).toEqual('fontFamily3');
+      expect(eventDispatcher.dispatchFontLoading.calls[0].args[0]).toEqual(font1);
+      expect(eventDispatcher.dispatchFontLoading.calls[1].args[0]).toEqual(font2);
+      expect(eventDispatcher.dispatchFontLoading.calls[2].args[0]).toEqual(font3);
 
       expect(eventDispatcher.dispatchFontActive.callCount).toEqual(2);
-      expect(eventDispatcher.dispatchFontActive.calls[0].args[0]).toEqual('fontFamily1');
-      expect(eventDispatcher.dispatchFontActive.calls[1].args[0]).toEqual('fontFamily3');
+      expect(eventDispatcher.dispatchFontActive.calls[0].args[0]).toEqual(font1);
+      expect(eventDispatcher.dispatchFontActive.calls[1].args[0]).toEqual(font3);
 
       expect(eventDispatcher.dispatchFontInactive.callCount).toEqual(1);
-      expect(eventDispatcher.dispatchFontInactive.calls[0].args[0]).toEqual('fontFamily2');
+      expect(eventDispatcher.dispatchFontInactive.calls[0].args[0]).toEqual(font2);
 
       expect(eventDispatcher.dispatchActive).toHaveBeenCalled();
       expect(eventDispatcher.dispatchInactive).not.toHaveBeenCalled();
@@ -156,30 +171,32 @@ describe('FontWatcher', function () {
 
   describe('watch multiple fonts with descriptions', function () {
     it('should call the correct callbacks', function () {
-      activeFontFamilies = ['fontFamily1', 'fontFamily2'];
+      var font5 = new Font('font4', 'i7'),
+          font6 = new Font('font5'),
+          font7 = new Font('font6'),
+          font8 = new Font('font7', 'i4'),
+          font9 = new Font('font8', 'n7');
+
+      activeFonts = [font5, font6];
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch(['fontFamily1', 'fontFamily2', 'fontFamily3'], {
-        'fontFamily1': ['i7'],
-        'fontFamily2': null,
-        'fontFamily3': ['n4', 'i4', 'n7']
-      }, {}, FakeFontWatchRunner, true);
+      fontWatcher.watch([font5, font6, font7, font8, font9], {}, FakeFontWatchRunner, true);
 
       expect(eventDispatcher.dispatchFontLoading.callCount).toEqual(5);
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily1', 'i7');
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily2', 'n4');
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily3', 'n4');
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily3', 'i4');
-      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith('fontFamily3', 'n7');
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font5);
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font6);
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font7);
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font8);
+      expect(eventDispatcher.dispatchFontLoading).toHaveBeenCalledWith(font9);
 
       expect(eventDispatcher.dispatchFontActive.callCount).toEqual(2);
-      expect(eventDispatcher.dispatchFontActive).toHaveBeenCalledWith('fontFamily1', 'i7');
-      expect(eventDispatcher.dispatchFontActive).toHaveBeenCalledWith('fontFamily2', 'n4');
+      expect(eventDispatcher.dispatchFontActive).toHaveBeenCalledWith(font5);
+      expect(eventDispatcher.dispatchFontActive).toHaveBeenCalledWith(font6);
 
       expect(eventDispatcher.dispatchFontInactive.callCount).toEqual(3);
-      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith('fontFamily3', 'n4');
-      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith('fontFamily3', 'i4');
-      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith('fontFamily3', 'n7');
+      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith(font7);
+      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith(font8);
+      expect(eventDispatcher.dispatchFontInactive).toHaveBeenCalledWith(font9);
 
       expect(eventDispatcher.dispatchInactive).not.toHaveBeenCalled();
       expect(eventDispatcher.dispatchActive).toHaveBeenCalled();
@@ -188,15 +205,15 @@ describe('FontWatcher', function () {
 
   describe('watch multiple fonts with test strings', function () {
     it('should use the correct tests strings', function () {
-      activeFontFamilies = ['fontFamily1', 'fontFamily2'];
+      activeFonts = [font1, font2];
 
       var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher);
 
-      fontWatcher.watch(['fontFamily1', 'fontFamily2', 'fontFamily3', 'fontFamily4'], {}, {
-        'fontFamily1': 'testString1',
-        'fontFamily2': null,
-        'fontFamily3': 'testString2',
-        'fontFamily4': null
+      fontWatcher.watch([font1, font2, font3, font4], {
+        'font1': 'testString1',
+        'font2': null,
+        'font3': 'testString2',
+        'font4': null
       }, FakeFontWatchRunner, true);
 
       expect(testStrings.callCount).toEqual(2);
@@ -208,7 +225,7 @@ describe('FontWatcher', function () {
   it('should pass on the timeout to FontWatchRunner', function () {
     var fontWatcher = new FontWatcher(userAgent, domHelper, eventDispatcher, 4000);
 
-    fontWatcher.watch(['fontFamily1'], {}, {}, FakeFontWatchRunner, true);
+    fontWatcher.watch([font1], {}, FakeFontWatchRunner, true);
 
     expect(timeout).toHaveBeenCalledWith(4000);
   });

data/spec/core/fontwatchrunner_spec.js

@@ -1,5 +1,6 @@
 describe('FontWatchRunner', function () {
   var FontWatchRunner = webfont.FontWatchRunner,
+      Font = webfont.Font,
       BrowserInfo = webfont.BrowserInfo,
       UserAgentParser = webfont.UserAgentParser,
       DomHelper = webfont.DomHelper,
@@ -17,8 +18,7 @@ describe('FontWatchRunner', function () {
   });
 
   describe('Fake browser', function () {
-    var fontFamily =  'My Family',
-        fontDescription = 'n4',
+    var font =  new Font('My Family', 'n4'),
         TARGET_SIZE = 3,
         FALLBACK_SIZE_A = 1,
         FALLBACK_SIZE_B = 2,
@@ -84,12 +84,12 @@ describe('FontWatchRunner', function () {
       ];
 
       var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-          domHelper, fontFamily, fontDescription, browserInfo);
+          domHelper, font, browserInfo);
 
       fontWatchRunner.start();
 
       jasmine.Clock.tick(1 * 25);
-      expect(activeCallback).toHaveBeenCalledWith('My Family', 'n4');
+      expect(activeCallback).toHaveBeenCalledWith(font);
     });
 
     it('should wait for font load and call active', function () {
@@ -101,12 +101,12 @@ describe('FontWatchRunner', function () {
       ];
 
       var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-          domHelper, fontFamily, fontDescription, browserInfo);
+          domHelper, font, browserInfo);
 
       fontWatchRunner.start();
 
       jasmine.Clock.tick(3 * 25);
-      expect(activeCallback).toHaveBeenCalledWith('My Family', 'n4');
+      expect(activeCallback).toHaveBeenCalledWith(font);
     });
 
     it('should wait for font inactive and call inactive', function () {
@@ -121,12 +121,12 @@ describe('FontWatchRunner', function () {
       ];
 
       var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-          domHelper, fontFamily, fontDescription, browserInfo);
+          domHelper, font, browserInfo);
 
       fontWatchRunner.start();
 
       jasmine.Clock.tick(4 * 25);
-      expect(inactiveCallback).toHaveBeenCalledWith('My Family', 'n4');
+      expect(inactiveCallback).toHaveBeenCalledWith(font);
     });
 
     describe('WebKit fallback bug', function () {
@@ -137,12 +137,12 @@ describe('FontWatchRunner', function () {
         ];
 
         var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-            domHelper, fontFamily, fontDescription, fallbackBugBrowserInfo);
+            domHelper, font, fallbackBugBrowserInfo);
 
         fontWatchRunner.start();
 
         jasmine.Clock.tick(1 * 25);
-        expect(activeCallback).toHaveBeenCalledWith('My Family', 'n4');
+        expect(activeCallback).toHaveBeenCalledWith(font);
       });
 
       it('should consider last resort font as having identical metrics and call active', function () {
@@ -154,12 +154,12 @@ describe('FontWatchRunner', function () {
         timesToGetTimeBeforeTimeout = 2;
 
         var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-            domHelper, fontFamily, fontDescription, fallbackBugBrowserInfo);
+            domHelper, font, fallbackBugBrowserInfo);
 
         fontWatchRunner.start();
 
         jasmine.Clock.tick(1 * 25);
-        expect(activeCallback).toHaveBeenCalledWith('My Family', 'n4');
+        expect(activeCallback).toHaveBeenCalledWith(font);
       });
 
       it('should fail to load font and call inactive', function () {
@@ -172,12 +172,12 @@ describe('FontWatchRunner', function () {
         timesToGetTimeBeforeTimeout = 3;
 
         var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-            domHelper, fontFamily, fontDescription, fallbackBugBrowserInfo);
+            domHelper, font, fallbackBugBrowserInfo);
 
         fontWatchRunner.start();
 
         jasmine.Clock.tick(2 * 25);
-        expect(inactiveCallback).toHaveBeenCalledWith('My Family', 'n4');
+        expect(inactiveCallback).toHaveBeenCalledWith(font);
       });
 
       it('should call inactive when we are loading a metric incompatible font', function () {
@@ -189,13 +189,13 @@ describe('FontWatchRunner', function () {
         timesToGetTimeBeforeTimeout = 2;
 
         var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-            domHelper, fontFamily, fontDescription, fallbackBugBrowserInfo,
+            domHelper, font, fallbackBugBrowserInfo,
             0, { 'My Other Family': true });
 
         fontWatchRunner.start();
 
         jasmine.Clock.tick(1 * 25);
-        expect(inactiveCallback).toHaveBeenCalledWith('My Family', 'n4');
+        expect(inactiveCallback).toHaveBeenCalledWith(font);
       });
 
       it('should call active when we are loading a metric compatible font', function () {
@@ -207,13 +207,13 @@ describe('FontWatchRunner', function () {
         timesToGetTimeBeforeTimeout = 2;
 
         var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-            domHelper, fontFamily, fontDescription, fallbackBugBrowserInfo,
+            domHelper, font, fallbackBugBrowserInfo,
             0, { 'My Family': true });
 
         fontWatchRunner.start();
 
         jasmine.Clock.tick(1 * 25);
-        expect(activeCallback).toHaveBeenCalledWith('My Family', 'n4');
+        expect(activeCallback).toHaveBeenCalledWith(font);
       });
     });
 
@@ -229,7 +229,7 @@ describe('FontWatchRunner', function () {
           TARGET_SIZE, TARGET_SIZE
         ];
         fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-            domHelper, fontFamily, fontDescription, browserInfo);
+            domHelper, font, browserInfo);
 
         fontWatchRunner.start();
 
@@ -243,7 +243,7 @@ describe('FontWatchRunner', function () {
         ];
 
         fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-            domHelper, fontFamily, fontDescription, browserInfo, 0, {}, 'TestString');
+            domHelper, font, browserInfo, 0, {}, 'TestString');
 
         fontWatchRunner.start();
 
@@ -254,17 +254,26 @@ describe('FontWatchRunner', function () {
   });
 
   describe('real browser testing', function () {
-    var userAgent = null;
+    var userAgent = null,
+        nullFont = null,
+        sourceSansA = null,
+        sourceSansB = null,
+        elena = null;
 
     beforeEach(function () {
       var userAgentParser = new UserAgentParser(window.navigator.userAgent, window.document);
 
+      nullFont = new Font('__webfontloader_test__');
+      sourceSansA = new Font('SourceSansA');
+      sourceSansB = new Font('SourceSansB');
+      elena = new Font('Elena');
+
       userAgent = userAgentParser.parse();
     });
 
     it('should fail to load a null font', function () {
       var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-          domHelper, '__webfontloader_test__', '', userAgent.getBrowserInfo(), 500);
+          domHelper, nullFont, userAgent.getBrowserInfo(), 500);
 
       runs(function () {
         fontWatchRunner.start();
@@ -275,23 +284,25 @@ describe('FontWatchRunner', function () {
       });
 
       runs(function () {
-        expect(inactiveCallback).toHaveBeenCalledWith('__webfontloader_test__', '');
+        expect(inactiveCallback).toHaveBeenCalledWith(nullFont);
       });
     });
 
     it('should load font succesfully', function () {
       var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-          domHelper, 'SourceSansA', '', userAgent.getBrowserInfo(), 500),
+          domHelper, sourceSansA, userAgent.getBrowserInfo(), 500),
           ruler = new FontRuler(domHelper, 'abcdef'),
+          monospace = new Font('monospace'),
+          sourceSansAFallback = new Font("'SourceSansA', monospace"),
           activeWidth = null,
           originalWidth = null,
           finalCheck = false;
 
       runs(function () {
         ruler.insert();
-        ruler.setFont('monospace');
+        ruler.setFont(monospace);
         originalWidth = ruler.getWidth();
-        ruler.setFont("'SourceSansA', monospace");
+        ruler.setFont(sourceSansAFallback);
         fontWatchRunner.start();
       });
 
@@ -300,7 +311,7 @@ describe('FontWatchRunner', function () {
       });
 
       runs(function () {
-        expect(activeCallback).toHaveBeenCalledWith('SourceSansA', '');
+        expect(activeCallback).toHaveBeenCalledWith(sourceSansA);
         activeWidth = ruler.getWidth();
         expect(activeWidth).not.toEqual(originalWidth);
 
@@ -321,7 +332,7 @@ describe('FontWatchRunner', function () {
 
     it('should attempt to load a non-existing font', function () {
       var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-          domHelper, 'Elena', '', userAgent.getBrowserInfo(), 500);
+          domHelper, elena, userAgent.getBrowserInfo(), 500);
 
       runs(function () {
         fontWatchRunner.start();
@@ -332,23 +343,25 @@ describe('FontWatchRunner', function () {
       });
 
       runs(function () {
-        expect(inactiveCallback).toHaveBeenCalledWith('Elena', '');
+        expect(inactiveCallback).toHaveBeenCalledWith(elena);
       });
     });
 
     it('should load even if @font-face is inserted after watching has started', function () {
       var fontWatchRunner = new FontWatchRunner(activeCallback, inactiveCallback,
-          domHelper, 'SourceSansB', '', userAgent.getBrowserInfo(), 500),
+          domHelper, sourceSansB, userAgent.getBrowserInfo(), 500),
           ruler = new FontRuler(domHelper, 'abcdef'),
+          monospace = new Font('monospace'),
+          sourceSansBFallback = new Font("'SourceSansB', monospace"),
           activeWidth = null,
           originalWidth = null,
           finalCheck = false;
 
       runs(function () {
         ruler.insert();
-        ruler.setFont('monospace');
+        ruler.setFont(monospace);
         originalWidth = ruler.getWidth();
-        ruler.setFont("'SourceSansB', monospace");
+        ruler.setFont(sourceSansBFallback);
         fontWatchRunner.start();
         var link = document.createElement('link');
 
@@ -363,7 +376,7 @@ describe('FontWatchRunner', function () {
       });
 
       runs(function () {
-        expect(activeCallback).toHaveBeenCalledWith('SourceSansB', '');
+        expect(activeCallback).toHaveBeenCalledWith(sourceSansB);
         activeWidth = ruler.getWidth();
         expect(activeWidth).not.toEqual(originalWidth);
 
@@ -381,5 +394,44 @@ describe('FontWatchRunner', function () {
         expect(ruler.getWidth()).toEqual(activeWidth);
       });
     });
+
+    it('should load one weight after another', function () {
+       var fontWatchRunnerRegular = new FontWatchRunner(activeCallback, inactiveCallback,
+           domHelper, 'SourceSansC', 'n4', userAgent.getBrowserInfo(), 500),
+           fontWatchRunnerBold = new FontWatchRunner(activeCallback, inactiveCallback,
+           domHelper, 'SourceSansC', 'n7', userAgent.getBrowserInfo(), 500),
+           fontRulerA = new FontRuler(domHelper, 'abcdef'),
+           fontRulerB = new FontRuler(domHelper, 'abcdef');
+
+      runs(function () {
+        fontRulerA.insert();
+        fontRulerA.setFont('SourceSansC', 'n4');
+        fontWatchRunnerRegular.start();
+      });
+
+      waitsFor(function () {
+        return activeCallback.wasCalled || inactiveCallback.wasCalled;
+      });
+
+      runs(function () {
+        expect(activeCallback).toHaveBeenCalledWith('SourceSansC', 'n4');
+
+        activeCallback.reset();
+        inactiveCallback.reset();
+
+        fontRulerB.insert();
+        fontRulerB.setFont('SourceSansC', 'n7');
+        fontWatchRunnerBold.start();
+      });
+
+      waitsFor(function () {
+        return activeCallback.wasCalled || inactiveCallback.wasCalled;
+      });
+
+      runs(function () {
+        expect(activeCallback).toHaveBeenCalledWith('SourceSansC', 'n7');
+        expect(fontRulerA.getSize()).not.toEqual(fontRulerB.getSize());
+      });
+    });
   });
 });