webfontloader 1.0.15 → 1.0.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. data/CHANGELOG +3 -0
  2. data/lib/webfontloader/demo/public/fontwatchrunner-default-fonts.html +86 -0
  3. data/lib/webfontloader/demo/public/index.html +1 -0
  4. data/lib/webfontloader/demo/public/jquery.min.js +166 -0
  5. data/lib/webfontloader/demo/server.rb +9 -0
  6. data/lib/webfontloader.rb +1 -1
  7. data/src/core/fontwatcher.js +30 -88
  8. data/src/core/fontwatchrunner.js +136 -0
  9. data/src/core/namespace.js +1 -1
  10. data/src/modules.yml +1 -0
  11. data/src-test/core/fontwatchertest.js +185 -496
  12. data/src-test/core/fontwatchrunnertest.js +190 -0
  13. data/webfontloader.gemspec +6 -2
  14. metadata +19 -4
data/src-test/core/fontwatchertest.js CHANGED
@@ -3,555 +3,244 @@ var FontWatcherTest = TestCase('FontWatcherTest');
3
3
  FontWatcherTest.prototype.setUp = function() {
4
4
  var self = this;
5
5
 
6
- this.classNames_ = {};
7
- this.classNamesCount_ = 0;
8
- this.fakeDomHelper_ = {
9
- removeElement: function() {},
10
- createElement: function(name, attrs, innerHtml) {
11
- var element = document.createElement(name);
12
-
13
- for (var attr in attrs) {
14
- element.setAttribute(attr, attrs[attr]);
15
- }
16
- element.innerHTML = innerHtml;
17
- return element;
6
+ this.fontLoadingEventCalled_ = 0;
7
+ this.fontLoading_ = {};
8
+ this.fontActiveEventCalled_ = 0;
9
+ this.fontActive_ = {};
10
+ this.fontInactiveEventCalled_ = 0;
11
+ this.fontInactive_ = {};
12
+ this.activeEventCalled_ = 0;
13
+ this.inactiveEventCalled_ = 0;
14
+ this.fakeEventDispatcher_ = {
15
+ dispatchLoading: function() {
16
+ fail('dispatchLoading should not be called by FontWatcher.');
17
+ },
18
+ dispatchFontLoading: function(fontFamily, fontDescription) {
19
+ self.fontLoadingEventCalled_++;
20
+ self.fontLoading_[fontFamily + ' ' + fontDescription] = true;
21
+ },
22
+ dispatchFontActive: function(fontFamily, fontDescription) {
23
+ self.fontActiveEventCalled_++;
24
+ self.fontActive_[fontFamily + ' ' + fontDescription] = true;
18
25
  },
19
- insertInto: function() {},
20
- appendClassName: function(e, name) {
21
- self.classNames_[name] = true;
22
- self.classNamesCount_++;
26
+ dispatchFontInactive: function(fontFamily, fontDescription) {
27
+ self.fontInactiveEventCalled_++;
28
+ self.fontInactive_[fontFamily + ' ' + fontDescription] = true;
23
29
  },
24
- removeClassName: function(e, name) {
25
- var exists = self.classNames_[name];
26
- if (exists) {
27
- self.classNames_[name] = false;
28
- self.classNamesCount_--;
29
- }
30
+ dispatchActive: function() {
31
+ self.activeEventCalled_++;
32
+ },
33
+ dispatchInactive: function() {
34
+ self.inactiveEventCalled_++;
30
35
  }
31
36
  };
32
- this.fakeHtmlElement_ = { className: '' };
33
- this.loadingEventCalled_ = false;
34
- this.fontLoadingEventCalled_ = 0;
35
- this.fontLoading_ = [];
36
- this.fontActiveEventCalled_ = 0;
37
- this.fontActive_ = [];
38
- this.fontInactvieEventCalled_ = 0;
39
- this.fontInactive_ = [];
40
- this.activeEventCalled_ = 0;
41
37
 
42
- var namespace = 'ns';
43
-
44
- this.callbacks_ = {
45
- loading: function() {
46
- self.loadingEventCalled_ = true;
47
- },
48
- active: function() {
49
- self.activeEventCalled_++;
50
- },
51
- fontloading: function(fontFamily, fontDescription) {
52
- self.fontLoadingEventCalled_++;
53
- self.fontLoading_.push(fontFamily + ' ' + fontDescription);
54
- },
55
- fontactive: function(fontFamily, fontDescription) {
56
- self.fontActiveEventCalled_++;
57
- self.fontActive_.push(fontFamily + ' ' + fontDescription);
58
- },
59
- fontinactive: function(fontFamily, fontDescription) {
60
- self.fontInactvieEventCalled_++;
61
- self.fontInactive_.push(fontFamily + ' ' + fontDescription);
62
- }
38
+ this.fakeFontSizer_ = {
39
+ getWidth: function() {
40
+ fail('Fake getWidth should not be called.');
41
+ }
63
42
  };
64
- this.eventDispatcher_ = new webfont.EventDispatcher(this.fakeDomHelper_,
65
- this.fakeHtmlElement_, this.callbacks_, namespace);
66
- };
67
43
 
68
- FontWatcherTest.prototype.testWatchOneFontAlreadyLoaded = function() {
69
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
70
- this.eventDispatcher_, {
71
- getWidth: function(element) {
72
- var fontFamily = element.style.fontFamily;
73
- var fonts = fontFamily.split(',');
74
- var size = fonts.length;
75
-
76
- if (size == 6) {
77
- return 1;
78
- } else {
79
- return 2;
80
- }
81
- }
82
- }, function() {}, function() { return 0; });
83
- var fontFamilies = [ 'fontFamily1' ];
44
+ this.fakeAsyncCall_ = function() {
45
+ fail('Fake asyncCall should not be called.');
46
+ };
84
47
 
85
- fontWatcher.watch(fontFamilies, {}, {}, false);
86
- assertEquals(1, this.fontLoadingEventCalled_);
87
- assertEquals(1, this.fontLoading_.length);
88
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
89
- assertEquals(1, this.fontActiveEventCalled_);
90
- assertEquals(1, this.fontActive_.length);
91
- assertEquals('fontFamily1 n4', this.fontActive_[0]);
92
- };
48
+ this.fakeGetTime_ = function() {
49
+ fail('Fake getTime should not be called.');
50
+ };
93
51
 
94
- FontWatcherTest.prototype.testWatchMultipleFontsAlreadyLoaded = function() {
95
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.eventDispatcher_,{
96
- getWidth: function(element) {
97
- var fontFamily = element.style.fontFamily;
98
- var fonts = fontFamily.split(',');
99
- var size = fonts.length;
100
-
101
- if (size == 6) {
102
- return 1;
103
- } else {
104
- return 2;
105
- }
106
- }
107
- }, function() {}, function() { return 0; });
108
- var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
52
+ // Mock out FontWatchRunner to return active/inactive for families we give it
53
+ this.originalFontWatchRunner_ = webfont.FontWatchRunner;
54
+ this.fontWatchRunnerActiveFamilies_ = [];
55
+ this.testStringCount_ = 0;
56
+ this.testStrings_ = {};
57
+ webfont.FontWatchRunner = function(activeCallback, inactiveCallback, domHelper,
58
+ fontSizer, asyncCall, getTime, fontFamily, fontDescription, opt_fontTestString) {
59
+ if (opt_fontTestString) {
60
+ self.testStringCount_++;
61
+ self.testStrings_[fontFamily] = opt_fontTestString;
62
+ }
63
+
64
+ if (self.fontWatchRunnerActiveFamilies_.indexOf(fontFamily) > -1) {
65
+ activeCallback(fontFamily, fontDescription);
66
+ } else {
67
+ inactiveCallback(fontFamily, fontDescription);
68
+ }
69
+
70
+ };
109
71
 
110
- fontWatcher.watch(fontFamilies, {}, {}, false);
111
- assertEquals(3, this.fontLoadingEventCalled_);
112
- assertEquals(3, this.fontLoading_.length);
113
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
114
- assertEquals('fontFamily2 n4', this.fontLoading_[1]);
115
- assertEquals('fontFamily3 n4', this.fontLoading_[2]);
116
- assertEquals(3, this.fontActiveEventCalled_);
117
- assertEquals(3, this.fontActive_.length);
118
- assertEquals('fontFamily1 n4', this.fontActive_[0]);
119
- assertEquals('fontFamily2 n4', this.fontActive_[1]);
120
- assertEquals('fontFamily3 n4', this.fontActive_[2]);
121
72
  };
122
73
 
123
- FontWatcherTest.prototype.testWatchOneFontWaitForLoad = function() {
124
- var async = false;
125
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
126
- this.eventDispatcher_, {
127
-
128
- count_: 0,
129
-
130
- getWidth: function(element) {
131
- var fontFamily = element.style.fontFamily;
132
- var fonts = fontFamily.split(',');
133
- var size = fonts.length;
134
-
135
- if (size == 6) {
136
- return 1;
137
- } else if (this.count_ == 0) {
138
- this.count_++;
139
- return 1;
140
- } else if (this.count_ == 1) {
141
- return 2;
142
- }
143
- }
144
- }, function(func, timeout) {
145
- async = true;
146
- func();
147
- }, function() { return 0; });
74
+ FontWatcherTest.prototype.tearDown = function() {
75
+ // Replace the original FontWatchRunner implementation
76
+ webfont.FontWatchRunner = this.originalFontWatchRunner_;
77
+ };
78
+
79
+ FontWatcherTest.prototype.testWatchOneFontNotLast = function() {
148
80
  var fontFamilies = [ 'fontFamily1' ];
81
+ this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1' ];
82
+
83
+ var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
84
+ this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
149
85
 
150
86
  fontWatcher.watch(fontFamilies, {}, {}, false);
151
- assertTrue(async);
152
- assertEquals(1, this.fontLoadingEventCalled_);
153
- assertEquals(1, this.fontLoading_.length);
154
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
155
- assertEquals(1, this.fontActiveEventCalled_);
156
- assertEquals(1, this.fontActive_.length);
157
- assertEquals('fontFamily1 n4', this.fontActive_[0]);
87
+
88
+ assertEquals(0, this.fontInactiveEventCalled_);
89
+ assertEquals(0, this.activeEventCalled_);
90
+ assertEquals(0, this.inactiveEventCalled_);
158
91
  };
159
92
 
160
- FontWatcherTest.prototype.testWatchMultipleFontsWaitForLoad = function() {
161
- var async = 0;
162
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
163
- this.eventDispatcher_, {
164
-
165
- font1Count_: 0,
166
- font2Count_: 0,
167
- font3Count_: 0,
168
-
169
- getWidth: function(element) {
170
- var fontFamily = element.style.fontFamily;
171
- var fonts = fontFamily.split(',');
172
- var size = fonts.length;
173
-
174
- if (size == 6) {
175
- return 1;
176
- } else if (fonts[0].indexOf("fontFamily1") != -1 &&
177
- this.font1Count_ != 2) {
178
- this.font1Count_++;
179
- return 1;
180
- } else if (fonts[0].indexOf("fontFamily2") != -1 &&
181
- this.font2Count_ != 1) {
182
- this.font2Count_++;
183
- return 1;
184
- } else if (fonts[0].indexOf("fontFamily3") != -1 &&
185
- this.font3Count_ != 5) {
186
- this.font3Count_++;
187
- return 1;
188
- } else {
189
- return 2;
190
- }
191
- }
192
- }, function(func, timeout) {
193
- async++;
194
- func();
195
- }, function() { return 0; });
196
- var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
93
+ FontWatcherTest.prototype.testWatchOneFontActive = function() {
94
+ var fontFamilies = [ 'fontFamily1' ];
95
+ this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1' ];
197
96
 
198
- fontWatcher.watch(fontFamilies, {}, {}, false);
199
- assertEquals(8, async);
200
- assertEquals(3, this.fontLoadingEventCalled_);
201
- assertEquals(3, this.fontLoading_.length);
202
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
203
- assertEquals('fontFamily2 n4', this.fontLoading_[1]);
204
- assertEquals('fontFamily3 n4', this.fontLoading_[2]);
205
- assertEquals(3, this.fontActiveEventCalled_);
206
- assertEquals(3, this.fontActive_.length);
207
- assertEquals('fontFamily1 n4', this.fontActive_[0]);
208
- assertEquals('fontFamily2 n4', this.fontActive_[1]);
209
- assertEquals('fontFamily3 n4', this.fontActive_[2]);
210
- };
97
+ var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
98
+ this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
211
99
 
212
- FontWatcherTest.prototype.testWatchMultipleFontsWaitForLoadAndLoaded =
213
- function() {
214
- var async = 0;
215
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
216
- this.eventDispatcher_, {
217
-
218
- font1Count_: 0,
219
- font3Count_: 0,
220
-
221
- getWidth: function(element) {
222
- var fontFamily = element.style.fontFamily;
223
- var fonts = fontFamily.split(',');
224
- var size = fonts.length;
225
-
226
- if (size == 6) {
227
- return 1;
228
- } else if (fonts[0].indexOf("fontFamily1") != -1 &&
229
- this.font1Count_ != 2) {
230
- this.font1Count_++;
231
- return 1;
232
- } else if (fonts[0].indexOf("fontFamily3") != -1 &&
233
- this.font3Count_ != 5) {
234
- this.font3Count_++;
235
- return 1;
236
- } else {
237
- return 2;
238
- }
239
- }
240
- }, function(func, timeout) {
241
- async++;
242
- func();
243
- }, function() { return 0; });
244
- var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
100
+ fontWatcher.watch(fontFamilies, {}, {}, true);
245
101
 
246
- fontWatcher.watch(fontFamilies, {}, {}, false);
247
- assertEquals(7, async);
248
- assertEquals(3, this.fontLoadingEventCalled_);
249
- assertEquals(3, this.fontLoading_.length);
250
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
251
- assertEquals('fontFamily2 n4', this.fontLoading_[1]);
252
- assertEquals('fontFamily3 n4', this.fontLoading_[2]);
253
- assertEquals(3, this.fontActiveEventCalled_);
254
- assertEquals(3, this.fontActive_.length);
255
- assertEquals('fontFamily1 n4', this.fontActive_[0]);
256
- assertEquals('fontFamily2 n4', this.fontActive_[1]);
257
- assertEquals('fontFamily3 n4', this.fontActive_[2]);
102
+ assertEquals(1, this.fontLoadingEventCalled_);
103
+ assertEquals(true, this.fontLoading_['fontFamily1 n4']);
104
+ assertEquals(1, this.fontActiveEventCalled_);
105
+ assertEquals(true, this.fontActive_['fontFamily1 n4']);
106
+ assertEquals(0, this.fontInactiveEventCalled_);
107
+ assertEquals(1, this.activeEventCalled_);
108
+ assertEquals(0, this.inactiveEventCalled_);
258
109
  };
259
110
 
260
- FontWatcherTest.prototype.testWatchOneFontWaitForLoadInactive = function() {
261
- var time = 0;
262
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
263
- this.eventDispatcher_, {
264
-
265
- count_: 0,
266
-
267
- getWidth: function(element) {
268
- return 1;
269
- }
270
- }, function(func, timeout) {
271
- func();
272
- }, function() {
273
- time += 2500;
274
- return time;
275
- });
111
+ FontWatcherTest.prototype.testWatchOneFontInactive = function() {
276
112
  var fontFamilies = [ 'fontFamily1' ];
113
+ this.fontWatchRunnerActiveFamilies_ = [];
114
+
115
+ var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
116
+ this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
117
+
118
+ fontWatcher.watch(fontFamilies, {}, {}, true);
277
119
 
278
- fontWatcher.watch(fontFamilies, {}, {}, false);
279
120
  assertEquals(1, this.fontLoadingEventCalled_);
280
- assertEquals(1, this.fontLoading_.length);
281
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
282
- assertEquals(1, this.fontInactvieEventCalled_);
283
- assertEquals(1, this.fontInactive_.length);
284
- assertEquals('fontFamily1 n4', this.fontInactive_[0]);
121
+ assertEquals(true, this.fontLoading_['fontFamily1 n4']);
122
+ assertEquals(0, this.fontActiveEventCalled_);
123
+ assertEquals(1, this.fontInactiveEventCalled_);
124
+ assertEquals(true, this.fontInactive_['fontFamily1 n4']);
125
+ assertEquals(0, this.activeEventCalled_);
126
+ assertEquals(1, this.inactiveEventCalled_);
285
127
  };
286
128
 
287
- FontWatcherTest.prototype.testWatchMultipleFontsWaitForLoadAndInactive =
288
- function() {
289
- var count = 0;
290
- var async = 0;
291
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
292
- this.eventDispatcher_, {
293
-
294
- font1Count_: 0,
295
- font3Count_: 0,
296
-
297
- getWidth: function(element) {
298
- var fontFamily = element.style.fontFamily;
299
- var fonts = fontFamily.split(',');
300
- var size = fonts.length;
301
-
302
- if (size == 6) {
303
- return 1;
304
- } else if (fonts[0].indexOf("fontFamily1") != -1 &&
305
- this.font1Count_ != 2) {
306
- this.font1Count_++;
307
- return 1;
308
- } else if (fonts[0].indexOf("fontFamily2") != -1) {
309
- return 1;
310
- } else if (fonts[0].indexOf("fontFamily3") != -1 &&
311
- this.font3Count_ != 5) {
312
- this.font3Count_++;
313
- return 1;
314
- } else {
315
- return 2;
316
- }
317
- }
318
- }, function(func, timeout) {
319
- async++;
320
- func();
321
- }, function() {
322
- if (++count == 5) {
323
- return 5001;
324
- }
325
- return 0;
326
- });
129
+ FontWatcherTest.prototype.testWatchMultipleFontsActive = function() {
327
130
  var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
131
+ this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
132
+
133
+ var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
134
+ this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
135
+
136
+ fontWatcher.watch(fontFamilies, {}, {}, true);
328
137
 
329
- fontWatcher.watch(fontFamilies, {}, {}, false);
330
- assertEquals(9, async);
331
138
  assertEquals(3, this.fontLoadingEventCalled_);
332
- assertEquals(3, this.fontLoading_.length);
333
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
334
- assertEquals('fontFamily2 n4', this.fontLoading_[1]);
335
- assertEquals('fontFamily3 n4', this.fontLoading_[2]);
336
- assertEquals(2, this.fontActiveEventCalled_);
337
- assertEquals(2, this.fontActive_.length);
338
- assertEquals('fontFamily1 n4', this.fontActive_[0]);
339
- assertEquals('fontFamily3 n4', this.fontActive_[1]);
340
- assertEquals(1, this.fontInactvieEventCalled_);
341
- assertEquals('fontFamily2 n4', this.fontInactive_[0]);
139
+ assertEquals(true, this.fontLoading_['fontFamily1 n4']);
140
+ assertEquals(true, this.fontLoading_['fontFamily2 n4']);
141
+ assertEquals(true, this.fontLoading_['fontFamily3 n4']);
142
+ assertEquals(3, this.fontActiveEventCalled_);
143
+ assertEquals(true, this.fontActive_['fontFamily1 n4']);
144
+ assertEquals(true, this.fontActive_['fontFamily2 n4']);
145
+ assertEquals(true, this.fontActive_['fontFamily3 n4']);
146
+ assertEquals(0, this.fontInactiveEventCalled_);
147
+ assertEquals(1, this.activeEventCalled_);
148
+ assertEquals(0, this.inactiveEventCalled_);
342
149
  };
343
150
 
344
- FontWatcherTest.prototype.testWatchMultipleFontsAlreadyLoadedAndLastBatchOnDone
345
- = function() {
346
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.eventDispatcher_,{
347
- getWidth: function(element) {
348
- var fontFamily = element.style.fontFamily;
349
- var fonts = fontFamily.split(',');
350
- var size = fonts.length;
351
-
352
- if (size == 6) {
353
- return 1;
354
- } else {
355
- return 2;
356
- }
357
- }
358
- }, function() {}, function() { return 0; });
151
+ FontWatcherTest.prototype.testWatchMultipleFontsInactive = function() {
359
152
  var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
153
+ this.fontWatchRunnerActiveFamilies_ = [];
154
+
155
+ var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
156
+ this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
360
157
 
361
158
  fontWatcher.watch(fontFamilies, {}, {}, true);
159
+
362
160
  assertEquals(3, this.fontLoadingEventCalled_);
363
- assertEquals(3, this.fontLoading_.length);
364
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
365
- assertEquals('fontFamily2 n4', this.fontLoading_[1]);
366
- assertEquals('fontFamily3 n4', this.fontLoading_[2]);
367
- assertEquals(3, this.fontActiveEventCalled_);
368
- assertEquals(3, this.fontActive_.length);
369
- assertEquals('fontFamily1 n4', this.fontActive_[0]);
370
- assertEquals('fontFamily2 n4', this.fontActive_[1]);
371
- assertEquals('fontFamily3 n4', this.fontActive_[2]);
372
- assertEquals(1, this.activeEventCalled_);
373
- assertEquals(4, this.classNamesCount_);
374
- assertEquals(true, this.classNames_['ns-fontfamily1-n4-active']);
375
- assertEquals(true, this.classNames_['ns-fontfamily2-n4-active']);
376
- assertEquals(true, this.classNames_['ns-fontfamily3-n4-active']);
377
- assertEquals(true, this.classNames_['ns-active']);
161
+ assertEquals(true, this.fontLoading_['fontFamily1 n4']);
162
+ assertEquals(true, this.fontLoading_['fontFamily2 n4']);
163
+ assertEquals(true, this.fontLoading_['fontFamily3 n4']);
164
+ assertEquals(0, this.fontActiveEventCalled_);
165
+ assertEquals(3, this.fontInactiveEventCalled_);
166
+ assertEquals(true, this.fontInactive_['fontFamily1 n4']);
167
+ assertEquals(true, this.fontInactive_['fontFamily2 n4']);
168
+ assertEquals(true, this.fontInactive_['fontFamily3 n4']);
169
+ assertEquals(0, this.activeEventCalled_);
170
+ assertEquals(1, this.inactiveEventCalled_);
378
171
  };
379
172
 
380
- FontWatcherTest.prototype.testWatchMultipleFontsWaitForLoadAndLastBatchOnDone =
381
- function() {
382
- var async = 0;
383
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
384
- this.eventDispatcher_, {
385
-
386
- font1Count_: 0,
387
- font2Count_: 0,
388
- font3Count_: 0,
389
-
390
- getWidth: function(element) {
391
- var fontFamily = element.style.fontFamily;
392
- var fonts = fontFamily.split(',');
393
- var size = fonts.length;
394
-
395
- if (size == 6) {
396
- return 1;
397
- } else if (fonts[0].indexOf("fontFamily1") != -1 &&
398
- this.font1Count_ != 2) {
399
- this.font1Count_++;
400
- return 1;
401
- } else if (fonts[0].indexOf("fontFamily2") != -1 &&
402
- this.font2Count_ != 1) {
403
- this.font2Count_++;
404
- return 1;
405
- } else if (fonts[0].indexOf("fontFamily3") != -1 &&
406
- this.font3Count_ != 5) {
407
- this.font3Count_++;
408
- return 1;
409
- } else {
410
- return 2;
411
- }
412
- }
413
- }, function(func, timeout) {
414
- async++;
415
- func();
416
- }, function() { return 0; });
173
+ FontWatcherTest.prototype.testWatchMultipleFontsMixed = function() {
417
174
  var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
175
+ this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1', 'fontFamily3' ];
176
+
177
+ var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
178
+ this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
418
179
 
419
180
  fontWatcher.watch(fontFamilies, {}, {}, true);
420
- assertEquals(8, async);
181
+
421
182
  assertEquals(3, this.fontLoadingEventCalled_);
422
- assertEquals(3, this.fontLoading_.length);
423
- assertEquals('fontFamily1 n4', this.fontLoading_[0]);
424
- assertEquals('fontFamily2 n4', this.fontLoading_[1]);
425
- assertEquals('fontFamily3 n4', this.fontLoading_[2]);
426
- assertEquals(3, this.fontActiveEventCalled_);
427
- assertEquals(3, this.fontActive_.length);
428
- assertEquals('fontFamily1 n4', this.fontActive_[0]);
429
- assertEquals('fontFamily2 n4', this.fontActive_[1]);
430
- assertEquals('fontFamily3 n4', this.fontActive_[2]);
183
+ assertEquals(true, this.fontLoading_['fontFamily1 n4']);
184
+ assertEquals(true, this.fontLoading_['fontFamily2 n4']);
185
+ assertEquals(true, this.fontLoading_['fontFamily3 n4']);
186
+ assertEquals(2, this.fontActiveEventCalled_);
187
+ assertEquals(true, this.fontActive_['fontFamily1 n4']);
188
+ assertEquals(true, this.fontActive_['fontFamily3 n4']);
189
+ assertEquals(1, this.fontInactiveEventCalled_);
190
+ assertEquals(true, this.fontInactive_['fontFamily2 n4']);
431
191
  assertEquals(1, this.activeEventCalled_);
432
- assertEquals(true, this.classNames_['ns-fontfamily1-n4-active']);
433
- assertEquals(true, this.classNames_['ns-fontfamily2-n4-active']);
434
- assertEquals(true, this.classNames_['ns-fontfamily3-n4-active']);
435
- assertEquals(true, this.classNames_['ns-active']);
436
- assertEquals(4, this.classNamesCount_);
192
+ assertEquals(0, this.inactiveEventCalled_);
437
193
  };
438
194
 
439
- FontWatcherTest.prototype
440
- .testWatchMultipleFontsWaitForLoadAndLastBatchOnDoneWithVariations =
441
- function() {
442
- var async = 0;
443
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
444
- this.eventDispatcher_, {
445
-
446
- font1Count_: 0,
447
- font2Count_: 0,
448
- font3Count_: 0,
449
-
450
- getWidth: function(element) {
451
- var fontFamily = element.style.fontFamily;
452
- var fonts = fontFamily.split(',');
453
- var size = fonts.length;
454
-
455
- if (size == 6) {
456
- return 1;
457
- } else if (fonts[0].indexOf("fontFamily1") != -1 &&
458
- this.font1Count_ != 2) {
459
- this.font1Count_++;
460
- return 1;
461
- } else if (fonts[0].indexOf("fontFamily2") != -1 &&
462
- this.font2Count_ != 1) {
463
- this.font2Count_++;
464
- return 1;
465
- } else if (fonts[0].indexOf("fontFamily3") != -1 &&
466
- this.font3Count_ != 5) {
467
- this.font3Count_++;
468
- return 1;
469
- } else {
470
- return 2;
471
- }
472
- }
473
- }, function(func, timeout) {
474
- async++;
475
- func();
476
- }, function() { return 0; });
195
+ FontWatcherTest.prototype.testWatchMultipleFontsWithDescriptions = function() {
477
196
  var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3' ];
197
+ this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1', 'fontFamily2' ];
478
198
 
479
- fontWatcher.watch(fontFamilies, {
480
- 'fontFamily1': ['i7'],
481
- 'fontFamily2': null,
482
- 'fontFamily3': ['n4', 'i4', 'n7'] }, {}, true);
199
+ var fontDescriptions = {
200
+ 'fontFamily1': ['i7'],
201
+ 'fontFamily2': null,
202
+ 'fontFamily3': ['n4', 'i4', 'n7']
203
+ };
204
+
205
+ var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
206
+ this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
207
+
208
+ fontWatcher.watch(fontFamilies, fontDescriptions, {}, true);
483
209
 
484
- assertEquals(8, async);
485
210
  assertEquals(5, this.fontLoadingEventCalled_);
486
- assertEquals(5, this.fontLoading_.length);
487
- assertEquals('fontFamily1 i7',
488
- this.fontLoading_[0]);
489
- assertEquals('fontFamily2 n4', this.fontLoading_[1]);
490
- assertEquals('fontFamily3 n4',
491
- this.fontLoading_[2]);
492
- assertEquals('fontFamily3 i4', this.fontLoading_[3]);
493
- assertEquals('fontFamily3 n7', this.fontLoading_[4]);
494
- assertEquals(5, this.fontActiveEventCalled_);
495
- assertEquals(5, this.fontActive_.length);
496
- assertEquals('fontFamily1 i7',
497
- this.fontActive_[0]);
498
- assertEquals('fontFamily2 n4', this.fontActive_[1]);
499
- assertEquals('fontFamily3 n4',
500
- this.fontActive_[2]);
501
- assertEquals('fontFamily3 i4', this.fontActive_[3]);
502
- assertEquals('fontFamily3 n7', this.fontActive_[4]);
211
+ assertEquals(true, this.fontLoading_['fontFamily1 i7']);
212
+ assertEquals(true, this.fontLoading_['fontFamily2 n4']);
213
+ assertEquals(true, this.fontLoading_['fontFamily3 n4']);
214
+ assertEquals(true, this.fontLoading_['fontFamily3 i4']);
215
+ assertEquals(true, this.fontLoading_['fontFamily3 n7']);
216
+ assertEquals(2, this.fontActiveEventCalled_);
217
+ assertEquals(true, this.fontActive_['fontFamily1 i7']);
218
+ assertEquals(true, this.fontActive_['fontFamily2 n4']);
219
+ assertEquals(3, this.fontInactiveEventCalled_);
220
+ assertEquals(true, this.fontInactive_['fontFamily3 n4']);
221
+ assertEquals(true, this.fontInactive_['fontFamily3 i4']);
222
+ assertEquals(true, this.fontInactive_['fontFamily3 n7']);
503
223
  assertEquals(1, this.activeEventCalled_);
504
- assertEquals(6, this.classNamesCount_);
505
- assertEquals(true, this.classNames_['ns-fontfamily1-i7-active']);
506
- assertEquals(true, this.classNames_['ns-fontfamily2-n4-active']);
507
- assertEquals(true, this.classNames_['ns-fontfamily3-n4-active']);
508
- assertEquals(true, this.classNames_['ns-fontfamily3-i4-active']);
509
- assertEquals(true, this.classNames_['ns-fontfamily3-n7-active']);
510
- assertEquals(true, this.classNames_['ns-active']);
224
+ assertEquals(0, this.inactiveEventCalled_);
511
225
  };
512
226
 
513
- FontWatcherTest.prototype.testTestStringIsNotDefault = function() {
514
- var testString = '';
515
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
516
- this.eventDispatcher_, {
517
- getWidth: function(element) {
518
- var fontFamily = element.style.fontFamily;
519
- var fonts = fontFamily.split(',');
520
- var size = fonts.length;
521
-
522
- testString = element.innerHTML;
523
- if (size == 6) {
524
- return 1;
525
- } else {
526
- return 2;
527
- }
528
- }
529
- }, function() {}, function() { return 0; });
530
- var fontFamilies = [ 'fontFamily1' ];
227
+ FontWatcherTest.prototype.testWatchMultipleFontsWithTestStrings = function() {
228
+ var fontFamilies = [ 'fontFamily1', 'fontFamily2', 'fontFamily3', 'fontFamily4' ];
229
+ this.fontWatchRunnerActiveFamilies_ = [ 'fontFamily1', 'fontFamily2' ];
531
230
 
532
- fontWatcher.watch(fontFamilies, {}, { 'fontFamily1': 'testString!' }, false);
533
- assertEquals('testString!', testString);
534
- };
231
+ var fontTestStrings = {
232
+ 'fontFamily1': 'testString1',
233
+ 'fontFamily2': null,
234
+ 'fontFamily3': 'testString3',
235
+ 'fontFamily4': null
236
+ };
535
237
 
536
- FontWatcherTest.prototype.testTestStringIsDefault = function() {
537
- var testString = '';
538
- var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_,
539
- this.eventDispatcher_, {
540
- getWidth: function(element) {
541
- var fontFamily = element.style.fontFamily;
542
- var fonts = fontFamily.split(',');
543
- var size = fonts.length;
544
-
545
- testString = element.innerHTML;
546
- if (size == 6) {
547
- return 1;
548
- } else {
549
- return 2;
550
- }
551
- }
552
- }, function() {}, function() { return 0; });
553
- var fontFamilies = [ 'fontFamily1' ];
238
+ var fontWatcher = new webfont.FontWatcher(this.fakeDomHelper_, this.fakeEventDispatcher_,
239
+ this.fakeFontSizer_, this.fakeAsyncCall_, this.fakeGetTime_);
554
240
 
555
- fontWatcher.watch(fontFamilies, {}, {}, false);
556
- assertEquals('Mm', testString);
241
+ fontWatcher.watch(fontFamilies, {}, fontTestStrings, true);
242
+
243
+ assertEquals(2, this.testStringCount_);
244
+ assertEquals('testString1', this.testStrings_['fontFamily1']);
245
+ assertEquals('testString3', this.testStrings_['fontFamily3']);
557
246
  };