pi-lean-dimension 0.1.0

package/node_modules/@mixmark-io/domino/test/w3c/harness/DomTestCase.js

@@ -0,0 +1,438 @@
+/*
+Copyright (c) 2001-2005 World Wide Web Consortium,
+(Massachusetts Institute of Technology, Institut National de
+Recherche en Informatique et en Automatique, Keio University). All
+Rights Reserved. This program is distributed under the W3C's Software
+Intellectual Property License. This program is distributed in the
+hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE.
+See W3C License http://www.w3.org/Consortium/Legal/ for more details.
+*/
+
+function assertSize(descr, expected, actual) {
+  var actualSize;
+  assertNotNull(descr, actual);
+  actualSize = actual.length;
+  assertEquals(descr, expected, actualSize);
+}
+
+function assertEqualsAutoCase(context, descr, expected, actual) {
+  if (builder.contentType == "text/html") {
+    if(context == "attribute") {
+      assertEquals(descr, expected.toLowerCase(), actual.toLowerCase());
+    } 
+    else {
+      assertEquals(descr, expected.toUpperCase(), actual);
+    }
+  } 
+  else {
+    assertEquals(descr, expected, actual); 
+  }
+}
+
+
+  function assertEqualsCollectionAutoCase(context, descr, expected, actual) {
+  //
+  // if they aren't the same size, they aren't equal
+  assertEquals(descr, expected.length, actual.length);
+
+  //
+  // if there length is the same, then every entry in the expected list
+  // must appear once and only once in the actual list
+  var expectedLen = expected.length;
+  var expectedValue;
+  var actualLen = actual.length;
+  var i;
+  var j;
+  var matches;
+  for(i = 0; i < expectedLen; i++) {
+    matches = 0;
+    expectedValue = expected[i];
+    for(j = 0; j < actualLen; j++) {
+      if (builder.contentType == "text/html") {
+        if (context == "attribute") {
+          if (expectedValue.toLowerCase() == actual[j].toLowerCase()) {
+            matches++;
+          }
+        }
+        else {
+          if (expectedValue.toUpperCase() == actual[j]) {
+            matches++;
+          }
+        }
+      } 
+      else {
+        if(expectedValue == actual[j]) {
+            matches++;
+        }
+      }
+    }
+    if(matches == 0) {
+      assert(descr + ": No match found for " + expectedValue,false);
+    }
+    if(matches > 1) {
+      assert(descr + ": Multiple matches found for " + expectedValue, false);
+    }
+  }
+}
+
+function assertEqualsCollection(descr, expected, actual) {
+  //
+  // if they aren't the same size, they aren't equal
+  assertEquals(descr, expected.length, actual.length);
+  //
+  // if there length is the same, then every entry in the expected list
+  // must appear once and only once in the actual list
+  var expectedLen = expected.length;
+  var expectedValue;
+  var actualLen = actual.length;
+  var i;
+  var j;
+  var matches;
+  for(i = 0; i < expectedLen; i++) {
+    matches = 0;
+    expectedValue = expected[i];
+    for(j = 0; j < actualLen; j++) {
+      if(expectedValue == actual[j]) {
+        matches++;
+      }
+    }
+    if(matches == 0) {
+      assert(descr + ": No match found for " + expectedValue,false);
+    }
+    if(matches > 1) {
+      assert(descr + ": Multiple matches found for " + expectedValue, false);
+    }
+  }
+}
+
+
+function assertEqualsListAutoCase(context, descr, expected, actual) {
+  var minLength = expected.length;
+  if (actual.length < minLength) {
+    minLength = actual.length;
+  }
+  //
+  for(var i = 0; i < minLength; i++) {
+    assertEqualsAutoCase(context, descr, expected[i], actual[i]);
+  }
+  //
+  // if they aren't the same size, they aren't equal
+  assertEquals(descr, expected.length, actual.length);
+}
+
+function assertEqualsList(descr, expected, actual) {
+  var minLength = expected.length;
+  if (actual.length < minLength) {
+    minLength = actual.length;
+  }
+  //
+  for(var i = 0; i < minLength; i++) {
+    if(expected[i] != actual[i]) {
+      assertEquals(descr, expected[i], actual[i]);
+    }
+  }
+  //
+  // if they aren't the same size, they aren't equal
+  assertEquals(descr, expected.length, actual.length);
+}
+
+function assertInstanceOf(descr, type, obj) {
+  if(type == "Attr") {
+    assertEquals(descr,2,obj.nodeType);
+    var specd = obj.specified;
+  }
+}
+
+function assertSame(descr, expected, actual) {
+  if(expected != actual) {
+    assertEquals(descr, expected.nodeType, actual.nodeType);
+    assertEquals(descr, expected.nodeValue, actual.nodeValue);
+  }
+}
+
+function assertURIEquals(assertID, scheme, path, host, file, name, query, fragment, isAbsolute, actual) {
+  //
+  // URI must be non-null
+  assertNotNull(assertID, actual);
+
+  var uri = actual;
+
+  var lastPound = actual.lastIndexOf("#");
+  var actualFragment = "";
+  if(lastPound != -1) {
+    //
+    //  substring before pound
+    //
+    uri = actual.substring(0,lastPound);
+    actualFragment = actual.substring(lastPound+1);
+  }
+  if(fragment != null) assertEquals(assertID,fragment, actualFragment);
+
+  var lastQuestion = uri.lastIndexOf("?");
+  var actualQuery = "";
+  if(lastQuestion != -1) {
+    //
+    //  substring before pound
+    //
+    uri = actual.substring(0,lastQuestion);
+    actualQuery = actual.substring(lastQuestion+1);
+  }
+  if(query != null) assertEquals(assertID, query, actualQuery);
+
+  var firstColon = uri.indexOf(":");
+  var firstSlash = uri.indexOf("/");
+  var actualPath = uri;
+  var actualScheme = "";
+  if(firstColon != -1 && firstColon < firstSlash) {
+    actualScheme = uri.substring(0,firstColon);
+    actualPath = uri.substring(firstColon + 1);
+  }
+
+  if(scheme != null) {
+    assertEquals(assertID, scheme, actualScheme);
+  }
+
+  if(path != null) {
+    assertEquals(assertID, path, actualPath);
+  }
+
+  if(host != null) {
+    var actualHost = "";
+    if(actualPath.substring(0,2) == "//") {
+      var termSlash = actualPath.substring(2).indexOf("/") + 2;
+      actualHost = actualPath.substring(0,termSlash);
+    }
+    assertEquals(assertID, host, actualHost);
+  }
+
+  if(file != null || name != null) {
+    var actualFile = actualPath;
+    var finalSlash = actualPath.lastIndexOf("/");
+    if(finalSlash != -1) {
+      actualFile = actualPath.substring(finalSlash+1);
+    }
+    if (file != null) {
+      assertEquals(assertID, file, actualFile);
+    }
+    if (name != null) {
+      var actualName = actualFile;
+      var finalDot = actualFile.lastIndexOf(".");
+      if (finalDot != -1) {
+        actualName = actualName.substring(0, finalDot);
+      }
+      assertEquals(assertID, name, actualName);
+    }
+  }
+
+  if(isAbsolute != null) {
+    assertEquals(assertID + ' ' + actualPath, isAbsolute, actualPath.substring(0,1) == "/");
+  }
+}
+
+
+// size() used by assertSize element
+function size(collection) {
+  return collection.length;
+}
+
+function same(expected, actual) {
+  return expected === actual;
+}
+
+function getSuffix(contentType) {
+  switch(contentType) {
+    case "text/html":
+    return ".html";
+
+    case "text/xml":
+    return ".xml";
+
+    case "application/xhtml+xml":
+    return ".xhtml";
+
+    case "image/svg+xml":
+    return ".svg";
+
+    case "text/mathml":
+    return ".mml";
+  }
+  return ".html";
+}
+
+function equalsAutoCase(context, expected, actual) {
+  if (builder.contentType == "text/html") {
+    if (context == "attribute") {
+      return expected.toLowerCase() == actual;
+    }
+    return expected.toUpperCase() == actual;
+  }
+  return expected == actual;
+}
+
+function catchInitializationError(blder, ex) {
+  if (blder == null) {
+    alert(ex);
+  }
+  else {
+    blder.initializationError = ex;
+    blder.initializationFatalError = ex;
+  }
+}
+
+function checkInitialization(blder, testname) {
+    if (blder.initializationError != null) {
+        if (blder.skipIncompatibleTests) {
+          info(testname + " not run:" + blder.initializationError);
+          return blder.initializationError;
+        }
+        else {
+          //
+          //  if an exception was thrown
+          //    rethrow it and do not run the test
+            if (blder.initializationFatalError != null) {
+            throw blder.initializationFatalError;
+          } else {
+            //
+            //  might be recoverable, warn but continue the test
+            warn(testname + ": " +  blder.initializationError);
+          }
+        }
+    }
+    return null;
+}
+
+function createTempURI(scheme) {
+  if (scheme == "http") {
+   return "http://localhost:8080/webdav/tmp" + Math.floor(Math.random() * 100000) + ".xml";
+  }
+  return "file:///tmp/domts" + Math.floor(Math.random() * 100000) + ".xml";
+}
+
+
+function EventMonitor() {
+  this.atEvents = new Array();
+  this.bubbledEvents = new Array();
+  this.capturedEvents = new Array();
+  this.allEvents = new Array();
+}
+
+EventMonitor.prototype.handleEvent = function(evt) {
+    switch(evt.eventPhase) {
+       case 1:
+       monitor.capturedEvents[monitor.capturedEvents.length] = evt;
+       break;
+       
+       case 2:
+       monitor.atEvents[monitor.atEvents.length] = evt;
+       break;
+
+       case 3:
+       monitor.bubbledEvents[monitor.bubbledEvents.length] = evt;
+       break;
+    }
+    monitor.allEvents[monitor.allEvents.length] = evt;
+}
+
+function DOMErrorImpl(err) {
+  this.severity = err.severity;
+  this.message = err.message;
+  this.type = err.type;
+  this.relatedException = err.relatedException;
+  this.relatedData = err.relatedData;
+  this.location = err.location;
+}
+
+
+
+function DOMErrorMonitor() {
+  this.allErrors = new Array();
+}
+
+DOMErrorMonitor.prototype.handleError = function(err) {
+    errorMonitor.allErrors[errorMonitor.allErrors.length] = new DOMErrorImpl(err);
+}
+
+DOMErrorMonitor.prototype.assertLowerSeverity = function(id, severity) {
+    var i;
+    for (i = 0; i < errorMonitor.allErrors.length; i++) {
+        if (errorMonitor.allErrors[i].severity >= severity) {
+           assertEquals(id, severity - 1, errorMonitor.allErrors[i].severity);
+        }
+    }
+}
+
+function UserDataNotification(operation, key, data, src, dst) {
+    this.operation = operation;
+    this.key = key;
+    this.data = data;
+    this.src = src;
+    this.dst = dst;
+}
+
+function UserDataMonitor() {
+  this.allNotifications = new Array();
+}
+
+UserDataMonitor.prototype.handle = function(operation, key, data, src, dst) {
+    userDataMonitor.allNotifications[this.allNotifications.length] =
+         new UserDataNotification(operation, key, data, src, dst);
+}
+
+
+
+
+function checkFeature(feature, version)
+{
+  if (!builder.hasFeature(feature, version))
+  {
+    //
+    //  don't throw exception so that users can select to ignore the precondition
+    //
+    builder.initializationError = "builder does not support feature " + feature + " version " + version;
+  }
+}
+
+function preload(frame, varname, url) {
+  return builder.preload(frame, varname, url);
+}
+
+function load(frame, varname, url) {
+    return builder.load(frame, varname, url);
+}
+
+function getImplementationAttribute(attr) {
+    return builder.getImplementationAttribute(attr);
+}
+
+
+function setImplementationAttribute(attribute, value) {
+    builder.setImplementationAttribute(attribute, value);
+}
+
+function setAsynchronous(value) {
+    if (builder.supportsAsyncChange) {
+      builder.async = value;
+    } else {
+      update();
+    }
+}
+
+
+function toLowerArray(src) {
+   var newArray = new Array();
+   var i;
+   for (i = 0; i < src.length; i++) {
+      newArray[i] = src[i].toLowerCase();
+   }
+   return newArray;
+}
+
+function getImplementation() {
+    return builder.getImplementation();
+}
+
+function warn(msg) {
+  //console.log(msg);
+}

package/node_modules/@mixmark-io/domino/test/w3c/harness/index.js

@@ -0,0 +1,95 @@
+var fs = require('fs');
+var vm = require('vm');
+var assert = require('assert');
+var util = require('util');
+var Path = require('path');
+var domino = require('../../../lib');
+var impl = domino.createDOMImplementation();
+var Window = require('../../../lib/Window');
+
+var globals = {
+  assertEquals: function(message, expected, actual) {
+    assert.equal(actual, expected, message + ': expected ' +
+      util.inspect(expected, false, 0) + ' got ' +
+      util.inspect(actual, false, 0)
+    );
+  },
+  assertTrue: function(message, actual) {
+    globals.assertEquals(message, true, actual);
+  },
+  assertFalse: function(message, actual) {
+    assert.ok(!actual, message);
+  },
+  assertNull: function(message, actual) {
+    globals.assertEquals(message, null, actual);
+  },
+  assertNotNull: function(message, actual) {
+    assert.notEqual(actual, null, message);
+  },
+  console: console
+};
+
+function list(dir, re, fn) {
+  dir = Path.resolve(__dirname, '..', dir);
+  fs.readdirSync(dir).forEach(function(file) {
+    var path = Path.join(dir, file);
+    var m = re.exec(path);
+    if (m) fn.apply(null, m);
+  });
+}
+
+module.exports = function(path) {
+
+  function run(ctx, file) {
+    vm.runInContext(fs.readFileSync(file, 'utf8'), ctx, file);
+    return ctx;
+  }
+
+  function makeContext() {
+    var ctx = vm.createContext(); // create new independent context
+    Object.keys(globals).forEach(function(k) {
+      ctx[k] = globals[k]; // shallow clone
+    });
+
+    ctx.createConfiguredBuilder = function() {
+      return {
+        contentType: 'text/html',
+        hasFeature: function(feature, version) {
+          return impl.hasFeature(feature, version);
+        },
+        getImplementation: function() {
+          return impl;
+        },
+        setImplementationAttribute: function(attr, value) {
+          // Ignore
+        },
+        preload: function(docRef, name, href) {
+          return 1;
+        },
+        load: function(docRef, name, href) {
+          var doc = Path.resolve(__dirname, '..', path, 'files', href) + '.html';
+          var html = fs.readFileSync(doc, 'utf8');
+          var url = 'http://example.com/'+Path.join(path,'files',href)+'.html';
+
+          var document = domino.createDocument(html);
+          document.address = url;
+          var win = new Window(document);
+          return win.document;
+        }
+      };
+    };
+    run(ctx, __dirname + '/DomTestCase.js');
+    return ctx;
+  }
+
+  var tests = {};
+  list(path, /(.*?)\.js$/, function(file, basename) {
+    tests[basename] =  function() {
+      var ctx = makeContext();
+      run(ctx, file);
+      ctx.setUpPage();
+      ctx.runTest();
+    };
+  });
+  return tests;
+};

package/node_modules/@mixmark-io/domino/test/w3c/index.js

@@ -0,0 +1,12 @@
+var suite = require('./harness');
+
+exports.level1 = {
+  core: suite('level1/core/'),
+  html: suite('level1/html/')
+};
+/*
+exports.level2 = {
+  core: suite('level2/core/'),
+  html: suite('level2/html/')
+};
+*/

package/node_modules/@mixmark-io/domino/test/w3c/level1/core/documentgetdoctypenodtd.js

@@ -0,0 +1,110 @@
+
+/*
+Copyright © 2001-2004 World Wide Web Consortium, 
+(Massachusetts Institute of Technology, European Research Consortium 
+for Informatics and Mathematics, Keio University). All 
+Rights Reserved. This work is distributed under the W3C® Software License [1] in the 
+hope that it will be useful, but WITHOUT ANY WARRANTY; without even 
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+
+[1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+*/
+
+
+
+   /**
+    *  Gets URI that identifies the test.
+    *  @return uri identifier of test
+    */
+function getTargetURI() {
+      return "http://www.w3.org/2001/DOM-Test-Suite/level1/core/documentgetdoctypenodtd";
+   }
+
+var docsLoaded = -1000000;
+var builder = null;
+
+//
+//   This function is called by the testing framework before
+//      running the test suite.
+//
+//   If there are no configuration exceptions, asynchronous
+//        document loading is started.  Otherwise, the status
+//        is set to complete and the exception is immediately
+//        raised when entering the body of the test.
+//
+function setUpPage() {
+   setUpPageStatus = 'running';
+   try {
+     //
+     //   creates test document builder, may throw exception
+     //
+     builder = createConfiguredBuilder();
+       setImplementationAttribute("validating", false);
+
+      docsLoaded = 0;
+      
+      var docRef = null;
+      if (typeof(this.doc) != 'undefined') {
+        docRef = this.doc;
+      }
+      docsLoaded += preload(docRef, "doc", "hc_nodtdstaff");
+        
+       if (docsLoaded == 1) {
+          setUpPageStatus = 'complete';
+       }
+    } catch(ex) {
+    	catchInitializationError(builder, ex);
+        setUpPageStatus = 'complete';
+    }
+}
+
+
+
+//
+//   This method is called on the completion of 
+//      each asychronous load started in setUpTests.
+//
+//   When every synchronous loaded document has completed,
+//      the page status is changed which allows the
+//      body of the test to be executed.
+function loadComplete() {
+    if (++docsLoaded == 1) {
+        setUpPageStatus = 'complete';
+    }
+}
+
+
+/**
+* 
+    The "getDoctype()" method returns null for XML documents
+   without a document type declaration.
+   Retrieve the XML document without a DTD and invoke the 
+   "getDoctype()" method.  It should return null. 
+
+* @author NIST
+* @author Mary Brady
+* @see http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-core#ID-B63ED1A31
+*/
+function documentgetdoctypenodtd() {
+   var success;
+    if(checkInitialization(builder, "documentgetdoctypenodtd") != null) return;
+    var doc;
+      var docType;
+      
+      var docRef = null;
+      if (typeof(this.doc) != 'undefined') {
+        docRef = this.doc;
+      }
+      doc = load(docRef, "doc", "hc_nodtdstaff");
+      docType = doc.doctype;
+
+      assertNull("documentGetDocTypeNoDTDAssert",docType);
+    
+}
+
+
+
+
+function runTest() {
+   documentgetdoctypenodtd();
+}