Waits up to the provided wait time for a prompt is present on the page. This information will be
logged and recorded, with a screenshot for traceability and added
debugging support.

@param seconds the number of seconds to wait
972718
public void promptPresent(double seconds) {
        try {
            double timeTook = popup(seconds);
            checkPromptPresent(seconds, timeTook);
        } catch (TimeoutException e) {
            checkPromptPresent(seconds, seconds);
        }
    }
909141
@Step(".*wait (?:for )?([0-9]*) seconds?.*")
    @Documentation(order = 10, description = "Wait for a number of seconds", example = "And I wait for 6 seconds")
    public void waitForSeconds(int seconds) {
        try {
            Thread.sleep(seconds * 1000);
        } catch (InterruptedException e) {
            log.error("Thread interrupted while sleeping", e);
        }
    }
1153990
@Override
    public boolean setTransactionTimeout(final int _seconds)
    {
        if (VFSStoreResource.LOG.isDebugEnabled()) {
            VFSStoreResource.LOG.debug("setTransactionTimeout (seconds = " + _seconds + ")");
        }
        return true;
    }
1083437
public function setReceiveMessageWaitTimeSeconds(int $seconds = null): void
    {
        if (null == $seconds) {
            unset($this->attributes['ReceiveMessageWaitTimeSeconds']);
        } else {
            $this->attributes['ReceiveMessageWaitTimeSeconds'] = $seconds;
        }
    }
103500
@Override
	public void go() {
		logger.info("Waiting {} seconds for {}...", timeout, element);
		WebDriverWait waiting = new WebDriverWait(getWebDriver(), timeout);
		try {
			waiting.until(ExpectedConditions.presenceOfElementLocated(element));
		} catch (NullPointerException e) {
			fail(String.format("Element %s did not appear within %d seconds.", element, timeout), e);
		}
	}
181206
public function waitForLink($link, $seconds = null)
    {
        $message = $this->formatTimeOutMessage('Waited %s seconds for link', $link);

        return $this->waitUsing($seconds, 100, function () use ($link) {
            return $this->seeLink($link);
        }, $message);
    }
1037423
def pause(self, seconds):
        
        if self._driver.w3c:
            self.w3c_actions.pointer_action.pause(seconds)
            self.w3c_actions.key_action.pause(seconds)
        else:
            self._actions.append(lambda: time.sleep(seconds))
        return self
903867
@Override
	public void setTransactionTimeout(int seconds) throws TransactionManagementException {
		logger.entering(CLASSNAME, "setTransactionTimeout", seconds);
		try {
			userTran.setTransactionTimeout(seconds);
		} catch (SystemException e) {
			throw new TransactionManagementException(e);
		}
		logger.exiting(CLASSNAME, "setTransactionTimeout");
	}
1234168
public boolean waitFor(Condition condition, long timeout, TimeUnit unit) {
        boolean    intr=false;
        final long timeout_ns=TimeUnit.NANOSECONDS.convert(timeout, unit);
        lock.lock();
        try {
            for(long wait_time=timeout_ns, start=System.nanoTime(); wait_time > 0 && !condition.isMet();) {
                try {
                    wait_time=cond.awaitNanos(wait_time);
                }
                catch(InterruptedException e) {
                    wait_time=timeout_ns - (System.nanoTime() - start);
                    intr=true;
                }
            }
            return condition.isMet();
        }
        finally {
            lock.unlock();
            if(intr) Thread.currentThread().interrupt();
        }
    }
1296701
@Override
    public void await() throws InterruptedException {
        queueLock.lock();
        try {
            while(test()) {
                condition.await();
            }
        }
        finally {
            queueLock.unlock();
        }
    }
146313
public boolean setTransactionTimeout(final int seconds) throws XAException {

        final String methodName = "recover";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName, seconds);
        }

        final boolean result = _siXaResource.setTransactionTimeout(seconds);

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName, Boolean.valueOf(result));
        }
        return result;
    }
525572
def wait_for(self, text, seconds):
        
        found = False
        stream = self.stream
        start_time = time.time()
        while not found:
            if time.time() - start_time > seconds:
                break
            stream.data_available.wait(0.5)
            stream.data_unoccupied.clear()
            while stream.data:
                line = stream.data.pop(0)
                value = line.getvalue()
                if text in value:
                    found = True
                self.lines.append(value)
                stream.data_available.clear()
                stream.data_unoccupied.set()
                if time.time() - start_time > seconds:
                    break
        return found
145379
public void promptNotPresent(double seconds) {
        try {
            double timeTook = noPopup(seconds);
            checkPromptNotPresent(seconds, timeTook);
        } catch (TimeoutException e) {
            checkPromptNotPresent(seconds, seconds);
        }
    }
1210681
@Override
    public void _waitForNonStaleResults(Duration waitTimeout) {
        theWaitForNonStaleResults = true;
        timeout = ObjectUtils.firstNonNull(waitTimeout, getDefaultTimeout());
    }
1043730
private static void wait(Object lock, int timeout)
  {
    try {
      lock.wait(timeout);
    }
    catch(InterruptedException unused) {
      Thread.currentThread().interrupt();
    }
  }
1303282
public void setExpires(int seconds) {
		try {
			ExpiresHeader expiresHeader =
				SipFactoryImpl.headerFactory.createExpiresHeader(seconds);
			expiresHeader.setExpires(seconds);
			this.message.setExpires(expiresHeader);
		} catch (Exception e) {
			throw new IllegalArgumentException("Error setting expiration header!", e);
		}
	}
1140405
def timeout(self, seconds=None):
        
        if seconds is None:
            self.socketIO.wait()
        else:
            self.socketIO.wait(seconds=seconds)