StreamTest

final def !=(arg0: Any): Boolean

def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def !==(right: Null): TripleEqualsInvocation[Null]

def !==[T](right: T): TripleEqualsInvocation[T]

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def ===(right: Null): TripleEqualsInvocation[Null]

def ===[T](right: T): TripleEqualsInvocation[T]

object AddData

Adds the given data to the stream.

object Assert

object AssertOnQuery

object AwaitEpoch

object AwaitTerminationTester

object CheckAnswer

Checks to make sure that the current data stored in the sink matches the expectedAnswer.

object CheckLastBatch

Checks to make sure that the current data stored in the sink matches the expectedAnswer.

object CheckNewAnswer

object Execute

Execute arbitrary code

object IncrementEpoch

object MultiAddData

Adds data to multiple memory streams such that all the data will be made visible in the same batch.

object StopStream extends StreamAction with StreamMustBeRunning with Product with Serializable

Stops the stream.

def afterAll(): Unit

def alert: Alerter

final def asInstanceOf[T0]: T0

macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertCached(query: Dataset[_], numCachedTables: Int = 1): Unit

Asserts that a given Dataset will be executed using the given number of cached results.

macro def assertCompiles(code: String)(implicit pos: Position): Assertion

macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

def assertEmptyMissingInput(query: Dataset[_]): Unit

Asserts that a given Dataset does not have missing inputs in all the analyzed plans.

def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): Assertion

macro def assertTypeError(code: String)(implicit pos: Position): Assertion

val assertionsHelper: AssertionsHelper

macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

def beforeAll(): Unit

def canEvaluate(expr: Expression, plan: LogicalPlan): Boolean

def canEvaluateWithinJoin(expr: Expression): Boolean

def cancel(cause: Throwable)(implicit pos: Position): Nothing

def cancel(message: String, cause: Throwable)(implicit pos: Position): Nothing

def cancel(message: String)(implicit pos: Position): Nothing

def cancel()(implicit pos: Position): Nothing

def cancelAfter[T](timeout: Span)(fun: ⇒ T)(implicit signaler: Signaler, prettifier: Prettifier, pos: Position, timed: Timed[T]): T

def checkAggregatesWithTol(dataFrame: DataFrame, expectedAnswer: Row, absTol: Double): Unit

def checkAggregatesWithTol(dataFrame: DataFrame, expectedAnswer: Seq[Row], absTol: Double): Unit

Runs the plan and makes sure the answer is within absTol of the expected result.

def checkAnswer(df: ⇒ DataFrame, expectedAnswer: DataFrame): Unit

def checkAnswer(df: ⇒ DataFrame, expectedAnswer: Row): Unit

def checkAnswer(df: ⇒ DataFrame, expectedAnswer: Seq[Row]): Unit

Runs the plan and makes sure the answer matches the expected result.

def checkDataset[T](ds: ⇒ Dataset[T], expectedAnswer: T*): Unit

Evaluates a dataset to make sure that the result of calling collect matches the given expected answer.

def checkDatasetUnorderly[T](ds: ⇒ Dataset[T], expectedAnswer: T*)(implicit arg0: Ordering[T]): Unit

Evaluates a dataset to make sure that the result of calling collect matches the given expected answer, after sort.

def checkKeywordsExist(df: DataFrame, keywords: String*): Unit

Runs the plan and makes sure the answer contains all of the keywords.

def checkKeywordsNotExist(df: DataFrame, keywords: String*): Unit

Runs the plan and makes sure the answer does NOT contain any of the keywords.

def clone(): AnyRef

def compareExpressions(e1: Expression, e2: Expression): Unit

Fails the test if the two expressions do not match

def compareJoinOrder(plan1: LogicalPlan, plan2: LogicalPlan): Unit

Fails the test if the join order in the two plans do not match

def comparePlans(plan1: LogicalPlan, plan2: LogicalPlan, checkAnalysis: Boolean = true): Unit

Fails the test if the two plans do not match

def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T]

implicit def convertToEqualizer[T](left: T): Equalizer[T]

def defaultEquality[A]: Equality[A]

implicit val defaultSignaler: Signaler

val defaultTrigger: Trigger

val defaultUseV2Sink: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def execute(testName: String, configMap: ConfigMap, color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit

def expectedTestCount(filter: Filter): Int

def fail(cause: Throwable)(implicit pos: Position): Nothing

def fail(message: String, cause: Throwable)(implicit pos: Position): Nothing

def fail(message: String)(implicit pos: Position): Nothing

def fail()(implicit pos: Position): Nothing

def failAfter[T](timeout: Span)(fun: ⇒ T)(implicit signaler: Signaler, prettifier: Prettifier, pos: Position, timed: Timed[T]): T

def finalize(): Unit

final def getClass(): Class[_]

final def getTestResourceFile(file: String): File

final def getTestResourcePath(file: String): String

def hashCode(): Int

def ignore(testName: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

def info: Informer

def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean

def initializeLogIfNecessary(isInterpreter: Boolean): Unit

def intercept[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): T

val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

def log: Logger

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

def logDebug(msg: ⇒ String): Unit

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

def logError(msg: ⇒ String): Unit

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

def logInfo(msg: ⇒ String): Unit

def logName: String

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

def logTrace(msg: ⇒ String): Unit

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

def logWarning(msg: ⇒ String): Unit

def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

def markup: Documenter

final def ne(arg0: AnyRef): Boolean

def nestedSuites: IndexedSeq[Suite]

def normalizeExprIds(plan: LogicalPlan): LogicalPlan

Since attribute references are given globally unique ids during analysis, we must normalize them to check if two different queries are identical.

def normalizePlan(plan: LogicalPlan): LogicalPlan

Normalizes plans: - Filter the filter conditions that appear in a plan.

def note: Notifier

final def notify(): Unit

final def notifyAll(): Unit

def pending: Assertion with PendingStatement

def pendingUntilFixed(f: ⇒ Unit)(implicit pos: Position): Assertion with PendingStatement

final def registerIgnoredTest(testText: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

final def registerTest(testText: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

def replaceAlias(condition: Expression, aliases: AttributeMap[Expression]): Expression

def rerunner: Option[String]

def run(testName: Option[String], args: Args): Status

def runNestedSuites(args: Args): Status

def runStressTest(ds: Dataset[Int], prepareActions: Seq[StreamAction], addData: (Seq[Int], Boolean) ⇒ StreamAction, iterations: Int): Unit

Creates a stress test that randomly starts/stops/adds data/checks the result.

def runStressTest(ds: Dataset[Int], addData: (Seq[Int]) ⇒ StreamAction, iterations: Int = 100): Unit

Creates a stress test that randomly starts/stops/adds data/checks the result.

def runTest(testName: String, args: Args): Status

def runTests(testName: Option[String], args: Args): Status

lazy val spark: SparkSession

def splitConjunctivePredicates(condition: Expression): Seq[Expression]

def splitDisjunctivePredicates(condition: Expression): Seq[Expression]

val streamingTimeout: Span

How long to wait for an active stream to catch up when checking a result.

final val styleName: String

final val succeed: Assertion

def suiteId: String

def suiteName: String

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

def tags: Map[String, Set[String]]

def test(testName: String, testTags: Tag*)(testFun: ⇒ Any)(implicit pos: Position): Unit

def testDataFor(testName: String, theConfigMap: ConfigMap): TestData

def testNames: Set[String]

def testStream(_stream: Dataset[_], outputMode: OutputMode = OutputMode.Append, useV2Sink: Boolean = defaultUseV2Sink)(actions: StreamAction*): Unit

Executes the specified actions on the given streaming DataFrame and provides helpful error messages in the case of failures or incorrect answers.

def testsFor(unit: Unit): Unit

def toString(): String

def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withClue[T](clue: Any)(fun: ⇒ T): T

final def withFixture(test: NoArgTest): Outcome

Log the suite name and the test name before and after each test.

def withSQLConf(pairs: (String, String)*)(f: ⇒ Unit): Unit

Sets all SQL configurations specified in pairs, calls f, and then restores all SQL configurations.

final def execute: Unit

def trap[T](f: ⇒ T): Throwable