Log assertion details using both the old QUnit.log interface and
QUnit.on( "assertion" ) interface.

@private
554261
function logAssertion(details) {
  		runLoggingCallbacks("log", details);

  		var assertion = {
  			passed: details.result,
  			actual: details.actual,
  			expected: details.expected,
  			message: details.message,
  			stack: details.source,
  			todo: details.todo
  		};
  		this.testReport.pushAssertion(assertion);
  		emit("assertion", assertion);
  	}
568648
protected final void assertNotNull(String message, Object obj) {
		if (getLog().isDebugEnabled()) {
			getLog().debug(
					"\t(" //$NON-NLS-1$
					+	getLogType(obj)
					+	") " //$NON-NLS-1$
					+	message
					+	" = " //$NON-NLS-1$
					+	obj);
		}
		if (obj == null) {
			throw new AssertionError("assertNotNull: " + message); //$NON-NLS-1$
		}
	}
816750
function logResults(output) {
  var context = requisition.conversionContext;
  return output.convert('string', context).then(function(message) {
    if (output.error) {
      console.error(message);
    }
    else {
      console.log(message);
    }
    return output;
  });
}
276836
function AssertionError(actual, expected, phrase, base) {
  this.name = 'AssertionError';
  this.actual = actual;
  this.expected = expected;
  this.message = 'expected ' + objectDisplay(actual) + ' ' +
      phrase + ' ' +
    objectDisplay(expected);

  if (typeof actual === 'object' || typeof expected === 'object') {
    this.showDiff = true;
  }

  Error.captureStackTrace(this, base);
}
655992
function (setUp, tearDown, fn) {
    return function (test) {
        var context = {};
        if (tearDown) {
            var done = test.done;
            test.done = function (err) {
                try {
                    tearDown.call(context, function (err2) {
                        if (err && err2) {
                            test._assertion_list.push(
                                types.assertion({error: err})
                            );
                            return done(err2);
                        }
                        done(err || err2);
                    });
                }
                catch (e) {
                    done(e);
                }
            };
        }
        if (setUp) {
            setUp.call(context, function (err) {
                if (err) {
                    return test.done(err);
                }
                fn.call(context, test);
            });
        }
        else {
            fn.call(context, test);
        }
    };
}
896985
def qteUpdateLogSlot(self):
        

        # Fetch all log records that have arrived since the last
        # fetch() call and update the record counter.
        log = self.logHandler.fetch(start=self.qteLogCnt)
        self.qteLogCnt += len(log)

        # Return immediately if no log message is available (this case
        # should be impossible).
        if not len(log):
            return

        # Remove all duplicate entries and count their repetitions.
        log_pruned = []
        last_entry = log[0]
        num_rep = -1
        for cur_entry in log:
            # If the previous log message is identical to the current
            # one increase its repetition counter. If the two log
            # messages differ, add the last message to the output log
            # and reset the repetition counter.
            if last_entry.msg == cur_entry.msg:
                num_rep += 1
            else:
                log_pruned.append([last_entry, num_rep])
                num_rep = 0
                last_entry = cur_entry

        # The very last entry must be added by hand.
        log_pruned.append([cur_entry, num_rep])

        # Format the log entries (eg. color coding etc.)
        log_formatted = ""
        for cur_entry in log_pruned:
            log_formatted += self.qteFormatMessage(cur_entry[0], cur_entry[1])
            log_formatted + '\n'

        # Insert the formatted text all at once as calls to insertHtml
        # are expensive.
        self.qteText.insertHtml(log_formatted)
        self.qteMoveToEndOfBuffer()

        # If the log contained an error (or something else of interest
        # to the user) then switch to the messages buffer (ie. switch
        # to this very applet).
        if self.qteAutoActivate:
            self.qteAutoActivate = False
            self.qteMain.qteMakeAppletActive(self)
289203
function _log(message) {
        var level = message.level;
        if (level === "warning") {
            level = "warn";
        }
        var text = "ConsoleAgent: " + message.text;
        if (message.url) {
            text += " (url: " + message.url + ")";
        }
        if (message.stackTrace) {
            var callFrame = message.stackTrace[0];
            text += " in " + callFrame.functionName + ":" + callFrame.columnNumber;
        }
        console[level](text);
    }
511918
function assertHistoryType (history) {
  assertType("history", "object", history);
  assertType("history.listen", "function", history.listen);
  assertType("history.push", "function", history.push);
  assertType("history.replace", "function", history.replace);
  assertType("history.goBack", "function", history.goBack);
}
775858
def assert(truthy, label = nil, objects = nil)
      if (RMQ.app.development? || RMQ.app.test?) && !truthy
        label ||= 'Assert failed'
        if block_given? && !objects
          objects = yield
        end
        log_detailed label, objects: objects, skip_first_caller: true
      end
    end
457024
def QA_util_log_info(
        logs,
        ui_log=None,
        ui_progress=None,
        ui_progress_int_value=None,
):
    
    logging.warning(logs)

    # 给GUI使用，更新当前任务到日志和进度
    if ui_log is not None:
        if isinstance(logs, str):
            ui_log.emit(logs)
        if isinstance(logs, list):
            for iStr in logs:
                ui_log.emit(iStr)

    if ui_progress is not None and ui_progress_int_value is not None:
        ui_progress.emit(ui_progress_int_value)
384917
function internalAssert(condition, message) {
  if (!condition) {
    throw new AssertionError({
      message,
      actual: false,
      expected: true,
      operator: '=='
    });
  }
}
807820
void log(CallInfo callInfo, DeltaAssertion da) {
    if (isEnabled(Option.LOG_ASSERTIONS) ||
        (    ! da.passed() 
            && isEnabled(Option.LOG_ASSERTION_ERRORS) )) {
      log.write(callInfo, da);
    }
  }
886667
function log () {
  if (mocking) {
    cli.stdout += stripAnsi(concatArguments(arguments) + '\n')
  } else {
    console.log.apply(null, arguments)
  }
}
1282699
function( name, error, skip ) {
		var self = this,
			now = Date.now(),
			last = ! self.isAsync && self._lastTest ? self._lastTest : self.start,
			result = new AssertResult( name, self.nsPath, now - last, error, skip );

		self.tests[ name ] = result;
		self.list.push( result );
		self._logs.push( result );
		self._lastTest = now;
	}
227430
function (onDone) {

		// refuse any write or log creation
		l_logLock = true;

		//console.log(l_name + '::disposeAllLogs::waitClosing...');
		console.log(l_name + '::disposeAllLogs::closing ' + Object.keys(l_logs).length + ' log files...');

		l_onAllClosed = onDone;

		if (l_checkDoneBusy === false) {
			l_checkDoneBusy = true;
			l_checkLogClose();
		}
	}
154987
function( result, message ) {
            message = message || ( result ? "okay" : "failed, expected argument to be truthy, was: " +
            QUnit.dump.parse( result ) );
            if ( !!result ) {
                this.push( true, result, true, message );
            } else {
                this.test.pushFailure( message, null, result );
            }
        }
969182
function() {
      if (dest) {
        // Restore console.log to original and write the output
        console.log = consoleLog;

        if (!grunt.file.exists(dest)) {
            // Write only if our reporter ignored our `output` option
            grunt.file.write(dest, output.join('\n'));
        }
      }
      var stats = helpers.reduceStats(testStats);

      if (stats.failures === 0) {
        var okMsg = stats.tests + ' passed!' + ' (' + stats.duration + 's)';

        if (options.growlOnSuccess) {
          growl(okMsg, {
            image: asset('growl/ok.png'),
            title: okMsg,
            priority: 3
          });
        }

        grunt.log.ok(okMsg);

        // Async test pass
        done(true);

      } else {
        var failMsg = stats.failures + '/' + stats.tests + ' tests failed (' +
          stats.duration + 's)';

        // Show Growl notice, if avail
        growl(failMsg, {
          image: asset('growl/error.png'),
          title: failMsg,
          priority: 3
        });

        // Bail tests if bail option is true
        if (options.bail) {
          grunt.warn(failMsg);
        } else {
          grunt.log.error(failMsg);
        }

        // Async test fail
        done(false);
      }
    }