Add m-esr52 at 52.6.0

1 files changed, 553 insertions, 0 deletions

diff --git a/layout/tools/tests/regression_tests.js b/layout/tools/tests/regression_tests.js
new file mode 100644
index 000000000..19003b08f
--- /dev/null
+++ b/layout/tools/tests/regression_tests.js
@@ -0,0 +1,553 @@
+
+
+const nsIFilePicker = Components.interfaces.nsIFilePicker;
+const nsILayoutRegressionTester = Components.interfaces.nsILayoutRegressionTester;
+
+const kTestTypeBaseline         = 1;
+const kTestTypeVerify           = 2;
+const kTestTypeVerifyAndCompare = 3;
+const kTestTypeCompare          = 4;
+
+const kTestSourceSingleFile     = 1;
+const kTestSourceDirList        = 2;
+
+var gTestcaseDirArray = new Array;    // array of nsILocalFiles
+
+var gBaselineOutputDir;       // nsIFile
+var gVerifyOutputDir;         // nsIFile
+
+var gBaselineFileExtension;   // string
+var gVerifyFileExtension;     // string
+
+var gTestType;                // baseline, verify, compare etc.
+
+var gTestWindow;
+var gTestURLs = new Array;
+var gTestURLsIndex;
+
+function DoOnload()
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+
+  // clear any values that the form manager may have unhelpfully filled in
+  document.testForm.singleTestFileInput.value = "";
+  document.testForm.baselineOutputDir.value = "";
+  document.testForm.verifyOutputDir.value = "";
+  
+  InitFormFromPrefs();
+  
+  UpdateRunTestsButton();
+}
+
+function InitFormFromPrefs()
+{
+  // load prefs
+  try {
+    var testURL = GetStringPref("nglayout.debug.testcaseURL");
+    document.testForm.singleTestFileInput.value = testURL;
+    
+    var baselineDirURL = GetStringPref("nglayout.debug.baselineDirURL");
+    gBaselineOutputDir = GetFileFromURISpec(baselineDirURL);
+    document.testForm.baselineOutputDir.value = gBaselineOutputDir.path;
+    
+    var verifyDirURL = GetStringPref("nglayout.debug.verifyDirURL");
+    gVerifyOutputDir = GetFileFromURISpec(verifyDirURL);
+    document.testForm.verifyOutputDir.value = gVerifyOutputDir.path;
+    
+    var dirIndex = 0;
+    while (true)    // we'll throw  when we reach a nonexistent pref
+    {
+      var curDir = GetStringPref("nglayout.debug.testcaseDir" + dirIndex);
+      var dirFileSpec = GetFileFromURISpec(curDir);
+      gTestcaseDirArray.push(dirFileSpec);
+      dirIndex ++;
+    }
+  }
+  catch(e)
+  {
+  }
+  
+  RebuildTestDirsSelect();
+}
+
+function SaveFormToPrefs()
+{
+   SaveStringPref("nglayout.debug.testcaseURL", document.testForm.singleTestFileInput.value);
+  
+  // save prefs
+  if (gBaselineOutputDir)
+  {
+    var baselineDirURL = GetURISpecFromFile(gBaselineOutputDir);
+    SaveStringPref("nglayout.debug.baselineDirURL", baselineDirURL);
+  }
+  
+  if (gVerifyOutputDir)
+  {
+    var verifyDirURL = GetURISpecFromFile(gVerifyOutputDir);
+    SaveStringPref("nglayout.debug.verifyDirURL", verifyDirURL);
+  }
+  
+  var dirIndex;
+  for (dirIndex = 0; dirIndex < gTestcaseDirArray.length; dirIndex ++)
+  {
+    var curURL = GetURISpecFromFile(gTestcaseDirArray[dirIndex]);
+    SaveStringPref("nglayout.debug.testcaseDir" + dirIndex, curURL);
+  }
+  try
+  {
+    // clear prefs for higher indices until we throw
+    while (1)
+    {
+      ClearPref("nglayout.debug.testcaseDir" + dirIndex);
+    }
+  }
+  catch(e)
+  {
+  }
+  
+}
+
+function GetURISpecFromFile(inFile)
+{
+  var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
+  var fileHandler = ioService.getProtocolHandler("file").QueryInterface(Components.interfaces.nsIFileProtocolHandler);
+  return fileHandler.getURLSpecFromFile(inFile);
+}
+
+function GetFileFromURISpec(uriSpec)
+{
+  var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
+  var fileHandler = ioService.getProtocolHandler("file").QueryInterface(Components.interfaces.nsIFileProtocolHandler);
+  return fileHandler.getFileFromURLSpec(uriSpec);
+}
+
+function SaveStringPref(inPrefName, inPrefValue)
+{
+  var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
+  prefs.setCharPref(inPrefName, inPrefValue);
+}
+
+function GetStringPref(inPrefName)
+{
+  var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
+  return prefs.getCharPref(inPrefName); 
+}
+
+function ClearPref(inPrefName)
+{
+  var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
+  prefs.clearUserPref(inPrefName); 
+}
+
+function WriteOutput(aText, aReplace, aColorString)
+{
+  var outputDiv = document.getElementById("results");
+
+  if (aReplace)
+    ClearOutput();
+  
+  var childDiv = document.createElement("div");
+  var textNode = document.createTextNode(aText);
+  childDiv.appendChild(textNode);
+  childDiv.setAttribute("style", "color: " + aColorString + ";");
+  outputDiv.appendChild(childDiv);
+}
+
+function ClearOutput()
+{
+  var outputDiv = document.getElementById("results");
+  var curChild;
+  while (curChild = outputDiv.firstChild)
+    outputDiv.removeChild(curChild);
+}
+
+// returns an nsIFile
+function PickDirectory()
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+
+  var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
+  fp.init(window, "Pick a directory", nsIFilePicker.modeGetFolder);
+  var result = fp.show();
+  if (result == nsIFilePicker.returnCancel)
+    throw("User cancelled");
+  
+  var chosenDir = fp.file;
+  return chosenDir;
+}
+
+
+// returns a url string
+function PickFileURL()
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+
+  var fp = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
+  fp.init(window, "Pick a directory", nsIFilePicker.modeOpen);
+  fp.appendFilters(nsIFilePicker.filterHTML + nsIFilePicker.filterText);
+  
+  var result = fp.show();
+  if (result == nsIFilePicker.returnCancel)
+    throw("User cancelled");
+   
+  return fp.fileURL.spec;
+}
+
+function RebuildTestDirsSelect()
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+  var dirsSelect = document.getElementById("testDirsSelect");
+  
+  // rebuild it from gTestcaseDirArray
+  while (dirsSelect.length)
+    dirsSelect.remove(0);
+  
+  var i;
+  for (i = 0; i < gTestcaseDirArray.length; i ++)
+  {
+    var curDir = gTestcaseDirArray[i];
+    
+    var optionElement = document.createElement("option");
+    var textNode = document.createTextNode(curDir.leafName);
+    
+    optionElement.appendChild(textNode);
+    dirsSelect.add(optionElement, null);
+  }
+  
+  UpdateRunTestsButton();
+}
+
+// set the 'single testcase' file
+function ChooseTestcaseFile()
+{
+  var dirInput = document.getElementById("singleTestFileInput");
+  dirInput.value = PickFileURL();
+  
+  UpdateRunTestsButton();
+}
+
+function AppendTestcaseDir()
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+
+  var chosenDir = PickDirectory();
+  // does the array already contain this dir?
+  var i;
+  for (i = 0; i < gTestcaseDirArray.length; i ++)
+  {
+    var curElement = gTestcaseDirArray[i];
+    if (curElement.equals(chosenDir))    // nsIFile::Equals
+      return;
+  }
+  
+  gTestcaseDirArray[gTestcaseDirArray.length] = chosenDir;
+  RebuildTestDirsSelect();
+}
+
+function RemoveTestcaseDir()
+{
+  var dirsSelect = document.getElementById("testDirsSelect");
+  if (dirsSelect.selectedIndex != -1)
+  {
+    gTestcaseDirArray.splice(dirsSelect.selectedIndex, 1);
+    RebuildTestDirsSelect();
+  }
+}
+
+function InputOptionsValid()
+{
+  if (document.testForm.testType[0].checked)
+  {
+    // need a test file
+    var testcaseURL = document.testForm.singleTestFileInput.value;
+    if (testcaseURL.length == 0) return false;
+  }
+  else if (document.testForm.testType[1].checked)
+  {
+    // need at least one dir
+    if (gTestcaseDirArray.length == 0) return false;
+  }
+  else
+    return false;
+
+  return true;
+}
+
+function OutputOptionsValid()
+{
+  var testType = GetTestType();
+  
+  switch (testType)
+  {
+    case kTestTypeBaseline:
+      if (!gBaselineOutputDir) return false;
+      break;
+      
+    case kTestTypeVerify:
+     if (!gVerifyOutputDir) return false;
+      break;
+      
+    case kTestTypeVerifyAndCompare:
+    case kTestTypeCompare:
+     if (!gBaselineOutputDir  || !gVerifyOutputDir) return false;
+      break;
+  }
+
+  return true;
+}
+
+function UpdateRunTestsButton()
+{
+  var testType = GetTestType();
+  var dataValid = OutputOptionsValid();
+  if (testType != kTestTypeCompare)
+    dataValid &= InputOptionsValid();
+  document.testForm.runTests.disabled = !dataValid;
+}
+
+// returns nsIFile, sets the input value
+function ChooseOutputDirectory(inputElementID)
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+  var chosenDir = PickDirectory();
+  
+  var inputElement = document.getElementById(inputElementID);
+  inputElement.value = chosenDir.path;
+  
+  return chosenDir;
+}
+
+
+function CompareFrameDumps(testFileBasename, baselineDir, baselineExt, verifyDir, verifyExt)
+{
+  var debugObject = Components.classes["@mozilla.org/layout-debug/regressiontester;1"].createInstance(nsILayoutRegressionTester);
+  
+  var baseFile = baselineDir.clone();
+  baseFile.append(testFileBasename + baselineExt);
+  
+  var verifyFile = verifyDir.clone();
+  verifyFile.append(testFileBasename + verifyExt);
+  
+  var filesDiffer = debugObject.compareFrameModels(baseFile, verifyFile, nsILayoutRegressionTester.COMPARE_FLAGS_BRIEF);
+  if (filesDiffer)
+  {
+    WriteOutput("Test file '" + baseFile.leafName + "' failed", false, "red");
+  }
+  else
+  {
+    WriteOutput("Test file '" + baseFile.leafName + "' passed", false, "green");
+  }
+}
+
+function DumpFrames(testWindow, testFileName, outputDir, outputFileExtension)
+{
+  var debugObject = Components.classes["@mozilla.org/layout-debug/regressiontester;1"].createInstance(nsILayoutRegressionTester);
+
+  var outputFile = outputDir.clone();
+  outputFile.append(testFileName.replace(".html", outputFileExtension));
+
+  dump("Dumping frame model for " + testFileName + " to " + outputFile.leafName + "\n");
+  var result = debugObject.dumpFrameModel(testWindow, outputFile, nsILayoutRegressionTester.DUMP_FLAGS_MASK_DEFAULT);
+  if (result != 0)
+  {
+    WriteOutput("dumpFrameModel for " + testFileName + " failed", false, "orange");
+  }
+}
+
+function LoadTestURL(testWindow, theURL)
+{
+  dump("Loading test " + theURL + "\n");
+  // we use a 1/2 second delay to give time for async reflows to happen
+  testWindow.onload = setTimeout("HandleTestWindowLoad(gTestWindow)", 1000);
+  testWindow.location.href = theURL;
+}
+
+function HandleTestWindowLoad(testWindow)
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+
+  var outputDir;
+  var outputFileExtension;
+  var runCompare = false;
+  
+  switch (gTestType)
+  {
+    case kTestTypeBaseline:
+      outputDir = gBaselineOutputDir;
+      outputFileExtension = gBaselineFileExtension;
+      break;
+      
+    case kTestTypeVerify:
+      outputDir = gVerifyOutputDir;
+      outputFileExtension = gVerifyFileExtension;
+      break;
+      
+    case kTestTypeVerifyAndCompare:
+      outputDir = gVerifyOutputDir;
+      outputFileExtension = gVerifyFileExtension;
+      runCompare = true;
+      break;
+      
+    case kTestTypeCompare:
+      dump("Should never get here");
+      break;
+  }
+  
+  var loadedURL  = testWindow.location.href;
+  var loadedFile = loadedURL.substring(loadedURL.lastIndexOf('/') + 1);
+
+  DumpFrames(testWindow, loadedFile, outputDir, outputFileExtension);
+  
+  if (runCompare)
+  {
+    var testFileBasename = loadedFile.replace(".html", "");
+    CompareFrameDumps(testFileBasename, gBaselineOutputDir, gBaselineFileExtension, gVerifyOutputDir, gVerifyFileExtension);
+  }
+
+  // now fire of the next one, if we have one
+  var nextURL = gTestURLs[gTestURLsIndex++];
+  if (nextURL)
+    LoadTestURL(testWindow, nextURL);
+  else
+    testWindow.close();
+}
+
+
+function AddDirectoryEntriesToTestList(inDirFile, inRequiredExtension)
+{
+  var enumerator = inDirFile.directoryEntries;
+  
+  while (enumerator.hasMoreElements())
+  {
+    var curFile = enumerator.getNext();
+    curFile = curFile.QueryInterface(Components.interfaces.nsIFile);
+
+    var leafName = curFile.leafName;
+    if (leafName.indexOf(inRequiredExtension) != -1)
+    {
+      var fileURI = GetURISpecFromFile(curFile);
+      gTestURLs.push(fileURI);
+    }
+  }
+}
+
+
+// returns an array of filenames
+function DirectoryEntriesToArray(inDirFile, inRequiredExtension)
+{
+  var fileArray = new Array;
+
+  var enumerator = inDirFile.directoryEntries;
+  while (enumerator.hasMoreElements())
+  {
+    var curFile = enumerator.getNext();
+    curFile = curFile.QueryInterface(Components.interfaces.nsIFile);
+    var leafName = curFile.leafName;
+    if (leafName.indexOf(inRequiredExtension) != -1)
+    {
+      fileArray.push(leafName);
+    }
+  }
+
+  return fileArray;
+}
+
+
+function BuildTestURLsList(testSourceType)
+{
+  // clear the array
+  gTestURLs.splice(0, gTestURLs.length);
+  gTestURLsIndex = 0;
+  
+  if (testSourceType == kTestSourceSingleFile)
+  {
+    var testURL = document.testForm.singleTestFileInput.value;
+    if (testURL.substr(-5) != ".html")
+    {
+      // append /index.html if we have to
+      if (testURL.substr(-1) != "/")
+        testURL += "/";
+      testURL += "index.html";
+    }
+    gTestURLs[0] = testURL;
+  }
+  else
+  {
+    for (var i = 0; i < gTestcaseDirArray.length; i++)
+    {
+      var dirFile = gTestcaseDirArray[i];    // nsIFile for the dir
+      AddDirectoryEntriesToTestList(dirFile, ".html");
+    }
+  }
+}
+
+function CompareFilesInDir(inBaseDir, inBaseExtension, inVerifyDir, inVerifyExtension)
+{
+  var comapareFiles = DirectoryEntriesToArray(inBaseDir, inBaseExtension);
+
+  for (var i = 0; i < comapareFiles.length; i ++)
+  {
+    var curFilename = comapareFiles[i];
+    var testFileBasename = curFilename.replace(inBaseExtension, "");
+    CompareFrameDumps(testFileBasename, inBaseDir, inBaseExtension, inVerifyDir, inVerifyExtension);
+  }
+}
+
+function GetTestType()
+{
+  if (document.testForm.doWhat[0].checked)
+    return kTestTypeBaseline;
+
+  if (document.testForm.doWhat[1].checked)
+    return kTestTypeVerify;
+  
+  if (document.testForm.doWhat[2].checked)
+    return kTestTypeVerifyAndCompare;
+  
+  if (document.testForm.doWhat[3].checked)
+    return kTestTypeCompare;
+
+  return 0;
+}
+
+function RunTests()
+{
+  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
+
+  ClearOutput();
+  SaveFormToPrefs();
+  
+  var testSourceType;
+  if (document.testForm.testType[0].checked)
+    testSourceType = kTestSourceSingleFile;
+  else
+    testSourceType = kTestSourceDirList;
+  
+  gTestType = GetTestType();
+  
+  gBaselineFileExtension = document.testForm.baselineFileExtension.value;
+  gVerifyFileExtension   = document.testForm.verifyFileExtension.value;
+
+  if (gTestType == kTestTypeCompare)
+  {
+    // to compare, we'll just run through all the files in the
+    // baseline and verify dirs, and compare those that exist in
+    // both.
+    CompareFilesInDir(gBaselineOutputDir, gBaselineFileExtension, gVerifyOutputDir, gVerifyFileExtension);
+  }
+  else
+  {
+    BuildTestURLsList(testSourceType);
+  
+    gTestWindow = window.open("about:blank", "Test window",
+          "width=800,height=600,status=yes,toolbars=no");
+    
+    // start the first load
+    var testURL = gTestURLs[0];
+    gTestURLsIndex = 1;
+    LoadTestURL(gTestWindow, testURL);
+  }
+
+}
+
+