Class DeprecatedTokenizerTest

Return a negative integer, zero, or a positive integer if this object is less than, equal to, or greater than the specified object:

this < that   =>  <0
this == that  =>  0
this > that   =>  >0
Copy

This method may also be accessed via the < <= <=> >= and > shortcut operators. If not overridden the default implementation compares the toStr representations. Also see docLang.

Examples:

3.compare(8)  =>  -1
8.compare(3)  =>  1
8.compare(8)  =>  0
3 <=> 8       =>  -1  // shortcut for 3.compare(8)
Copy

Get the current test method being executed or throw Err if not currently running a test. This method is available during both setup and teardown as well as during the test itself.

Compare this object to the specified for equality. This method may be accessed via the == and != shortcut operators. If not overridden the default implementation compares for reference equality using the === operator. If this method is overridden, then hash() must also be overridden such that any two objects which return true for equals() must return the same value for hash(). This method must accept null and return false.

Throw a test failure exception. If msg is non-null, include it in the failure exception.

Return a unique hashcode for this object. If a class overrides hash() then it must ensure if equals() returns true for any two objects then they have same hash code.

Return if this Obj is immutable and safe to share between threads:

• an instance of a const class
• the result of toImmutable on List, Map, or Buf
• a Func object may or may not be immutable - see sys::Func.
• other instances are assumed mutable and return false

Setup is called before running each test method.

Teardown is called after running every test method.

Return a temporary test directory which may used as a scratch directory. This directory is guaranteed to be created and empty the first time this method is called for a given test run. The test directory is "{Env.cur.tempDir}/test/".

Get an immutable representation of this instance or throw NotImmutableErr if this object cannot be represented as an immutable:

• if type is const, return this
• if already an immutable List, Map, Buf, or Func return this
• if a List, then attempt to perform a deep clone by calling toImmutable on all items
• if a Map, then attempt to perform a deep clone by calling toImmutable on all values (keys are already immutable)
• some Funcs can be made immutable - see sys::Func
• if a Buf create immutable copy, see sys::Buf
• any other object throws NotImmutableErr

Return a string representation of this object.

Trap a dynamic call for handling. Dynamic calls are invoked with the -> shortcut operator:

a->x        a.trap("x", null)
a->x()      a.trap("x", null)
a->x = b    a.trap("x", [b])
a->x(b)     a.trap("x", [b])
a->x(b, c)  a.trap("x", [b, c])
Copy

The default implementation provided by Obj attempts to use reflection. If name maps to a method, it is invoked with the specified arguments. If name maps to a field and args.size is zero, get the field. If name maps to a field and args.size is one, set the field and return args[0]. Otherwise throw UnknownSlotErr.

Get the Type instance which represents this object's class. Also seeType.of or Pod.of.

Verify that cond is true, otherwise throw a test failure exception. If msg is non-null, include it in a failure exception. Identical to verifyTrue.

Verify that a == b, otherwise throw a test failure exception. If both a and b are nonnull, then this method also ensures that a.hash == b.hash, because any two objects which return true for equals() must also return the same hash code. If msg is non-null, include it in failure exception.

Verify that the function throws an Err of the exact same type as errType (compare using === operator). If the errType parameter is null, then this method tests only that an exception is thrown, not its type.

Example:

verifyErr(ParseErr#) { x := Int.fromStr("@#!") }
Copy

Verify that the function throws an Err. The Err must be the exact same type as errType and the contained msg must be the same as errMsg.

Example:

verifyErrMsg(ParseErr#, "Invalid Int: 'ABC'")
{
  x := Int.fromStr("ABC")
}
Copy

Verify that cond is false, otherwise throw a test failure exception. If msg is non-null, include it in a failure exception.

Verify that a != b, otherwise throw a test failure exception. If msg is non-null, include it in failure exception.

Verify that a is not null, otherwise throw a test failure exception. If msg is non-null, include it in a failure exception.

Verify that a !== b, otherwise throw a test failure exception. If msg is non-null, include it in failure exception.

Verify that a is null, otherwise throw a test failure exception. If msg is non-null, include it in a failure exception.

Verify that a === b, otherwise throw a test failure exception. If msg is non-null, include it in failure exception.

Verify that cond is true, otherwise throw a test failure exception. If msg is non-null, include it in a failure exception. Identical to verify.

Verify that Type.of(obj) equals the given type.

This method called whenever an it-block is applied to an object. The default implementation calls the function with this, and then returns this.

Write x.toStr to standard output followed by newline. If x is null then print "null". If no argument is provided then print an empty line.