PageBrowser

implicit abstract def webDriver: WebDriver

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

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)

def activePage: Option[AtChecker]

def activePage_=(page: Option[AtChecker]): Unit

Marks the given page as active.

def activePage_=(page: AtChecker): Unit

Marks the given page as active.

final def asInstanceOf[T0]: T0

def at[P <: AtChecker](pages: Function0[_ <: P]*): P

def at[P <: AtChecker](page: ⇒ P): P

Asserts that the browser is at the given page and stores the page as the active one.

def atCancelTestPage(unexpectedPage: AtChecker): Nothing

def atFailTestPage(unexpectedPage: AtChecker): Nothing

def atWaitPage(unexpectedPage: AtChecker): Nothing

def clearActivePage(): Unit

Marks the active page as inactive.

def clone(): AnyRef

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 failOnInactivePage(pageObject: PageObject): Unit

Abort the test when the given PageObject is not the active one.

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

def invalidateActivePage(): Unit

Marks the active page as inactive.

def invalidatePage(pageObject: PageObject): Unit

Marks the given page as inactive.

def isActivePage(page: AtChecker): Boolean

returns true if the given page is the active

def isAt(page: ⇒ AtChecker): Boolean

Check if the given page is the active one.

final def isInstanceOf[T0]: Boolean

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

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

implicit def longMult(l: Long): LongMult

def ndcKey: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyActivated(): Unit

final def notifyAll(): Unit

final def notifyDeactivated(): Unit

def onActivated(page: AtChecker): Unit

def onDeactivated(page: AtChecker): Unit

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

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

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

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

def to[P <: UrlPage with AtChecker](page: ⇒ P): P

navigates and activates the given page.

def toString(): String

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

def trace(msg: ⇒ String): Unit

def updateNdc(): Unit

def via[P <: UrlPage](page: ⇒ P): P

Starts navigation to the given page.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def waitFor[T](duration: FiniteDuration)(fun: ⇒ T): T

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

def warn(msg: ⇒ String): Unit

def withActivePage[S](page: AtChecker)(thunk: ⇒ S): S

Executes the given code while setting page as the active page.

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

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