VncDriverFactory

abstract def capabilities(): Capabilities

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final val DAYS: java.util.concurrent.TimeUnit(DAYS)

final val HOURS: java.util.concurrent.TimeUnit(HOURS)

final val MICROSECONDS: java.util.concurrent.TimeUnit(MICROSECONDS)

final val MILLISECONDS: java.util.concurrent.TimeUnit(MILLISECONDS)

final val MINUTES: java.util.concurrent.TimeUnit(MINUTES)

final val NANOSECONDS: java.util.concurrent.TimeUnit(NANOSECONDS)

final val SECONDS: java.util.concurrent.TimeUnit(SECONDS)

final def asInstanceOf[T0]: T0

def awaitVncServer(): V

def clone(): AnyRef

def compatible: Boolean

val connectionTimeout: FiniteDuration

def createRealWebDriver(): WebDriver

def createWebDriver(executor: HttpCommandExecutor, capabilities: Capabilities): WebDriver

def createWebDriver(): WebDriver

def debug(msg: ⇒ String, throwable: ⇒ Throwable): Unit

def debug(msg: ⇒ String): Unit

implicit def doubleMult(d: Double): DoubleMult

implicit def durationDouble(n: Double): DurationConversions

implicit def durationInt(n: Int): DurationConversions

implicit def durationLong(n: Long): DurationConversions

implicit def durationToPair(d: Duration): (Long, TimeUnit)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(msg: ⇒ String, throwable: ⇒ Throwable): Unit

def error(msg: ⇒ String): Unit

def finalize(): Unit

final val fromNow: scala.concurrent.duration.fromNow.type

final def getClass(): Class[_]

def hashCode(): Int

def info(msg: ⇒ String, throwable: ⇒ Throwable): Unit

def info(msg: ⇒ String): Unit

implicit def intMult(i: Int): IntMult

final def isInstanceOf[T0]: Boolean

val limit: Limit

how many instances should be started

def log(level: LogLevel, msg: ⇒ String, throwable: ⇒ Throwable): Unit

def log(level: LogLevel, msg: ⇒ String): Unit

implicit def longMult(l: Long): LongMult

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def pairIntToDuration(p: (Int, TimeUnit)): Duration

implicit def pairLongToDuration(p: (Long, TimeUnit)): FiniteDuration

def runTest[T](testName: String, fn: ⇒ T): T

def runTests[T](fn: ⇒ T): T

val socketTimeout: FiniteDuration

final val span: scala.concurrent.duration.span.type

final def synchronized[T0](arg0: ⇒ T0): T0

def takeScreenshot(testName: String, webDriver: WebDriver with TakesScreenshot): Unit

def timeouts: Set[PatienceConfig]

def toString(): String

def trace(msg: ⇒ String, throwable: ⇒ Throwable): Unit

def trace(msg: ⇒ String): Unit

val traced: Boolean

def url(): String

val vnc: Boolean

def vncServerDuration(): scala.concurrent.duration.FiniteDuration

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def waitFor[T](description: String, config: PatienceConfig)(fun: ⇒ T): T

def waitFor[T](description: String, timeout: FiniteDuration, interval: FiniteDuration)(fun: ⇒ T): T

def warn(msg: ⇒ String, throwable: ⇒ Throwable): Unit

def warn(msg: ⇒ String): Unit

def webDriver: WebDriver

def withPatience[T](map: PatienceMap)(fun: ⇒ T): T

def withPatience[T](config: (PatienceConfig, PatienceConfig)*)(fun: ⇒ T): T