report a successful execution of a process
@param {string} message
 eslint-disable-next-line no-unused-vars
433018
function reportSucceededProcess(_message) {
    const emoji = require('node-emoji').emoji;
    console.log('');
    console.log(emoji.tada, emoji.tada, emoji.tada);
}
1228700
function write(message, handle) {
		var result = false
		var err
		var args = Array.prototype.slice.call(arguments)
		var cb = typeof args[args.length - 1] === 'function' ? args.pop() : null
		if (args.length > 1 && typeof handle === 'string') err = new Error('write handle argument cannot be string')
		else if (!self.writable) err = new Error('ipc not available')
		else {
			try {
				result = process.send.apply(process, args)
			} catch (e) {
				err = e
			}
			if (!err) self.emit('drain')
		}
		if (err) internalDestroy(cb, [err])
		else if (cb) {
			var cbArgs = []
			if (err) cbArgs.push(err)
			cb.apply(this, cbArgs)
		}
		return result
	}
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);
    }
1182329
function logMessage(message)
    {
        var repeatCount = 1;
        if (message == WebInspector.log.lastMessage)
            repeatCount = WebInspector.log.repeatCount + 1;

        WebInspector.log.lastMessage = message;
        WebInspector.log.repeatCount = repeatCount;

        // ConsoleMessage expects a proxy object
        message = new WebInspector.RemoteObject.fromPrimitiveValue(message);

        // post the message
        var msg = new WebInspector.ConsoleMessage(
            WebInspector.ConsoleMessage.MessageSource.Other,
            WebInspector.ConsoleMessage.MessageType.Log,
            messageLevel || WebInspector.ConsoleMessage.MessageLevel.Debug,
            -1,
            null,
            repeatCount,
            null,
            [message],
            null);

        self.console.addMessage(msg);
    }
34262
function logMessage (message, data) {
  if (!message) return
  render(message, data, (err, res) => {
    if (err) {
      console.error('\n   Error when rendering template complete message: ' + err.message.trim())
    }
    else {
      console.log('\n' + res.split(/\r?\n/g).map(line => '   ' + line).join('\n'))
    }
  })
}
1041772
function logDebug(message) {
  if (!debug) {
    return;
  }

  if (!enabled) return;
  console.log(os.EOL + chalk.cyan(message));
}
1212127
function (message) {
    var that = this;
    that._traceLogEventsCount();
    that.mc.trigger(TypeMsg$2.OnCreateError, message);
  }
832966
function(result, onKill) {
  /** @return {boolean} Whether this command is still running. */
  this.isRunning = function() {
    return result.isPending();
  };

  /**
   * @return {!promise.Promise.<!Result>} A promise for the result of this
   *     command.
   */
  this.result = function() {
    return result;
  };

  /**
   * Sends a signal to the underlying process.
   * @param {string=} opt_signal The signal to send; defaults to
   *     {@code SIGTERM}.
   */
  this.kill = function(opt_signal) {
    onKill(opt_signal || 'SIGTERM');
  };
}
606275
function(a, msg) {
		a = !!a;
		var details = {
			result: a,
			message: msg
		};
		msg = escapeInnerText(msg);
		runLoggingCallbacks( 'log', QUnit, details );
		config.current.assertions.push({
			result: a,
			message: msg
		});
	}
657322
function(message) {
            $log
              .append( settings.templates.message(message) )
            ;
            module.message.scroll.test();
            $.proxy(settings.onMessage, $log.children().last() )();
          }
362378
async function execAndReport({ cmd, name }) {
  try {
    const {
      failed,
      // code,
      // timedOut,
      stdout,
      stderr,
      // message,
    } = await execa.shell(cmd);
    process.stdout.write(stdout);
    process.stderr.write(stderr);
    await setCheckRun({
      name,
      status: 'completed',
      conclusion: 'success',
      output: {
        title: name,
        summary: `Ran ${cmd}`,
      },
    });
    return failed;
  } catch (err) {
    const {
      failed,
      // code,
      // timedOut,
      stdout,
      stderr,
      message,
    } = err;
    process.stdout.write(stdout);
    process.stderr.write(stderr);
    await setCheckRun({
      name,
      status: 'completed',
      conclusion: 'failure',
      output: {
        title: name,
        summary: `Ran ${cmd}`,
        text: `
<pre><code>
${message}
</code></pre>
        `.trim(),
      },
    });

    return failed;
  }
}
740420
def on_message(self, message):
        """"""
        json_rpc = json.loads(message)
        logging.log(logging.DEBUG, json_rpc)

        if self.pool is None:
            self.pool = multiprocessing.Pool(processes=args.workers)

        # Spawn a process to protect the server against segfaults
        async = self.pool.apply_async(_worker_process, [json_rpc])
        try:
            result = async.get(timeout=args.timeout)
            error = 0
        except multiprocessing.TimeoutError:
            result = ("File format conversion timed out! This is due "
                      "either to a large input file or a segmentation "
                      "fault in the underlying open babel library.")
            error = 1
            self.pool.terminate()
            self.pool = multiprocessing.Pool(processes=args.workers)
        except Exception:
            result = traceback.format_exc()
            error = 1
        logging.log(logging.DEBUG, result)

        self.write_message(json.dumps({'result': result, 'error': error,
                                       'id': json_rpc['id']},
                                      separators=(',', ':')))
217378
function exit (status, ...messages) {
  if (messages) {
    messages.forEach(message => console.log(message))
  }

  process.exit(status)
}
957691
function log (message) {
  if (!global.testing && !global.isModuleUse) {
    console.log(message)
  } else {
    debug(message)
  }
}
982142
def process_send_message_outcome(line)
      outcome = SendMessageOutcomeMessage.parse line
      return unless outcome

      @mutex.synchronize do
        @callbacks[:on_message_result].each do |callback|
          callback.call outcome.sequence, outcome.numbers, outcome.error
        end
      end

      true
    end
1052195
function finishMessage() {
    if (parser.tag_ < Parser.PADDING_TAG_) {
      var message = {};
      message[parser.tag_] = parser.messageBuffer_;
      parser.result_.push(message);
    }
    parser.state_ = Parser.State_.INIT;
  }
216157
function handleExecReturn(result) {
    console.log('Exec complete.');
    console.log(result[0]);
    if (result[1] && result[1] !== '') {
        console.error(result[1]);
    }
    return result;
}