All tests have been run.
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);
      }
    }
973931
function () {
                this.$Test._endTest.call(this);
                this.checkExpectedEventListEnd();
                this.resetClassOverrides();
                this.assertLogsEmpty(false, false);
                this._assertCount = 0;
                this._currentTestName = '';

                this._isFinished = true;

                this.$raiseEvent({
                    name : "end",
                    testObject : this,
                    testClass : this.$classpath,
                    nbrOfAsserts : this._totalAssertCount
                });
            }
664922
def is_complete(self):
        
        return all(
            [node.route_allocation() is not None for node in list(self._nodes.values()) if node != self._problem.depot()]
        )
393347
def display_all(self):
        
        print( ("total elapse %0.6f seconds, last elapse %0.6f seconds, "
                "took %s times measurement") % (
                    self.total_elapse, self.elapse, len(self.records)))
243112
def complete_all_trajectories(self):
    """"""
    for index in range(self.batch_size):
      trajectory = self._trajectories[index]
      assert trajectory.is_active
      self._complete_trajectory(trajectory, index)
72312
def run_all
      passed, failed_examples, passed_examples = Runner.run(['spec'], options.merge({ :message => 'Run all specs'}))

      self.rerun_specs = failed_examples
      self.last_run_passed = passed

      throw :task_has_failed unless passed
    end
245988
public function results()
    {
        $out = [''];

        $total    = $this->runner->totalCount;
        $passed   = count($this->runner->passed);
        $failures = count($this->runner->failures);
        $errors   = count($this->runner->errors);
        $skipped  = count($this->runner->skipped);

        $results   = [];
        $results[] = $this->green(self::INDICATOR).' Passes    '.$passed;
        $results[] = $this->red(self::INDICATOR).' Failures  '.$failures;
        $results[] = $this->yellow(self::INDICATOR).' Errors    '.$errors;
        $results[] = $this->magenta(self::INDICATOR).' Skipped   '.$skipped;

        $box = new Box($results, [
            'borderColor' => self::YELLOW,
            'paddingX'    => 1,
        ]);
        $box->setTitle('Results');
        $out[] = $box;

        foreach ($this->runner->failures as $test) {
            $out[] = '';
            $out[] = $this->red('FAILED - '.$test->name);
            $out[] = $test->getFailureMessage();
        }

        foreach ($this->runner->errors as $test) {
            $out[] = '';
            $out[] = $this->yellow('ERROR - '.$test->name);
            $out[] = $test->getErrorMessage();
        }

        $count = $this->green("$passed / $total");
        if ($passed !== $total) {
            $count = $this->red("$passed / $total");
        }
        $out[] = '';
        $out[] = "$count tests passed successfully.";

        echo $this->render(implode("\n", $out));

        if ($this->runner->options->coverage->enable === true) {
            echo "\n";
            echo $this->gray->render('Calculating Coverage...');
            echo "\n";

            $this->runner->coverage->calculate();
            echo $this->runner->coverage->output();
        }

        exit((int) ($passed !== $total));
    }
346268
def coverage(self,
                 container: Container,
                 tests: Optional[Iterable[TestCase]] = None,
                 *,
                 instrument: bool = True
                 ) -> TestSuiteCoverage:
        
        extractor = self.coverage_extractor(container)
        if tests is None:
            bugs = self.__installation.bugs
            bug = bugs[container.bug]
            tests = bug.tests
        return extractor.run(tests, instrument=instrument)
1192140
protected void runSelected() {
    List<TestDescription> selectedTests = getSelectedTests();
    if (selectedTests != null) {
      List<TestDescription> selectedTestsIncludedLeafs = new ArrayList<>();
      for (TestDescription desc : selectedTests) {
        includeAllLeafs(desc, selectedTestsIncludedLeafs);
      }
      // run all tests in selectedTestsIncludedLeafs
      run(selectedTestsIncludedLeafs);
    }
  }
983491
public function verifyAll()
    {
        $arguments = $this->getBrokerHttpClient()->getAllConsumerUrls($this->config->getProviderName());

        $arguments = \array_merge($arguments, $this->getArguments());

        $this->verifyAction($arguments);
    }
310652
public static function runAll()
    {
        self::checkSapiEnv();
        self::init();
        self::parseCommand();
        self::daemonize();
        self::initWorkers();
        self::installSignal();
        self::saveMasterPid();
        self::forkWorkers();
        self::displayUI();
        self::resetStd();
        self::monitorWorkers();
    }
1007378
async def runall(corogen):
    
    results = []
    for c in corogen:
        result = await c
        results.append(result)
    return results
1236726
public function all()
    {
        $this->forAuthorization();
        $this->forAccessTokens();
        $this->forTransientTokens();
        $this->forClients();
        $this->forPersonalAccessTokens();
    }
238928
def run_all
      return pending_result unless test_paths?
      Guard::UI.info("Resetting", reset: true)
      do_run{ @runner.run(@test_paths) }
    end
1040159
def complete(self):
        
        # Boolean to store the completeness of the analyses
        allcomplete = True
        # Clear the list of samples that still require more sequence data
        self.incomplete = list()
        for sample in self.runmetadata.samples:
            if sample.general.bestassemblyfile != 'NA':
                try:
                    # If the sample has been tagged as incomplete, only add it to the complete metadata list if the
                    # pipeline is on its final iteration
                    if sample.general.incomplete:
                        if self.final:
                            self.completemetadata.append(sample)
                        else:
                            sample.general.complete = False
                            allcomplete = False
                            self.incomplete.append(sample.name)
                except AttributeError:
                    sample.general.complete = True
                    self.completemetadata.append(sample)
            else:
                if self.final:
                    self.completemetadata.append(sample)
                else:
                    sample.general.complete = False
                    allcomplete = False
                    self.incomplete.append(sample.name)
        # If all the samples are complete, set the global variable for run completeness to True
        if allcomplete:
            self.analysescomplete = True
19300
def complete(self):
        
        if self.scan_limit is not None and self.scan_limit == 0:
            return True
        if self.item_limit is not None and self.item_limit == 0:
            return True
        return False
1036885
function all (data) {
    if (array(data)) {
      return testArray(data, false);
    }

    assert.object(data);

    return testObject(data, false);
  }