← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/layout/tools/tests/regression_tests.js

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/layout/tools/tests/regression_tests.js
 
1
 
 
2
 
 
3
const nsIFilePicker = Components.interfaces.nsIFilePicker;
 
4
const nsILayoutRegressionTester = Components.interfaces.nsILayoutRegressionTester;
 
5
 
 
6
const kTestTypeBaseline         = 1;
 
7
const kTestTypeVerify           = 2;
 
8
const kTestTypeVerifyAndCompare = 3;
 
9
const kTestTypeCompare          = 4;
 
10
 
 
11
const kTestSourceSingleFile     = 1;
 
12
const kTestSourceDirList        = 2;
 
13
 
 
14
var gTestcaseDirArray = new Array;    // array of nsILocalFiles
 
15
 
 
16
var gBaselineOutputDir;       // nsIFile
 
17
var gVerifyOutputDir;         // nsIFile
 
18
 
 
19
var gBaselineFileExtension;   // string
 
20
var gVerifyFileExtension;     // string
 
21
 
 
22
var gTestType;                // baseline, verify, compare etc.
 
23
 
 
24
var gTestWindow;
 
25
var gTestURLs = new Array;
 
26
var gTestURLsIndex;
 
27
 
 
28
function DoOnload()
 
29
{
 
30
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 
31
 
 
32
  // clear any values that the form manager may have unhelpfully filled in
 
33
  document.testForm.singleTestFileInput.value = "";
 
34
  document.testForm.baselineOutputDir.value = "";
 
35
  document.testForm.verifyOutputDir.value = "";
 
36
  
 
37
  InitFormFromPrefs();
 
38
  
 
39
  UpdateRunTestsButton();
 
40
}
 
41
 
 
42
function InitFormFromPrefs()
 
43
{
 
44
  // load prefs
 
45
  try {
 
46
    var testURL = GetStringPref("nglayout.debug.testcaseURL");
 
47
    document.testForm.singleTestFileInput.value = testURL;
 
48
    
 
49
    var baselineDirURL = GetStringPref("nglayout.debug.baselineDirURL");
 
50
    gBaselineOutputDir = GetFileFromURISpec(baselineDirURL);
 
51
    document.testForm.baselineOutputDir.value = gBaselineOutputDir.path;
 
52
    
 
53
    var verifyDirURL = GetStringPref("nglayout.debug.verifyDirURL");
 
54
    gVerifyOutputDir = GetFileFromURISpec(verifyDirURL);
 
55
    document.testForm.verifyOutputDir.value = gVerifyOutputDir.path;
 
56
    
 
57
    var dirIndex = 0;
 
58
    while (true)    // we'll throw  when we reach a nonexistent pref
 
59
    {
 
60
      var curDir = GetStringPref("nglayout.debug.testcaseDir" + dirIndex);
 
61
      var dirFileSpec = GetFileFromURISpec(curDir);
 
62
      gTestcaseDirArray.push(dirFileSpec);
 
63
      dirIndex ++;
 
64
    }
 
65
  }
 
66
  catch(e)
 
67
  {
 
68
  }
 
69
  
 
70
  RebuildTestDirsSelect();
 
71
}
 
72
 
 
73
function SaveFormToPrefs()
 
74
{
 
75
   SaveStringPref("nglayout.debug.testcaseURL", document.testForm.singleTestFileInput.value);
 
76
  
 
77
  // save prefs
 
78
  if (gBaselineOutputDir)
 
79
  {
 
80
    var baselineDirURL = GetURISpecFromFile(gBaselineOutputDir);
 
81
    SaveStringPref("nglayout.debug.baselineDirURL", baselineDirURL);
 
82
  }
 
83
  
 
84
  if (gVerifyOutputDir)
 
85
  {
 
86
    var verifyDirURL = GetURISpecFromFile(gVerifyOutputDir);
 
87
    SaveStringPref("nglayout.debug.verifyDirURL", verifyDirURL);
 
88
  }
 
89
  
 
90
  var dirIndex;
 
91
  for (dirIndex = 0; dirIndex < gTestcaseDirArray.length; dirIndex ++)
 
92
  {
 
93
    var curURL = GetURISpecFromFile(gTestcaseDirArray[dirIndex]);
 
94
    SaveStringPref("nglayout.debug.testcaseDir" + dirIndex, curURL);
 
95
  }
 
96
  try
 
97
  {
 
98
    // clear prefs for higher indices until we throw
 
99
    while (1)
 
100
    {
 
101
      ClearPref("nglayout.debug.testcaseDir" + dirIndex);
 
102
    }
 
103
  }
 
104
  catch(e)
 
105
  {
 
106
  }
 
107
  
 
108
}
 
109
 
 
110
function GetURISpecFromFile(inFile)
 
111
{
 
112
  var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
 
113
  var fileHandler = ioService.getProtocolHandler("file").QueryInterface(Components.interfaces.nsIFileProtocolHandler);
 
114
  return fileHandler.getURLSpecFromFile(inFile);
 
115
}
 
116
 
 
117
function GetFileFromURISpec(uriSpec)
 
118
{
 
119
  var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
 
120
  var fileHandler = ioService.getProtocolHandler("file").QueryInterface(Components.interfaces.nsIFileProtocolHandler);
 
121
  return fileHandler.getFileFromURLSpec(uriSpec);
 
122
}
 
123
 
 
124
function SaveStringPref(inPrefName, inPrefValue)
 
125
{
 
126
  var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
 
127
  prefs.setCharPref(inPrefName, inPrefValue);
 
128
}
 
129
 
 
130
function GetStringPref(inPrefName)
 
131
{
 
132
  var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
 
133
  return prefs.getCharPref(inPrefName); 
 
134
}
 
135
 
 
136
function ClearPref(inPrefName)
 
137
{
 
138
  var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
 
139
  prefs.clearUserPref(inPrefName); 
 
140
}
 
141
 
 
142
function WriteOutput(aText, aReplace, aColorString)
 
143
{
 
144
  var outputDiv = document.getElementById("results");
 
145
 
 
146
  if (aReplace)
 
147
    ClearOutput();
 
148
  
 
149
  var childDiv = document.createElement("div");
 
150
  var textNode = document.createTextNode(aText);
 
151
  childDiv.appendChild(textNode);
 
152
  childDiv.setAttribute("style", "color: " + aColorString + ";");
 
153
  outputDiv.appendChild(childDiv);
 
154
}
 
155
 
 
156
function ClearOutput()
 
157
{
 
158
  var outputDiv = document.getElementById("results");
 
159
  var curChild;
 
160
  while (curChild = outputDiv.firstChild)
 
161
    outputDiv.removeChild(curChild);
 
162
}
 
163
 
 
164
// returns an nsIFile
 
165
function PickDirectory()
 
166
{
 
167
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 
168
 
 
169
  var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
 
170
  fp.init(window, "Pick a directory", nsIFilePicker.modeGetFolder);
 
171
  var result = fp.show();
 
172
  if (result == nsIFilePicker.returnCancel)
 
173
    throw("User cancelled");
 
174
  
 
175
  var chosenDir = fp.file;
 
176
  return chosenDir;
 
177
}
 
178
 
 
179
 
 
180
// returns a url string
 
181
function PickFileURL()
 
182
{
 
183
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 
184
 
 
185
  var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
 
186
  fp.init(window, "Pick a directory", nsIFilePicker.modeOpen);
 
187
  fp.appendFilters(nsIFilePicker.filterHTML + nsIFilePicker.filterText);
 
188
  
 
189
  var result = fp.show();
 
190
  if (result == nsIFilePicker.returnCancel)
 
191
    throw("User cancelled");
 
192
   
 
193
  return fp.fileURL.spec;
 
194
}
 
195
 
 
196
function RebuildTestDirsSelect()
 
197
{
 
198
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 
199
  var dirsSelect = document.getElementById("testDirsSelect");
 
200
  
 
201
  // rebuild it from gTestcaseDirArray
 
202
  while (dirsSelect.length)
 
203
    dirsSelect.remove(0);
 
204
  
 
205
  var i;
 
206
  for (i = 0; i < gTestcaseDirArray.length; i ++)
 
207
  {
 
208
    var curDir = gTestcaseDirArray[i];
 
209
    
 
210
    var optionElement = document.createElement("option");
 
211
    var textNode = document.createTextNode(curDir.leafName);
 
212
    
 
213
    optionElement.appendChild(textNode);
 
214
    dirsSelect.add(optionElement, null);
 
215
  }
 
216
  
 
217
  UpdateRunTestsButton();
 
218
}
 
219
 
 
220
// set the 'single testcase' file
 
221
function ChooseTestcaseFile()
 
222
{
 
223
  var dirInput = document.getElementById("singleTestFileInput");
 
224
  dirInput.value = PickFileURL();
 
225
  
 
226
  UpdateRunTestsButton();
 
227
}
 
228
 
 
229
function AppendTestcaseDir()
 
230
{
 
231
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 
232
 
 
233
  var chosenDir = PickDirectory();
 
234
  // does the array already contain this dir?
 
235
  var i;
 
236
  for (i = 0; i < gTestcaseDirArray.length; i ++)
 
237
  {
 
238
    var curElement = gTestcaseDirArray[i];
 
239
    if (curElement.equals(chosenDir))    // nsIFile::Equals
 
240
      return;
 
241
  }
 
242
  
 
243
  gTestcaseDirArray[gTestcaseDirArray.length] = chosenDir;
 
244
  RebuildTestDirsSelect();
 
245
}
 
246
 
 
247
function RemoveTestcaseDir()
 
248
{
 
249
  var dirsSelect = document.getElementById("testDirsSelect");
 
250
  if (dirsSelect.selectedIndex != -1)
 
251
  {
 
252
    gTestcaseDirArray.splice(dirsSelect.selectedIndex, 1);
 
253
    RebuildTestDirsSelect();
 
254
  }
 
255
}
 
256
 
 
257
function InputOptionsValid()
 
258
{
 
259
  if (document.testForm.testType[0].checked)
 
260
  {
 
261
    // need a test file
 
262
    var testcaseURL = document.testForm.singleTestFileInput.value;
 
263
    if (testcaseURL.length == 0) return false;
 
264
  }
 
265
  else if (document.testForm.testType[1].checked)
 
266
  {
 
267
    // need at least one dir
 
268
    if (gTestcaseDirArray.length == 0) return false;
 
269
  }
 
270
  else
 
271
    return false;
 
272
 
 
273
  return true;
 
274
}
 
275
 
 
276
function OutputOptionsValid()
 
277
{
 
278
  var testType = GetTestType();
 
279
  
 
280
  switch (testType)
 
281
  {
 
282
    case kTestTypeBaseline:
 
283
      if (!gBaselineOutputDir) return false;
 
284
      break;
 
285
      
 
286
    case kTestTypeVerify:
 
287
     if (!gVerifyOutputDir) return false;
 
288
      break;
 
289
      
 
290
    case kTestTypeVerifyAndCompare:
 
291
    case kTestTypeCompare:
 
292
     if (!gBaselineOutputDir  || !gVerifyOutputDir) return false;
 
293
      break;
 
294
  }
 
295
 
 
296
  return true;
 
297
}
 
298
 
 
299
function UpdateRunTestsButton()
 
300
{
 
301
  var testType = GetTestType();
 
302
  var dataValid = OutputOptionsValid();
 
303
  if (testType != kTestTypeCompare)
 
304
    dataValid &= InputOptionsValid();
 
305
  document.testForm.runTests.disabled = !dataValid;
 
306
}
 
307
 
 
308
// returns nsIFile, sets the input value
 
309
function ChooseOutputDirectory(inputElementID)
 
310
{
 
311
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 
312
  var chosenDir = PickDirectory();
 
313
  
 
314
  var inputElement = document.getElementById(inputElementID);
 
315
  inputElement.value = chosenDir.path;
 
316
  
 
317
  return chosenDir;
 
318
}
 
319
 
 
320
 
 
321
function CompareFrameDumps(testFileBasename, baselineDir, baselineExt, verifyDir, verifyExt)
 
322
{
 
323
  var debugObject = Components.classes["@mozilla.org/layout-debug/regressiontester;1"].createInstance(nsILayoutRegressionTester);
 
324
  
 
325
  var baseFile = baselineDir.clone();
 
326
  baseFile.append(testFileBasename + baselineExt);
 
327
  
 
328
  var verifyFile = verifyDir.clone();
 
329
  verifyFile.append(testFileBasename + verifyExt);
 
330
  
 
331
  var filesDiffer = debugObject.compareFrameModels(baseFile, verifyFile, nsILayoutRegressionTester.COMPARE_FLAGS_BRIEF);
 
332
  if (filesDiffer)
 
333
  {
 
334
    WriteOutput("Test file '" + baseFile.leafName + "' failed", false, "red");
 
335
  }
 
336
  else
 
337
  {
 
338
    WriteOutput("Test file '" + baseFile.leafName + "' passed", false, "green");
 
339
  }
 
340
}
 
341
 
 
342
function DumpFrames(testWindow, testFileName, outputDir, outputFileExtension)
 
343
{
 
344
  var debugObject = Components.classes["@mozilla.org/layout-debug/regressiontester;1"].createInstance(nsILayoutRegressionTester);
 
345
 
 
346
  var outputFile = outputDir.clone();
 
347
  outputFile.append(testFileName.replace(".html", outputFileExtension));
 
348
 
 
349
  dump("Dumping frame model for " + testFileName + " to " + outputFile.leafName + "\n");
 
350
  var result = debugObject.dumpFrameModel(testWindow, outputFile, nsILayoutRegressionTester.DUMP_FLAGS_MASK_DEFAULT);
 
351
  if (result != 0)
 
352
  {
 
353
    WriteOutput("dumpFrameModel for " + testFileName + " failed", false, "orange");
 
354
  }
 
355
}
 
356
 
 
357
function LoadTestURL(testWindow, theURL)
 
358
{
 
359
  dump("Loading test " + theURL + "\n");
 
360
  // we use a 1/2 second delay to give time for async reflows to happen
 
361
  testWindow.onload = setTimeout("HandleTestWindowLoad(gTestWindow)", 1000);
 
362
  testWindow.location.href = theURL;
 
363
}
 
364
 
 
365
function HandleTestWindowLoad(testWindow)
 
366
{
 
367
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 
368
 
 
369
  var outputDir;
 
370
  var outputFileExtension;
 
371
  var runCompare = false;
 
372
  
 
373
  switch (gTestType)
 
374
  {
 
375
    case kTestTypeBaseline:
 
376
      outputDir = gBaselineOutputDir;
 
377
      outputFileExtension = gBaselineFileExtension;
 
378
      break;
 
379
      
 
380
    case kTestTypeVerify:
 
381
      outputDir = gVerifyOutputDir;
 
382
      outputFileExtension = gVerifyFileExtension;
 
383
      break;
 
384
      
 
385
    case kTestTypeVerifyAndCompare:
 
386
      outputDir = gVerifyOutputDir;
 
387
      outputFileExtension = gVerifyFileExtension;
 
388
      runCompare = true;
 
389
      break;
 
390
      
 
391
    case kTestTypeCompare:
 
392
      dump("Should never get here");
 
393
      break;
 
394
  }
 
395
  
 
396
  var loadedURL  = testWindow.location.href;
 
397
  var loadedFile = loadedURL.substring(loadedURL.lastIndexOf('/') + 1);
 
398
 
 
399
  DumpFrames(testWindow, loadedFile, outputDir, outputFileExtension);
 
400
  
 
401
  if (runCompare)
 
402
  {
 
403
    var testFileBasename = loadedFile.replace(".html", "");
 
404
    CompareFrameDumps(testFileBasename, gBaselineOutputDir, gBaselineFileExtension, gVerifyOutputDir, gVerifyFileExtension);
 
405
  }
 
406
 
 
407
  // now fire of the next one, if we have one
 
408
  var nextURL = gTestURLs[gTestURLsIndex++];
 
409
  if (nextURL)
 
410
    LoadTestURL(testWindow, nextURL);
 
411
  else
 
412
    testWindow.close();
 
413
}
 
414
 
 
415
 
 
416
function AddDirectoryEntriesToTestList(inDirFile, inRequiredExtension)
 
417
{
 
418
  var enumerator = inDirFile.directoryEntries;
 
419
  
 
420
  while (enumerator.hasMoreElements())
 
421
  {
 
422
    var curFile = enumerator.getNext();
 
423
    curFile = curFile.QueryInterface(Components.interfaces.nsIFile);
 
424
 
 
425
    var leafName = curFile.leafName;
 
426
    if (leafName.indexOf(inRequiredExtension) != -1)
 
427
    {
 
428
      var fileURI = GetURISpecFromFile(curFile);
 
429
      gTestURLs.push(fileURI);
 
430
    }
 
431
  }
 
432
}
 
433
 
 
434
 
 
435
// returns an array of filenames
 
436
function DirectoryEntriesToArray(inDirFile, inRequiredExtension)
 
437
{
 
438
  var fileArray = new Array;
 
439
 
 
440
  var enumerator = inDirFile.directoryEntries;
 
441
  while (enumerator.hasMoreElements())
 
442
  {
 
443
    var curFile = enumerator.getNext();
 
444
    curFile = curFile.QueryInterface(Components.interfaces.nsIFile);
 
445
    var leafName = curFile.leafName;
 
446
    if (leafName.indexOf(inRequiredExtension) != -1)
 
447
    {
 
448
      fileArray.push(leafName);
 
449
    }
 
450
  }
 
451
 
 
452
  return fileArray;
 
453
}
 
454
 
 
455
 
 
456
function BuildTestURLsList(testSourceType)
 
457
{
 
458
  // clear the array
 
459
  gTestURLs.splice(0);
 
460
  gTestURLsIndex = 0;
 
461
  
 
462
  if (testSourceType == kTestSourceSingleFile)
 
463
  {
 
464
    var testURL = document.testForm.singleTestFileInput.value;
 
465
    if (testURL.substr(-5) != ".html")
 
466
    {
 
467
      // append /index.html if we have to
 
468
      if (testURL.substr(-1) != "/")
 
469
        testURL += "/";
 
470
      testURL += "index.html";
 
471
    }
 
472
    gTestURLs[0] = testURL;
 
473
  }
 
474
  else
 
475
  {
 
476
    for (var i = 0; i < gTestcaseDirArray.length; i++)
 
477
    {
 
478
      var dirFile = gTestcaseDirArray[i];    // nsIFile for the dir
 
479
      AddDirectoryEntriesToTestList(dirFile, ".html");
 
480
    }
 
481
  }
 
482
}
 
483
 
 
484
function CompareFilesInDir(inBaseDir, inBaseExtension, inVerifyDir, inVerifyExtension)
 
485
{
 
486
  var comapareFiles = DirectoryEntriesToArray(inBaseDir, inBaseExtension);
 
487
 
 
488
  for (var i = 0; i < comapareFiles.length; i ++)
 
489
  {
 
490
    var curFilename = comapareFiles[i];
 
491
    var testFileBasename = curFilename.replace(inBaseExtension, "");
 
492
    CompareFrameDumps(testFileBasename, inBaseDir, inBaseExtension, inVerifyDir, inVerifyExtension);
 
493
  }
 
494
}
 
495
 
 
496
function GetTestType()
 
497
{
 
498
  if (document.testForm.doWhat[0].checked)
 
499
    return kTestTypeBaseline;
 
500
 
 
501
  if (document.testForm.doWhat[1].checked)
 
502
    return kTestTypeVerify;
 
503
  
 
504
  if (document.testForm.doWhat[2].checked)
 
505
    return kTestTypeVerifyAndCompare;
 
506
  
 
507
  if (document.testForm.doWhat[3].checked)
 
508
    return kTestTypeCompare;
 
509
 
 
510
  return 0;
 
511
}
 
512
 
 
513
function RunTests()
 
514
{
 
515
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
 
516
 
 
517
  ClearOutput();
 
518
  SaveFormToPrefs();
 
519
  
 
520
  var testSourceType;
 
521
  if (document.testForm.testType[0].checked)
 
522
    testSourceType = kTestSourceSingleFile;
 
523
  else
 
524
    testSourceType = kTestSourceDirList;
 
525
  
 
526
  gTestType = GetTestType();
 
527
  
 
528
  gBaselineFileExtension = document.testForm.baselineFileExtension.value;
 
529
  gVerifyFileExtension   = document.testForm.verifyFileExtension.value;
 
530
 
 
531
  if (gTestType == kTestTypeCompare)
 
532
  {
 
533
    // to compare, we'll just run through all the files in the
 
534
    // baseline and verify dirs, and compare those that exist in
 
535
    // both.
 
536
    CompareFilesInDir(gBaselineOutputDir, gBaselineFileExtension, gVerifyOutputDir, gVerifyFileExtension);
 
537
  }
 
538
  else
 
539
  {
 
540
    BuildTestURLsList(testSourceType);
 
541
  
 
542
    gTestWindow = window.open("about:blank", "Test window",
 
543
          "width=800,height=600,status=yes,toolbars=no");
 
544
    
 
545
    // start the first load
 
546
    var testURL = gTestURLs[0];
 
547
    gTestURLsIndex = 1;
 
548
    LoadTestURL(gTestWindow, testURL);
 
549
  }
 
550
 
 
551
}
 
552
 
 
553