def finish_case(kase)
end
324771
def finish_suite(suite)
      total      = suite.count_tests
      passes     = suite.count_passes
      assertions = suite.count_assertions
      failures   = suite.count_failures
      errors     = suite.count_errors
      skips      = suite.count_skips

      bar = '=' * 78
      # @FIXME: Remove this, since Colorize already take care of colorize?
      if colorize?
        bar = if pass == total then Colorize.green(bar)
              else Colorize.red(bar) end
      end

      # @FIXME: Should we add suite.runtime, instead if this lame time calculations?
      tally = [total, assertions, (Time.new - @time)]

      io.puts bar
      io.puts "  pass: %d,  fail: %d,  error: %d, skip: %d" % [passes, failures, errors, skips]
      io.puts "  total: %d tests with %d assertions in %f seconds" % tally
      io.puts bar
    end
725059
def end_entity(self):
        
        if self.stack[-1] == 'block' and self.dirty:
            self.escpos._raw('\n')
            self.dirty = False
        if len(self.stack) > 1:
            self.stack = self.stack[:-1]
289271
def finalize!
      return if finalized?

      modifiers.each do |modifier|
        modifier.type.each_with_index do |type, i|
          case type
          when :endian, :signedness, :precision, :type, :string_type
            tags[type] = modifier.value[i]
          when :size
            tags[:size] = modifier.value[i] unless tags[:size]
          else
            raise UnknownModifierError,
              "Unknown modifier: #{type}"
          end
        end
      end

      @finalized = true
      cache_string
    end
665716
def end(self, value: typing.Union[float, typing.Tuple[float, float]]) -> None:
        """"""
        ...
42402
def finish(status, stdout, stderr, passed, pending, failed)
      RRRSpec.redis.hmset(
        key,
        'finished_at', Time.zone.now.to_s,
        'status', status,
        'stdout', stdout,
        'stderr', stderr,
        'passed', passed,
        'pending', pending,
        'failed', failed
      )
    end
1065772
protected void finish() {
        Reporter reporter = this.reporterThreadLocal.get();
        assertEquals("Detailed results found at: " + reporter.getFileName(), "0 errors",
                Integer.toString(reporter.getFails()) + ERRORS_CHECK);
    }
682368
public void finish() {
        if (logListenerCommandShell != null) {
            logListenerCommandShell.cancel();
        }
        for (ScreenshotProcessor screenshotProcessor : processors) {
            screenshotProcessor.finish();
        }
    }
415352
def _handle_end_way(self):
        
        self._result.append(Way(result=self._result, **self._curr))
        self._curr = {}
37972
private function endProcess()
    {
        $arguments = $this->resolveProcessArgs();
        $name = sha1(serialize($arguments));
        if ($this->background->hasProcess($name)) {
            $this->background->getProcess($name)->stop();
            $this->background->removeProcess($name);
        }
    }
316042
function finish(cb) {
      clearTimeout(timer);
      timer = null;
      return subscriber.unsubscribe(
        'message/' + id + '/' + getIndex, cb);
    }
266351
def _finish(self):
        
        if self._process.returncode is None:
            self._process.stdin.flush()
            self._process.stdin.close()
            self._process.wait()
            self.closed = True
50778
def end(self):
        
        self._process.shutdown()
        self._roasting = False
        self._roast['date'] = now_date(str=True)
1138913
private function _processSwitchCase() {
		// If we already are in a "case", we remove it from the stack
		if ($this->statementStack->getCurrentStackItem()->type === StatementItem::TYPE_CASE || $this->statementStack->getCurrentStackItem()->type === StatementItem::TYPE_DEFAULT) {

			// Test if the previous case had a break
			$this->_checkSwitchCaseNeedBreak();

			$this->statementStack->pop();
		}

		// If the case arrives after the default
		$this->_checkSwitchDefaultOrder();

		// We store the control statement in the stack
		$stackitem = new StatementItem();
		$stackitem->line = $this->lineNumber;
		$stackitem->type = "CASE";
		$stackitem->name = "case";
		$this->statementStack->push($stackitem);

		// For this case
		$this->statementStack->getCurrentStackItem()->caseHasBreak = false;
		$this->statementStack->getCurrentStackItem()->caseStartLine = $this->lineNumber;

		// Check if the case is empty
		// We detect if the next valid token after ":" is another T_CASE
		$startPos = $this->tokenizer->findNextStringPosition(":", $this->tokenizer->getCurrentPosition());
		$this->statementStack->getCurrentStackItem()->caseIsEmpty = $this->tokenizer->checkNextValidToken(T_CASE, false, $startPos + 1) || $this->tokenizer->checkNextValidToken(T_DEFAULT, false, $startPos + 1);
	}
1077628
private static void finish() {

		if (progress.getMax() != null) {

			StringBuilder output = new StringBuilder();
			output.append("\nTile Generation: ").append(progress.getProgress())
					.append(" of ").append(progress.getMax());

			if (geoPackage != null) {
				try {
					GeoPackageTextOutput textOutput = new GeoPackageTextOutput(
							geoPackage);
					output.append("\n\n");
					output.append(textOutput.header());
					output.append("\n\n");
					output.append(textOutput.tileTable(tileTable));

				} finally {
					geoPackage.close();
				}
			}

			System.out.println(output.toString());
		}
	}
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;
  }
758429
def finish_off(self):
        """"""
        self.keywords = {} # map from keyword strings to arc labels
        self.tokens = {}   # map from numeric token values to arc labels
        for ilabel, (type, value) in enumerate(self.labels):
            if type == token.NAME and value is not None:
                self.keywords[value] = ilabel
            elif value is None:
                self.tokens[type] = ilabel
1182109
def final():
    """"""
    if DEBUG:
        print("Cleaning up message queues", queues)
        print("Cleaning up processes", procs)
    for q in queues:
        q.remove()
    for proc in procs:
        proc.terminate()