(function()()

in contrib/views/capacity-scheduler/src/main/resources/ui/app/assets/javascripts/qunit.js [1814:2495]

• 179 lines of code
• 40 McCabe index (conditional complexity)

(function() {

// Deprecated QUnit.init - Ref #530
// Re-initialize the configuration options
QUnit.init = function() {
  var tests, banner, result, qunit,
    config = QUnit.config;

  config.stats = { all: 0, bad: 0 };
  config.moduleStats = { all: 0, bad: 0 };
  config.started = 0;
  config.updateRate = 1000;
  config.blocking = false;
  config.autostart = true;
  config.autorun = false;
  config.filter = "";
  config.queue = [];
  config.semaphore = 1;

  // Return on non-browser environments
  // This is necessary to not break on node tests
  if ( typeof window === "undefined" ) {
    return;
  }

  qunit = id( "qunit" );
  if ( qunit ) {
    qunit.innerHTML =
      "<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
      "<h2 id='qunit-banner'></h2>" +
      "<div id='qunit-testrunner-toolbar'></div>" +
      "<h2 id='qunit-userAgent'></h2>" +
      "<ol id='qunit-tests'></ol>";
  }

  tests = id( "qunit-tests" );
  banner = id( "qunit-banner" );
  result = id( "qunit-testresult" );

  if ( tests ) {
    tests.innerHTML = "";
  }

  if ( banner ) {
    banner.className = "";
  }

  if ( result ) {
    result.parentNode.removeChild( result );
  }

  if ( tests ) {
    result = document.createElement( "p" );
    result.id = "qunit-testresult";
    result.className = "result";
    tests.parentNode.insertBefore( result, tests );
    result.innerHTML = "Running...<br/>&nbsp;";
  }
};

// Resets the test setup. Useful for tests that modify the DOM.
/*
DEPRECATED: Use multiple tests instead of resetting inside a test.
Use testStart or testDone for custom cleanup.
This method will throw an error in 2.0, and will be removed in 2.1
*/
QUnit.reset = function() {

  // Return on non-browser environments
  // This is necessary to not break on node tests
  if ( typeof window === "undefined" ) {
    return;
  }

  var fixture = id( "qunit-fixture" );
  if ( fixture ) {
    fixture.innerHTML = config.fixture;
  }
};

// Don't load the HTML Reporter on non-Browser environments
if ( typeof window === "undefined" ) {
  return;
}

var config = QUnit.config,
  hasOwn = Object.prototype.hasOwnProperty,
  defined = {
    document: typeof window.document !== "undefined",
    sessionStorage: (function() {
      var x = "qunit-test-string";
      try {
        sessionStorage.setItem( x, x );
        sessionStorage.removeItem( x );
        return true;
      } catch ( e ) {
        return false;
      }
    }())
  };

/**
* Escape text for attribute or text content.
*/
function escapeText( s ) {
  if ( !s ) {
    return "";
  }
  s = s + "";

  // Both single quotes and double quotes (for attributes)
  return s.replace( /['"<>&]/g, function( s ) {
    switch ( s ) {
    case "'":
      return "&#039;";
    case "\"":
      return "&quot;";
    case "<":
      return "&lt;";
    case ">":
      return "&gt;";
    case "&":
      return "&amp;";
    }
  });
}

/**
 * @param {HTMLElement} elem
 * @param {string} type
 * @param {Function} fn
 */
function addEvent( elem, type, fn ) {
  if ( elem.addEventListener ) {

    // Standards-based browsers
    elem.addEventListener( type, fn, false );
  } else if ( elem.attachEvent ) {

    // support: IE <9
    elem.attachEvent( "on" + type, fn );
  }
}

/**
 * @param {Array|NodeList} elems
 * @param {string} type
 * @param {Function} fn
 */
function addEvents( elems, type, fn ) {
  var i = elems.length;
  while ( i-- ) {
    addEvent( elems[ i ], type, fn );
  }
}

function hasClass( elem, name ) {
  return ( " " + elem.className + " " ).indexOf( " " + name + " " ) >= 0;
}

function addClass( elem, name ) {
  if ( !hasClass( elem, name ) ) {
    elem.className += ( elem.className ? " " : "" ) + name;
  }
}

function toggleClass( elem, name ) {
  if ( hasClass( elem, name ) ) {
    removeClass( elem, name );
  } else {
    addClass( elem, name );
  }
}

function removeClass( elem, name ) {
  var set = " " + elem.className + " ";

  // Class name may appear multiple times
  while ( set.indexOf( " " + name + " " ) >= 0 ) {
    set = set.replace( " " + name + " ", " " );
  }

  // trim for prettiness
  elem.className = typeof set.trim === "function" ? set.trim() : set.replace( /^\s+|\s+$/g, "" );
}

function id( name ) {
  return defined.document && document.getElementById && document.getElementById( name );
}

function getUrlConfigHtml() {
  var i, j, val,
    escaped, escapedTooltip,
    selection = false,
    len = config.urlConfig.length,
    urlConfigHtml = "";

  for ( i = 0; i < len; i++ ) {
    val = config.urlConfig[ i ];
    if ( typeof val === "string" ) {
      val = {
        id: val,
        label: val
      };
    }

    escaped = escapeText( val.id );
    escapedTooltip = escapeText( val.tooltip );

    config[ val.id ] = QUnit.urlParams[ val.id ];
    if ( !val.value || typeof val.value === "string" ) {
      urlConfigHtml += "<input id='qunit-urlconfig-" + escaped +
        "' name='" + escaped + "' type='checkbox'" +
        ( val.value ? " value='" + escapeText( val.value ) + "'" : "" ) +
        ( config[ val.id ] ? " checked='checked'" : "" ) +
        " title='" + escapedTooltip + "'><label for='qunit-urlconfig-" + escaped +
        "' title='" + escapedTooltip + "'>" + val.label + "</label>";
    } else {
      urlConfigHtml += "<label for='qunit-urlconfig-" + escaped +
        "' title='" + escapedTooltip + "'>" + val.label +
        ": </label><select id='qunit-urlconfig-" + escaped +
        "' name='" + escaped + "' title='" + escapedTooltip + "'><option></option>";

      if ( QUnit.is( "array", val.value ) ) {
        for ( j = 0; j < val.value.length; j++ ) {
          escaped = escapeText( val.value[ j ] );
          urlConfigHtml += "<option value='" + escaped + "'" +
            ( config[ val.id ] === val.value[ j ] ?
              ( selection = true ) && " selected='selected'" : "" ) +
            ">" + escaped + "</option>";
        }
      } else {
        for ( j in val.value ) {
          if ( hasOwn.call( val.value, j ) ) {
            urlConfigHtml += "<option value='" + escapeText( j ) + "'" +
              ( config[ val.id ] === j ?
                ( selection = true ) && " selected='selected'" : "" ) +
              ">" + escapeText( val.value[ j ] ) + "</option>";
          }
        }
      }
      if ( config[ val.id ] && !selection ) {
        escaped = escapeText( config[ val.id ] );
        urlConfigHtml += "<option value='" + escaped +
          "' selected='selected' disabled='disabled'>" + escaped + "</option>";
      }
      urlConfigHtml += "</select>";
    }
  }

  return urlConfigHtml;
}

function toolbarUrlConfigContainer() {
  var urlConfigContainer = document.createElement( "span" );

  urlConfigContainer.innerHTML = getUrlConfigHtml();

  // For oldIE support:
  // * Add handlers to the individual elements instead of the container
  // * Use "click" instead of "change" for checkboxes
  // * Fallback from event.target to event.srcElement
  addEvents( urlConfigContainer.getElementsByTagName( "input" ), "click", function( event ) {
    var params = {},
      target = event.target || event.srcElement;
    params[ target.name ] = target.checked ?
      target.defaultValue || true :
      undefined;
    window.location = QUnit.url( params );
  });
  addEvents( urlConfigContainer.getElementsByTagName( "select" ), "change", function( event ) {
    var params = {},
      target = event.target || event.srcElement;
    params[ target.name ] = target.options[ target.selectedIndex ].value || undefined;
    window.location = QUnit.url( params );
  });

  return urlConfigContainer;
}

function getModuleNames() {
  var i,
    moduleNames = [];

  for ( i in config.modules ) {
    if ( config.modules.hasOwnProperty( i ) ) {
      moduleNames.push( i );
    }
  }

  moduleNames.sort(function( a, b ) {
    return a.localeCompare( b );
  });

  return moduleNames;
}

function toolbarModuleFilterHtml() {
  var i,
    moduleFilterHtml = "",
    moduleNames = getModuleNames();

  if ( moduleNames.length <= 1 ) {
    return false;
  }

  moduleFilterHtml += "<label for='qunit-modulefilter'>Module: </label>" +
    "<select id='qunit-modulefilter' name='modulefilter'><option value='' " +
    ( config.module === undefined ? "selected='selected'" : "" ) +
    ">< All Modules ></option>";

  for ( i = 0; i < moduleNames.length; i++ ) {
    moduleFilterHtml += "<option value='" +
      escapeText( encodeURIComponent( moduleNames[ i ] ) ) + "' " +
      ( config.module === moduleNames[ i ] ? "selected='selected'" : "" ) +
      ">" + escapeText( moduleNames[ i ] ) + "</option>";
  }
  moduleFilterHtml += "</select>";

  return moduleFilterHtml;
}

function toolbarModuleFilter() {
  var moduleFilter = document.createElement( "span" ),
    moduleFilterHtml = toolbarModuleFilterHtml();

  if ( !moduleFilterHtml ) {
    return false;
  }

  moduleFilter.setAttribute( "id", "qunit-modulefilter-container" );
  moduleFilter.innerHTML = moduleFilterHtml;

  addEvent( moduleFilter.lastChild, "change", function() {
    var selectBox = moduleFilter.getElementsByTagName( "select" )[ 0 ],
      selectedModule = decodeURIComponent( selectBox.options[ selectBox.selectedIndex ].value );

    window.location = QUnit.url({
      module: ( selectedModule === "" ) ? undefined : selectedModule,

      // Remove any existing filters
      filter: undefined,
      testNumber: undefined
    });
  });

  return moduleFilter;
}

function toolbarFilter() {
  var testList = id( "qunit-tests" ),
    filter = document.createElement( "input" );

  filter.type = "checkbox";
  filter.id = "qunit-filter-pass";

  addEvent( filter, "click", function() {
    if ( filter.checked ) {
      addClass( testList, "hidepass" );
      if ( defined.sessionStorage ) {
        sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
      }
    } else {
      removeClass( testList, "hidepass" );
      if ( defined.sessionStorage ) {
        sessionStorage.removeItem( "qunit-filter-passed-tests" );
      }
    }
  });

  if ( config.hidepassed || defined.sessionStorage &&
      sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
    filter.checked = true;

    addClass( testList, "hidepass" );
  }

  return filter;
}

function toolbarLabel() {
  var label = document.createElement( "label" );
  label.setAttribute( "for", "qunit-filter-pass" );
  label.setAttribute( "title", "Only show tests and assertions that fail. Stored in sessionStorage." );
  label.innerHTML = "Hide passed tests";

  return label;
}

function appendToolbar() {
  var moduleFilter,
    toolbar = id( "qunit-testrunner-toolbar" );

  if ( toolbar ) {
    toolbar.appendChild( toolbarFilter() );
    toolbar.appendChild( toolbarLabel() );
    toolbar.appendChild( toolbarUrlConfigContainer() );

    moduleFilter = toolbarModuleFilter();
    if ( moduleFilter ) {
      toolbar.appendChild( moduleFilter );
    }
  }
}

function appendBanner() {
  var banner = id( "qunit-banner" );

  if ( banner ) {
    banner.className = "";
    banner.innerHTML = "<a href='" +
      QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) +
      "'>" + banner.innerHTML + "</a> ";
  }
}

function appendTestResults() {
  var tests = id( "qunit-tests" ),
    result = id( "qunit-testresult" );

  if ( result ) {
    result.parentNode.removeChild( result );
  }

  if ( tests ) {
    tests.innerHTML = "";
    result = document.createElement( "p" );
    result.id = "qunit-testresult";
    result.className = "result";
    tests.parentNode.insertBefore( result, tests );
    result.innerHTML = "Running...<br>&nbsp;";
  }
}

function storeFixture() {
  var fixture = id( "qunit-fixture" );
  if ( fixture ) {
    config.fixture = fixture.innerHTML;
  }
}

function appendUserAgent() {
  var userAgent = id( "qunit-userAgent" );
  if ( userAgent ) {
    userAgent.innerHTML = navigator.userAgent;
  }
}

// HTML Reporter initialization and load
QUnit.begin(function() {
  var qunit = id( "qunit" );

  if ( qunit ) {
    qunit.innerHTML =
    "<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
    "<h2 id='qunit-banner'></h2>" +
    "<div id='qunit-testrunner-toolbar'></div>" +
    "<h2 id='qunit-userAgent'></h2>" +
    "<ol id='qunit-tests'></ol>";
  }

  appendBanner();
  appendTestResults();
  appendUserAgent();
  appendToolbar();
  storeFixture();
});

QUnit.done(function( details ) {
  var i, key,
    banner = id( "qunit-banner" ),
    tests = id( "qunit-tests" ),
    html = [
      "Tests completed in ",
      details.runtime,
      " milliseconds.<br>",
      "<span class='passed'>",
      details.passed,
      "</span> assertions of <span class='total'>",
      details.total,
      "</span> passed, <span class='failed'>",
      details.failed,
      "</span> failed."
    ].join( "" );

  if ( banner ) {
    banner.className = details.failed ? "qunit-fail" : "qunit-pass";
  }

  if ( tests ) {
    id( "qunit-testresult" ).innerHTML = html;
  }

  if ( config.altertitle && defined.document && document.title ) {

    // show ✖ for good, ✔ for bad suite result in title
    // use escape sequences in case file gets loaded with non-utf-8-charset
    document.title = [
      ( details.failed ? "\u2716" : "\u2714" ),
      document.title.replace( /^[\u2714\u2716] /i, "" )
    ].join( " " );
  }

  // clear own sessionStorage items if all tests passed
  if ( config.reorder && defined.sessionStorage && details.failed === 0 ) {
    for ( i = 0; i < sessionStorage.length; i++ ) {
      key = sessionStorage.key( i++ );
      if ( key.indexOf( "qunit-test-" ) === 0 ) {
        sessionStorage.removeItem( key );
      }
    }
  }

  // scroll back to top to show results
  if ( config.scrolltop && window.scrollTo ) {
    window.scrollTo( 0, 0 );
  }
});

function getNameHtml( name, module ) {
  var nameHtml = "";

  if ( module ) {
    nameHtml = "<span class='module-name'>" + escapeText( module ) + "</span>: ";
  }

  nameHtml += "<span class='test-name'>" + escapeText( name ) + "</span>";

  return nameHtml;
}

QUnit.testStart(function( details ) {
  var a, b, li, running, assertList,
    name = getNameHtml( details.name, details.module ),
    tests = id( "qunit-tests" );

  if ( tests ) {
    b = document.createElement( "strong" );
    b.innerHTML = name;

    a = document.createElement( "a" );
    a.innerHTML = "Rerun";
    a.href = QUnit.url({ testNumber: details.testNumber });

    li = document.createElement( "li" );
    li.appendChild( b );
    li.appendChild( a );
    li.className = "running";
    li.id = "qunit-test-output" + details.testNumber;

    assertList = document.createElement( "ol" );
    assertList.className = "qunit-assert-list";

    li.appendChild( assertList );

    tests.appendChild( li );
  }

  running = id( "qunit-testresult" );
  if ( running ) {
    running.innerHTML = "Running: <br>" + name;
  }

});

QUnit.log(function( details ) {
  var assertList, assertLi,
    message, expected, actual,
    testItem = id( "qunit-test-output" + details.testNumber );

  if ( !testItem ) {
    return;
  }

  message = escapeText( details.message ) || ( details.result ? "okay" : "failed" );
  message = "<span class='test-message'>" + message + "</span>";

  // pushFailure doesn't provide details.expected
  // when it calls, it's implicit to also not show expected and diff stuff
  // Also, we need to check details.expected existence, as it can exist and be undefined
  if ( !details.result && hasOwn.call( details, "expected" ) ) {
    expected = escapeText( QUnit.dump.parse( details.expected ) );
    actual = escapeText( QUnit.dump.parse( details.actual ) );
    message += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" +
      expected +
      "</pre></td></tr>";

    if ( actual !== expected ) {
      message += "<tr class='test-actual'><th>Result: </th><td><pre>" +
        actual + "</pre></td></tr>" +
        "<tr class='test-diff'><th>Diff: </th><td><pre>" +
        QUnit.diff( expected, actual ) + "</pre></td></tr>";
    }

    if ( details.source ) {
      message += "<tr class='test-source'><th>Source: </th><td><pre>" +
        escapeText( details.source ) + "</pre></td></tr>";
    }

    message += "</table>";

  // this occours when pushFailure is set and we have an extracted stack trace
  } else if ( !details.result && details.source ) {
    message += "<table>" +
      "<tr class='test-source'><th>Source: </th><td><pre>" +
      escapeText( details.source ) + "</pre></td></tr>" +
      "</table>";
  }

  assertList = testItem.getElementsByTagName( "ol" )[ 0 ];

  assertLi = document.createElement( "li" );
  assertLi.className = details.result ? "pass" : "fail";
  assertLi.innerHTML = message;
  assertList.appendChild( assertLi );
});

QUnit.testDone(function( details ) {
  var testTitle, time, testItem, assertList,
    good, bad, testCounts,
    tests = id( "qunit-tests" );

  // QUnit.reset() is deprecated and will be replaced for a new
  // fixture reset function on QUnit 2.0/2.1.
  // It's still called here for backwards compatibility handling
  QUnit.reset();

  if ( !tests ) {
    return;
  }

  testItem = id( "qunit-test-output" + details.testNumber );
  assertList = testItem.getElementsByTagName( "ol" )[ 0 ];

  good = details.passed;
  bad = details.failed;

  // store result when possible
  if ( config.reorder && defined.sessionStorage ) {
    if ( bad ) {
      sessionStorage.setItem( "qunit-test-" + details.module + "-" + details.name, bad );
    } else {
      sessionStorage.removeItem( "qunit-test-" + details.module + "-" + details.name );
    }
  }

  if ( bad === 0 ) {
    addClass( assertList, "qunit-collapsed" );
  }

  // testItem.firstChild is the test name
  testTitle = testItem.firstChild;

  testCounts = bad ?
    "<b class='failed'>" + bad + "</b>, " + "<b class='passed'>" + good + "</b>, " :
    "";

  testTitle.innerHTML += " <b class='counts'>(" + testCounts +
    details.assertions.length + ")</b>";

  addEvent( testTitle, "click", function() {
    toggleClass( assertList, "qunit-collapsed" );
  });

  time = document.createElement( "span" );
  time.className = "runtime";
  time.innerHTML = details.runtime + " ms";

  testItem.className = bad ? "fail" : "pass";

  testItem.insertBefore( time, assertList );
});

if ( !defined.document || document.readyState === "complete" ) {
  config.autorun = true;
}

if ( defined.document ) {
  addEvent( window, "load", QUnit.load );
}

})();