Calls {@link WebDriver#quit()} on the instance return by the provider.
343728
@Override
	public void dispose(final WebDriver source) {
		if (configurationProvider.get().getBoolean(WebConstants.WEBDRIVER_DONT_QUIT)) {
			return;
		}
		logger.info("Quitting WebDriver...");
		source.quit();
	}
42304
def do_quit(self, _: argparse.Namespace) -> bool:
        """"""
        self._should_quit = True
        return self._STOP_AND_EXIT
285375
def quit(self, *args, **kwargs):  # real signature unknown
        
        self.stop()
        self._stop = True
        self.msleep(2* int(1e3 / self.settings['update frequency']))
        super(Plant, self).quit(*args, **kwargs)
1244190
def close(self):
        """"""
        if not self.driver:
            return

        try:
            self.driver.implicitly_wait(1)
            self.driver.find_element_by_id('link-logout').click()
        except NoSuchElementException:
            pass

        self.driver.quit()
        self.driver = None
1025214
public void abort() {
    LOG.info("Aborting session driver");
    running = false;
    cmNotifier.clearCalls();
    cmNotifier.doShutdown();
    server.stop();
    incomingCallExecutor.interrupt();
  }
609944
def quit(self):
        
        self._send('QUIT\r\n')
        resp = self._read()
        if not resp.startswith('221'):
            logger.warning('Unexpected server response at QUIT: ' + resp)
        self._socket.close()
        self._socket = None
        self._recipients = []
        self.results = {}
1301733
public void quit() {
        try {
            this.keepOn = false;
            if (this.serverSocket != null && !this.serverSocket.isClosed()) {
                this.serverSocket.close();
                this.serverSocket = null;
            }
        } catch (final IOException e) {
            throw new RuntimeException(e);
        }
    }
422309
def do_quit(self, arg):
        
        if isinstance(self.stdin, RemoteSocket) and not self.is_debug_instance:
            return self.do_detach(arg)
        self._user_requested_quit = True
        self.set_quit()
        return 1
208816
@Override
	public void stop() {
		if (state.stop()){
			try{
				doStop();
				state.finishStopping();
			}catch(Exception e){
				state.failStopping();
				logger.warn("Failed to stop {}", this.getClass().getName(), e);
			}
		}

	}
540598
@Override
    public void stop() {
        synchronized (this.lifecycleMonitor) {
            if (isRunning()) {
                log.info("stop: Stopping ConnectorManager");
                try {
                    connector.stop();
                } finally {
                    running = false;
                }
            }
        }
    }
488717
@Override
    public void stop(){
        if (isStarted) {
            synchronized (this) {
                if (isStarted) {
                    if (getRegistrationService() instanceof Closable) {
                        ((Closable) getRegistrationService()).stop();
                    }
                    isStarted = false;
                }
            }
        }

    }
384503
public void stop() {
        Plugin plugin = getPlugin();
        if (plugin != null) {
            try {
                LOGGER.log(Level.FINE, "Stopping {0}", shortName);
                plugin.stop();
            } catch (Throwable t) {
                LOGGER.log(WARNING, "Failed to shut down " + shortName, t);
            }
        } else {
            LOGGER.log(Level.FINE, "Could not find Plugin instance to stop for {0}", shortName);
        }
        // Work around a bug in commons-logging.
        // See http://www.szegedi.org/articles/memleak.html
        LogFactory.release(classLoader);
    }
1223192
@Override
  public boolean stop()
  {
    if (! _lifecycle.toStopping())
      return false;

    log.finest(this + " stopping");

    closeConnections();

    destroy();

    return true;
  }
1043256
def quit(self):
        
        cmd = b"quit\r\n"
        self._misc_cmd([cmd], b'quit', True)
        self.close()
937549
public void onShutdown(){
        if (instance==null) return;
        try {
            this.camelContext.stop();
        }
        catch (Exception ex) {
            logger.severeException(ex.getMessage(), ex);
        }
    }
696662
private function quit()
    {
        $this->output->writeln('Stopping the process manager.');

        // this method is also called during startup when something crashed, so
        // make sure we don't operate on nulls.
        if ($this->controller) {
            @$this->controller->close();
        }
        if ($this->web) {
            @$this->web->close();
        }

        if ($this->loop) {
            $this->loop->stop();
        }

        unlink($this->pidfile);
        exit;
    }
516755
def quit(self, reason=''):
        
        with self.lock:
            self.keep_going = False
            self._quit(reason)
            self._socket.shutdown(self._m_socket.SHUT_RDWR)
            self._socket.close()