modddels_annotation_dartz library

Classes

Applicative<F>
ApplicativeOps<F, A>
ApplicativePlus<F>
ApplicativePlusOps<F, A>
Attempt<A>
AVLTree<A>
AVLTreeMonoid<A>
BaseModddel: This is the base class of all modddels.
BaseTester<M extends BaseModddel<I, V>, I extends InvalidModddel, V extends ValidModddel>: This is the base class of Testers. A Tester is a generated class that allows you to easily create tests for your modddel.
Bind<F, A, B>
BooleanConjunctionMonoid
BooleanDisjunctionMonoid
CloseFile
ComparableOrder<A extends Comparable>
ComposedFunctor<F, G>
Cons<A>
ContentFailure: A ContentFailure is the failure of a contentValidation.
CustomMatcher: A useful utility class for implementing other matchers through inheritance. Derived classes should call the base constructor with a feature name and description, and an instance matcher, and should implement the featureValueOf abstract method.
Delay<A>
Description: Matchers build up their error messages by appending to Description objects.
DualMonoid<A>
DualSemigroup<A>
Either<L, R>
EitherLens<A, B, E>
EitherMonad<L>
Entity: An Entity is a modddel that holds other modddels (ValueObjects or Entities).
EntityFailure: An EntityFailure is a Failure specific to Entities.
Eq<A>
EqOps<A>
Evaluation<E, R, W, S, A>
EvaluationMonad<E, R, W, S>
Execute
ExecutionResult
Fail<A>
Failure: A Failure represents a validation that failed for a specific reason, making the modddel invalid. A valid modddel has no failures, while an invalid Modddel has at least one failure.
FailureType<F extends Failure>
FileRef
Foldable<F>
FoldableOps<F, A>
FoldableOpsFoldable<F extends FoldableOps>
Free<F, A>
Free2<First, Second>
Free3<First, Second, Third>
FreeComposer<F, C>
FreeMonad<F>
FreeOps<F, O>
Function0TraversableMonad
Functor<F>
FunctorOps<F, A>
FutureMonad
Gather<A>
IdFreeComposer<F>
IdMonad
IdTraversable
IHashMap<K, V>
IList<A>
IListEntity: An IListEntity is an IterableEntity where the modddels are held inside an IList.
IListMonoid<A>
IListTMonad<M>
IMap<K, V>
IMapEntity: An IMapEntity is an Iterable2Entity where the modddels are held inside an IMap.
IMapMonoid<K, V>
IMappedKeysEntity: An IMappedKeysEntity is an IterableEntity where the modddels are held inside the keys of an IMap. The values can be any Dart objects, and they are not validated during the contentValidation.
IMappedValuesEntity: An IMappedValuesEntity is an IterableEntity where the modddels are held inside the values of an IMap. The keys can be any Dart objects, and they are not validated during the contentValidation.
IntSumMonoid
InvalidEntity: An InvalidEntity is an interface implemented by the "invalid" union-case of Entities.
InvalidModddel: This is the base interface for the "invalid" union-case of a modddel.
InvalidStepTest<M extends BaseModddel<I, V>, I extends InvalidModddel, V extends ValidModddel>: This is the superclass of "InvalidStep" tests.
InvalidValueObject: An InvalidValueObject is an interface implemented by the "invalid" union-case of ValueObjects.
IOMonad
IOOp<A>
IOOps<F>
ISet<A>
ISetEntity: An ISetEntity is an IterableEntity where the modddels are held inside an ISet.
ISetMonoid<A>
isInstanceOf<T>: DEPRECATED Use isA instead.
Iterable2Entity: An Iterable2Entity is an Entity that holds a collection of modddels.
IterableEntity: An IterableEntity is an Entity that holds a collection of modddels.
IteratorEq<A>
IVector<A>
IVectorMonoid<A>
KtListEntity: A KtListEntity is an IterableEntity where the modddels are held inside a KtList.
KtMapEntity: A KtMapEntity is an Iterable2Entity where the modddels are held inside a KtMap.
KtMappedKeysEntity: A KtMappedKeysEntity is an IterableEntity where the modddels are held inside the keys of a KtMap. The values can be any Dart objects, and they are not validated during the contentValidation.
KtMappedValuesEntity: A KtMappedValuesEntity is an IterableEntity where the modddels are held inside the values of a KtMap. The keys can be any Dart objects, and they are not validated during the contentValidation.
KtSetEntity: A KtSetEntity is an IterableEntity where the modddels are held inside a KtSet.
Left<L, R>
LeftFreeComposer<LL, L, R>
Lens<AIn, AOut, BIn, BOut>
ListEntity: A ListEntity is an IterableEntity where the modddels are held inside a List.
ListMonoid<A>
ListTMonad<M>
ListTraversableMonadPlus
MapEntity: A MapEntity is an Iterable2Entity where the modddels are held inside a Map.
MappedKeysEntity: A MappedKeysEntity is an IterableEntity where the modddels are held inside the keys of a Map. The values can be any Dart objects, and they are not validated during the contentValidation.
MappedValuesEntity: A MappedValuesEntity is an IterableEntity where the modddels are held inside the values of a Map. The keys can be any Dart objects, and they are not validated during the contentValidation.
Matcher: The base class for all matchers.
MaxSemigroup<A>
MinSemigroup<A>
Modddel: Flags a class to be processed by the Modddels Generator.
ModddelInvalidMember: A ModddelInvalidMember is a wrapper class that holds an invalid member of an Entity, and its description in that Entity.
ModddelParams<M extends BaseModddel<InvalidModddel, ValidModddel>>: This is the base class of all ModddelParams.
Monad<F>
MonadCatch<F>
MonadCatchOps<F, A>
MonadOps<F, A>
MonadOpsMonad<F extends MonadOps>
MonadPlus<F>
MonadPlusOps<F, A>
MonadPlusOpsMonadPlus<F extends MonadPlusOps>
Monoid<A>
MultiValueObject: A MultiValueObject is a ValueObject that can hold multiple member parameters.
Nil<A>
None<A>
NullFailure: This annotation can be used inside any modddel / union of modddels, in front of a nullable member parameter.
NumMaxSemigroup
NumMinSemigroup
NumProductMonoid
NumSumMonoid
OnPlatform: An annotation for platform-specific customizations for a test suite.
OpenFile
Option<A>
OptionLens<A, B>
OptionMonadPlus
OptionMonoid<A>
OptionTraversable
Order<A>
Plus<F>
PlusEmpty<F>
PlusEmptyOps<F, A>
PlusOps<F, A>
Println
Pure<F, A>
ReadBytes
Readln
Retry: An annotation for marking a test suite to be retried.
Right<L, R>
RightFreeComposer<RR, L, R>
Semigroup<A>
SetEntity: A SetEntity is an IterableEntity where the modddels are held inside a Set.
SharedProp
SimpleEntity: A SimpleEntity is an Entity that holds the modddels as separate fields.
SimpleLens<A, B>
SingleValueObject: A SingleValueObject is a ValueObject that holds only one member parameter.
Skip: An annotation for marking a test suite as skipped.
Some<A>
State<S, A>
StateMonad<S>
StateT<F, S, A>
StateTMonad<F, S>
StreamMatcher: A matcher that matches events from Streams or StreamQueues.
StringDescription: The default implementation of Description. This should rarely need substitution, although conceivably it is a place where other languages could be supported.
StringMonoid
Suspend<F, A>
Tags: An annotation for applying a set of user-defined tags to a test suite.
Task<A>
TaskMonadCatch
TestOn: An annotation indicating which platforms a test suite supports.
Throws: Use the throwsA function instead.
Timeout: A class representing a modification to the default timeout for a test.
ToStringOrder<A extends Object>
Trampoline<A>
Traversable<F>
TraversableMonad<F>
TraversableMonadOps<F, A>
TraversableMonadPlus<F>
TraversableMonadPlusOps<F, A>
TraversableOps<F, A>
TraversableOpsTraversable<F extends TraversableOps>
Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
Tuple2<T1, T2>
Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
Tuple2Monoid<T1, T2>
Tuple2Semigroup<T1, T2>
Tuple3<T1, T2, T3>
Tuple3Monoid<T1, T2, T3>
Tuple3Semigroup<T1, T2, T3>
Tuple4<T1, T2, T3, T4>
Tuple4Monoid<T1, T2, T3, T4>
Tuple4Semigroup<T1, T2, T3, T4>
Tuple5<T1, T2, T3, T4, T5>
Tuple6<T1, T2, T3, T4, T5, T6>
Tuple7<T1, T2, T3, T4, T5, T6, T7>
Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>
Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
TypeMatcher<T>: A Matcher subclass that supports validating the Type of the target object.
TypeTemplate: An IterableEntity or Iterable2Entity have only one member parameter, which is the collection of modddels. For example, a 'BookList' ListEntity will have one member parameter List<Book> books.
Unit
UnitMonoid
Validation
ValidationStep
ValidEntity: A ValidEntity is an interface implemented by the "valid" union-case of Entities.
ValidModddel: This is the base interface for the "valid" union-case of a modddel.
ValidValueObject: A ValidValueObject is an interface implemented by the "valid" union-case of ValueObjects.
ValueFailure: A ValueFailure is a Failure specific to ValueObjects.
ValueObject: A ValueObject is a modddel that holds a "value", which can be made up by one or multiple member parameters.
WriteBytes

Enums

Ordering

Extensions

EitherCompat on Either<L, R>
TaskBoolOps on Task<bool>
TaskFlattenOps on Task<Task<A>>

Constants

anything → const Matcher: A matcher that matches any value.
contentValidation → const Validation
dependencyParam → const DependencyParamAnnotation: This annotation can be used inside any modddel / union of modddels, in front of a factory parameter.
invalidParam → const InvalidParamAnnotation: This annotation can only be used inside a SimpleEntity, in front of a nullable member parameter.
invalidWithGetter → const InvalidWithGetterAnnotation: Same as specifying both the invalidParam and withGetter annotations.
isArgumentError → const TypeMatcher<ArgumentError>: A matcher for ArgumentError.
isCastError → const TypeMatcher<TypeError>: A matcher for TypeError.
isConcurrentModificationError → const TypeMatcher<ConcurrentModificationError>: A matcher for ConcurrentModificationError.
isCyclicInitializationError → const TypeMatcher<Error>: A matcher for Error.
isEmpty → const Matcher: Returns a matcher that matches the isEmpty property.
isException → const TypeMatcher<Exception>: A matcher for Exception.
isFalse → const Matcher: A matcher that matches anything except the Boolean value true.
isFormatException → const TypeMatcher<FormatException>: A matcher for FormatException.
isList → const TypeMatcher<List>: A matcher for List.
isMap → const TypeMatcher<Map>: A matcher for Map.
isNaN → const Matcher: A matcher that matches the numeric value NaN.
isNegative → const Matcher: A matcher which matches if the match argument is negative.
isNonNegative → const Matcher: A matcher which matches if the match argument is zero or positive.
isNonPositive → const Matcher: A matcher which matches if the match argument is zero or negative.
isNonZero → const Matcher: A matcher which matches if the match argument is non-zero.
isNoSuchMethodError → const TypeMatcher<NoSuchMethodError>: A matcher for NoSuchMethodError.
isNotEmpty → const Matcher: Returns a matcher that matches the isNotEmpty property.
isNotNaN → const Matcher: A matcher that matches any non-NaN value.
isNotNull → const Matcher: A matcher that matches any non-null value.
isNull → const Matcher: A matcher that matches any null value.
isNullThrownError → const TypeMatcher<TypeError>: A matcher for TypeError.
isPositive → const Matcher: A matcher which matches if the match argument is positive.
isRangeError → const TypeMatcher<RangeError>: A matcher for RangeError.
isStateError → const TypeMatcher<StateError>: A matcher for StateError.
isTrue → const Matcher: A matcher that matches the Boolean value true.
isUnimplementedError → const TypeMatcher<UnimplementedError>: A matcher for UnimplementedError.
isUnsupportedError → const TypeMatcher<UnsupportedError>: A matcher for UnsupportedError.
isZero → const Matcher: A matcher which matches if the match argument is zero.
returnsNormally → const Matcher: A matcher that matches a function call against no exception.
throws → const Matcher: This function is deprecated.
throwsArgumentError → const Matcher: A matcher for functions that throw ArgumentError.
throwsConcurrentModificationError → const Matcher: A matcher for functions that throw ConcurrentModificationError.
throwsCyclicInitializationError → const Matcher: A matcher for functions that throw CyclicInitializationError.
throwsException → const Matcher: A matcher for functions that throw Exception.
throwsFormatException → const Matcher: A matcher for functions that throw FormatException.
throwsNoSuchMethodError → const Matcher: A matcher for functions that throw NoSuchMethodError.
throwsNullThrownError → const Matcher: A matcher for functions that throw NullThrownError.
throwsRangeError → const Matcher: A matcher for functions that throw RangeError.
throwsStateError → const Matcher: A matcher for functions that throw StateError.
throwsUnimplementedError → const Matcher: A matcher for functions that throw Exception.
throwsUnsupportedError → const Matcher: A matcher for functions that throw UnsupportedError.
unit → const Unit
validParam → const ValidParamAnnotation: This annotation can only be used inside a SimpleEntity, in front of a member parameter.
validWithGetter → const ValidWithGetterAnnotation: Same as specifying both the validParam and withGetter annotations.
withGetter → const WithGetterAnnotation: This annotation can be used inside any modddel / union of modddels, in front of a member parameter.

Properties

AVLTreeFo → Foldable<AVLTree>: final
BoolAndMi → Monoid<bool>: final
BoolOrMi → Monoid<bool>: final
completes → Matcher: Matches a Future that completes successfully with any value.
final
doesNotComplete → Matcher: Matches a Future that does not complete.
final
DoubleOrder → Order<double>: final
DualEndoMi → Monoid<Endo>: final
EitherM → EitherMonad: final
EitherTr → Traversable<Either>: final
emitsDone → StreamMatcher: Returns a StreamMatcher that asserts that the stream emits a "done" event.
final
EndoMi → Monoid<Endo>: final
FirstSemigroup → Semigroup: final
FreeM → FreeMonad: final
Function0TrM → Function0TraversableMonad: final
FutureM → FutureMonad: final
IdM → IdMonad: final
IdTr → IdTraversable: final
IHashMapTr → Traversable<IHashMap>: final
IListMi → Monoid<IList>: final
IListMP → MonadPlus<IList>: final
IListTr → Traversable<IList>: final
IMapMi → Monoid<IMap>: final
IMapTr → Traversable<IMap>: final
IntOrder → Order<int>: final
IntSumMi → Monoid<int>: final
io → IOOps<IOOp>: final
IOM → IOMonad: final
IOMC → MonadCatch<Free<IOOp, dynamic>>: final
ISetFo → Foldable<ISet>: final
IVectorMi → Monoid<IVector>: final
IVectorMP → MonadPlus<IVector>: final
IVectorTr → Traversable<IVector>: final
ListMi → Monoid<List>: final
ListMP → ListTraversableMonadPlus: final
ListTr → Traversable<List>: final
neverCalled → Null Function([Object?, Object?, Object?, Object?, Object?, Object?, Object?, Object?, Object?, Object?]): Returns a function that causes the test to fail if it's called.
no setter
NumMaxSi → Semigroup<num>: final
NumMinSi → Semigroup<num>: final
NumOrder → Order<num>: final
NumProductMi → Monoid<num>: final
NumSumMi → Monoid<num>: final
ObjectEq → Eq<Object>: final
ObjectIteratorEq → Eq<Iterator>: final
SecondSemigroup → Semigroup: final
StateM → StateMonad: final
StringMi → Monoid<String>: final
StringOrder → Order<String>: final
TaskMC → MonadCatch<Task>: final
toStringOrder → Order: final
TrampolineM → Monad<Trampoline>: final
TStateM → StateTMonad<Trampoline, dynamic>: final
tunit → Trampoline<Unit>: final
UnitMi → Monoid<Unit>: final

Functions

addStateInfo(Map matchState, Map values) → void: Useful utility for nesting match states.
addTearDown(dynamic callback()) → void: Registers a function to be run after the current test.
allOf(Object? arg0, [Object? arg1, Object? arg2, Object? arg3, Object? arg4, Object? arg5, Object? arg6]) → Matcher: This returns a matcher that matches if all of the matchers passed as arguments (up to 7) match.
anyElement(Object? valueOrMatcher) → Matcher: Returns a matcher which matches Iterables in which at least one element matches the given valueOrMatcher.
anyOf(Object? arg0, [Object? arg1, Object? arg2, Object? arg3, Object? arg4, Object? arg5, Object? arg6]) → Matcher: Matches if any of the given matchers evaluate to true.
cast<A>(dynamic a) → A
catching<A>(Function0<A> thunk) → Either<dynamic, A>
closeTo(num value, num delta) → Matcher: Returns a matcher which matches if the match argument is within delta of some value.
collapseWhitespace(String string) → String: Utility function to collapse whitespace runs to single spaces and strip leading/trailing whitespace.
comparableOrder<A extends Comparable>() → Order<A>
completion(Object? matcher, [String? description]) → Matcher: Matches a Future that completes successfully with a value that matches matcher.
composeF<A, B, C>(Function1<B, C> f, Function1<A, B> g) → Function1<A, C>
composeInterpreters<L, R, O>(O lInterpreter(L l), O rInterpreter(R r)) → Function1<Either<L, R>, O>
cons<A>(A head, IList<A> tail) → IList<A>
constF<A, B>(B b) → Function1<A, B>
contains(Object? expected) → Matcher: Returns a matcher that matches if the match argument contains the expected value.
containsAll(Iterable expected) → Matcher: Matches Iterables which contain an element matching every value in expected in any order, and may contain additional values.
containsAllInOrder(Iterable expected) → Matcher: Matches Iterables which contain an element matching every value in expected in the same order, but may contain additional values interleaved throughout.
containsOnce(Object? expected) → Matcher: Matches Iterables where exactly one element matches the expected value, and all other elements don't match.
containsPair(Object? key, Object? valueOrMatcher) → Matcher: Returns a matcher which matches maps containing the key-value pair with key => valueOrMatcher.
containsValue(Object? value) → Matcher: Returns a matcher which matches maps containing the given value.
curry2<A, B, C>(Function2<A, B, C> fun) → Function1<A, Function1<B, C>>
curry3<A, B, C, D>(Function3<A, B, C, D> fun) → Function1<A, Function1<B, Function1<C, D>>>
curry4<A, B, C, D, E>(Function4<A, B, C, D, E> fun) → Function1<A, Function1<B, Function1<C, Function1<D, E>>>>
curry5<A, B, C, D, E, F>(Function5<A, B, C, D, E, F> fun) → Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, F>>>>>
curry6<A, B, C, D, E, F, G>(Function6<A, B, C, D, E, F, G> fun) → Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, Function1<F, G>>>>>>
dualEndoMi<A>() → Monoid<Endo<A>>
dualMonoid<A>(Monoid<A> mi) → Monoid<A>
dualSemigroup<A>(Semigroup<A> si) → Semigroup<A>
eitherM<L>() → EitherMonad<L>
eitherTr<L, R>() → Traversable<Either<L, R>>
emits(Object? matcher) → StreamMatcher: Returns a StreamMatcher for matcher.
emitsAnyOf(Iterable matchers) → StreamMatcher: Returns a StreamMatcher that matches the stream if at least one of matchers matches.
emitsError(Object? matcher) → StreamMatcher: Returns a StreamMatcher that matches a single error event that matches matcher.
emitsInAnyOrder(Iterable matchers) → StreamMatcher: Returns a StreamMatcher that matches the stream if each matcher in matchers matches, in any order.
emitsInOrder(Iterable matchers) → StreamMatcher: Returns a StreamMatcher that matches the stream if each matcher in matchers matches, one after another.
emitsThrough(Object? matcher) → StreamMatcher: Returns a StreamMatcher that matches any number of events followed by events that match matcher.
emptyAVLNode<A>() → _AVLNode<A>
emptyMap<K extends Comparable, V>() → IMap<K, V>
emptySet<A extends Comparable>() → ISet<A>
emptySetWithOrder<A>(Order<A> order) → ISet<A>
emptyVector<A>() → IVector<A>
endoMi<A>() → Monoid<Endo<A>>
endsWith(String suffixString) → Matcher: Returns a matcher that matches if the match argument is a string and ends with suffixString.
eq<A>(EqF<A> f) → Eq<A>
equals(Object? expected, [int limit = 100]) → Matcher: Returns a matcher that matches if the value is structurally equal to expected.
equalsIgnoringCase(String value) → Matcher: Returns a matcher which matches if the match argument is a string and is equal to value when compared case-insensitively.
equalsIgnoringWhitespace(String value) → Matcher: Returns a matcher which matches if the match argument is a string and is equal to value, ignoring whitespace.
escape(String str) → String: Returns str with all whitespace characters represented as their escape sequences.
everyElement(Object? valueOrMatcher) → Matcher: Returns a matcher which matches Iterables in which all elements match the given valueOrMatcher.
expect(dynamic actual, dynamic matcher, {String? reason, Object? skip, bool verbose = false, ErrorFormatter? formatter}) → void: Assert that actual matches matcher.
expectAsync(Function callback, {int count = 1, int max = 0, String? id, String? reason}) → Function: This function is deprecated because it doesn't work well with strong mode. Use expectAsync0, expectAsync1, expectAsync2, expectAsync3, expectAsync4, expectAsync5, or expectAsync6 instead.
expectAsync0<T>(T callback(), {int count = 1, int max = 0, String? id, String? reason}) → Func0<T>: Informs the framework that the given callback of arity 0 is expected to be called count number of times (by default 1).
expectAsync1<T, A>(T callback(A), {int count = 1, int max = 0, String? id, String? reason}) → Func1<T, A>: Informs the framework that the given callback of arity 1 is expected to be called count number of times (by default 1).
expectAsync2<T, A, B>(T callback(A, B), {int count = 1, int max = 0, String? id, String? reason}) → Func2<T, A, B>: Informs the framework that the given callback of arity 2 is expected to be called count number of times (by default 1).
expectAsync3<T, A, B, C>(T callback(A, B, C), {int count = 1, int max = 0, String? id, String? reason}) → Func3<T, A, B, C>: Informs the framework that the given callback of arity 3 is expected to be called count number of times (by default 1).
expectAsync4<T, A, B, C, D>(T callback(A, B, C, D), {int count = 1, int max = 0, String? id, String? reason}) → Func4<T, A, B, C, D>: Informs the framework that the given callback of arity 4 is expected to be called count number of times (by default 1).
expectAsync5<T, A, B, C, D, E>(T callback(A, B, C, D, E), {int count = 1, int max = 0, String? id, String? reason}) → Func5<T, A, B, C, D, E>: Informs the framework that the given callback of arity 5 is expected to be called count number of times (by default 1).
expectAsync6<T, A, B, C, D, E, F>(T callback(A, B, C, D, E, F), {int count = 1, int max = 0, String? id, String? reason}) → Func6<T, A, B, C, D, E, F>: Informs the framework that the given callback of arity 6 is expected to be called count number of times (by default 1).
expectAsyncUntil0<T>(T callback(), bool isDone(), {String? id, String? reason}) → Func0<T>: Informs the framework that the given callback of arity 0 is expected to be called until isDone returns true.
expectAsyncUntil1<T, A>(T callback(A), bool isDone(), {String? id, String? reason}) → Func1<T, A>: Informs the framework that the given callback of arity 1 is expected to be called until isDone returns true.
expectAsyncUntil2<T, A, B>(T callback(A, B), bool isDone(), {String? id, String? reason}) → Func2<T, A, B>: Informs the framework that the given callback of arity 2 is expected to be called until isDone returns true.
expectAsyncUntil3<T, A, B, C>(T callback(A, B, C), bool isDone(), {String? id, String? reason}) → Func3<T, A, B, C>: Informs the framework that the given callback of arity 3 is expected to be called until isDone returns true.
expectAsyncUntil4<T, A, B, C, D>(T callback(A, B, C, D), bool isDone(), {String? id, String? reason}) → Func4<T, A, B, C, D>: Informs the framework that the given callback of arity 4 is expected to be called until isDone returns true.
expectAsyncUntil5<T, A, B, C, D, E>(T callback(A, B, C, D, E), bool isDone(), {String? id, String? reason}) → Func5<T, A, B, C, D, E>: Informs the framework that the given callback of arity 5 is expected to be called until isDone returns true.
expectAsyncUntil6<T, A, B, C, D, E, F>(T callback(A, B, C, D, E, F), bool isDone(), {String? id, String? reason}) → Func6<T, A, B, C, D, E, F>: Informs the framework that the given callback of arity 6 is expected to be called until isDone returns true.
expectLater(dynamic actual, dynamic matcher, {String? reason, Object? skip}) → Future: Just like expect, but returns a Future that completes when the matcher has finished matching.
fail(String message) → Never: Convenience method for throwing a new TestFailure with the provided message.
firstSemigroup<A>() → Semigroup<A>
flip<A, B, C>(Function2<A, B, C> f) → Function2<B, A, C>
freeM<F>() → FreeMonad<F>
function0TrM<A>() → TraversableMonad<Function0<A>>
futureM<A>() → Monad<Future<A>>
greaterThan(Object value) → Matcher: Returns a matcher which matches if the match argument is greater than the given value.
greaterThanOrEqualTo(Object value) → Matcher: Returns a matcher which matches if the match argument is greater than or equal to the given value.
group(Object? description, dynamic body(), {String? testOn, Timeout? timeout, Object? skip, Object? tags, Map<String, dynamic>? onPlatform, int? retry, bool solo = false}) → void: Creates a group of tests.
hasLength(Object? matcher) → Matcher: Returns a matcher that matches if an object has a length property that matches matcher.
id<A>(A a) → A
idF<A>() → Endo<A>
ihashmap<K, V>(Map<K, V> m) → IHashMap<K, V>
ilist<A>(Iterable<A> iterable) → IList<A>
ilistMi<A>() → Monoid<IList<A>>
ilistMP<A>() → MonadPlus<IList<A>>
ilistTMonad(Monad mmonad) → Monad
imap<K extends Comparable, V>(Map<K, V> m) → IMap<K, V>
imapLensE<K, V, E>(K k, E eF()) → EitherLens<IMap<K, V>, V, E>
imapLensO<K, V>(K k) → OptionLens<IMap<K, V>, V>
imapMi<K extends Comparable, V>() → Monoid<IMap<K, V>>
imapMonoid<K extends Comparable, V>(Semigroup<V> si) → Monoid<IMap<K, V>>
imapMonoidWithOrder<K, V>(Semigroup<V> si, Order<K> order) → Monoid<IMap<K, V>>
imapWithOrder<K, K2 extends K, V>(Order<K> o, Map<K2, V> m) → IMap<K, V>
inClosedOpenRange(num low, num high) → Matcher: Returns a matcher which matches if the match argument is greater than or equal to a low and less than high.
inExclusiveRange(num low, num high) → Matcher: Returns a matcher which matches if the match argument is greater than low and less than high.
inInclusiveRange(num low, num high) → Matcher: Returns a matcher which matches if the match argument is greater than or equal to low and less than or equal to high.
inOpenClosedRange(num low, num high) → Matcher: Returns a matcher which matches if the match argument is greater than low and less than or equal to high.
iomc<A>() → MonadCatch<Free<IOOp, A>>
iota(int n) → IList<int>
isA<T>() → TypeMatcher<T>: Returns a matcher that matches objects with type T.
iset<A extends Comparable>(Iterable<A> i) → ISet<A>
isetMi<A>(Order<A> o) → Monoid<ISet<A>>
isetWithOrder<A, A2 extends A>(Order<A> order, Iterable<A2> i) → ISet<A>
isIn(Object? expected) → Matcher: Returns a matcher that matches if the match argument is in the expected value. This is the converse of contains.
isNot(Object? valueOrMatcher) → Matcher: Returns a matcher that inverts valueOrMatcher to its logical negation.
iteratorEq<A>(Eq<A> aEq) → Eq<Iterator<A>>
ivector<A>(Iterable<A> iterable) → IVector<A>
ivectorLensE<A, E>(int i, E eF()) → EitherLens<IVector<A>, A, E>
ivectorLensO<A>(int i) → OptionLens<IVector<A>, A>
ivectorMi<A>() → Monoid<IVector<A>>
ivectorMP<A>() → MonadPlus<IVector<A>>
left<L, R>(L l) → Either<L, R>
lens<AIn, AOut, BIn, BOut>(Function1<AIn, BOut> getter, Function2<AIn, BIn, AOut> setter) → Lens<AIn, AOut, BIn, BOut>
lensE<A, B, E>(Function1<A, Either<E, B>> getter, Function2<A, B, Either<E, A>> setter) → EitherLens<A, B, E>
lensEtoO<A, B>(EitherLens<A, B, dynamic> aLens) → OptionLens<A, B>
lensO<A, B>(Function1<A, Option> getter, Function2<A, B, Option<A>> setter) → OptionLens<A, B>
lensOToE<A, B, E>(OptionLens<A, B> aLens, E eF()) → EitherLens<A, B, E>
lensS<A, B>(Function1<A, B> getter, Function2<A, B, A> setter) → SimpleLens<A, B>
lessThan(Object value) → Matcher: Returns a matcher which matches if the match argument is less than the given value.
lessThanOrEqualTo(Object value) → Matcher: Returns a matcher which matches if the match argument is less than or equal to the given value.
liftF<F, A>(F fa) → Free<F, A>
listMi<A>() → Monoid<List<A>>
listMP<A>() → MonadPlus<List<A>>
listTMonad<M>(Monad<M> mmonad) → Monad<M>
markTestSkipped(String message) → void: Marks the current test as skipped.
matches(Pattern re) → Matcher: Returns a matcher that matches if the match argument is a string and matches the regular expression given by re.
mayEmit(Object? matcher) → StreamMatcher: Returns a StreamMatcher that allows (but doesn't require) matcher to match the stream.
mayEmitMultiple(Object? matcher) → StreamMatcher: Returns a StreamMatcher that matches any number of events that match matcher.
monoid<A>(A zero(), A append(A t1, A t2)) → Monoid<A>
neverEmits(Object? matcher) → StreamMatcher: Returns a StreamMatcher that matches a stream that never matches matcher.
nil<A>() → IList<A>
none<A>() → Option<A>
objectEq<A>() → Eq<A>
option<A>(bool test, A value) → Option<A>
optionMi<A>(Semigroup<A> si) → Monoid<Option<A>>
optionOf<A>(A? value) → Option<A>
order<A>(OrderF<A> f) → Order<A>
orderBy<A, B>(Order o, B by(A a)) → Order<A>
orderedEquals(Iterable expected) → Matcher: Returns a matcher which matches Iterables that have the same length and the same elements as expected, in the same order.
pairwiseCompare<S, T>(Iterable<S> expected, bool comparator(S, T), String description) → Matcher: A pairwise matcher for Iterables.
predicate<T>(bool f(T), [String description = 'satisfies function']) → Matcher: Returns a matcher that uses an arbitrary function that returns whether the value is considered a match.
printOnFailure(String message) → void: Prints message if and when the current test fails.
prints(Object? matcher) → Matcher: Matches a Function that prints text that matches matcher.
pumpEventQueue({int times = 20}) → Future: Returns a Future that completes after the event loop has run the given number of times (20 by default).
registerException(Object error, [StackTrace stackTrace = StackTrace.empty]) → void: Registers an exception that was caught for the current test.
right<L, R>(R r) → Either<L, R>
same(Object? expected) → Matcher: Returns a matches that matches if the value is the same instance as expected, using identical.
secondSemigroup<A>() → Semigroup<A>
semigroup<A>(A append(A a1, A a2)) → Semigroup<A>
setUp(dynamic callback()) → void: Registers a function to be run before tests.
setUpAll(dynamic callback()) → void: Registers a function to be run once before all tests.
singletonMap<K extends Comparable, V>(K k, V v) → IMap<K, V>
some<A>(A a) → Option<A>
spawnHybridCode(String dartCode, {Object? message, bool stayAlive = false}) → StreamChannel: Spawns a VM isolate that runs the given dartCode, which is loaded as the contents of a Dart library.
spawnHybridUri(Object uri, {Object? message, bool stayAlive = false}) → StreamChannel: Spawns a VM isolate for the given uri, which may be a Uri or a String.
startsWith(String prefixString) → Matcher: Returns a matcher that matches if the match argument is a string and starts with prefixString.
stateM<S>() → StateMonad<S>
stringContainsInOrder(List<String> substrings) → Matcher: Returns a matcher that matches if the match argument is a string and contains a given list of substrings in relative order.
taskMC<A>() → MonadCatch<Task<A>>
tcall<T>(Function0<Trampoline<T>> thunk) → Trampoline<T>
tearDown(dynamic callback()) → void: Registers a function to be run after tests.
tearDownAll(dynamic callback()) → void: Registers a function to be run once after all tests.
test(Object? description, dynamic body(), {String? testOn, Timeout? timeout, Object? skip, Object? tags, Map<String, dynamic>? onPlatform, int? retry, bool solo = false}) → void: Creates a new test case with the given description (converted to a string) and body.
throwsA(Object? matcher) → Matcher: This can be used to match three kinds of objects:
treturn<T>(T t) → Trampoline<T>
tstateM<F, S>() → StateTMonad<Trampoline<F>, S>
tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) → Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) → Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12) → Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13) → Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) → Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) → Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) → Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17) → Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18) → Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) → Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
tuple2<T1, T2>(T1 v1, T2 v2) → Tuple2<T1, T2>
tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) → Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
tuple2Monoid<T1, T2>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid) → Monoid<Tuple2<T1, T2>>
tuple2Semigroup<T1, T2>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup) → Semigroup<Tuple2<T1, T2>>
tuple3<T1, T2, T3>(T1 v1, T2 v2, T3 v3) → Tuple3<T1, T2, T3>
tuple3Monoid<T1, T2, T3>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid, Monoid<T3> value3Monoid) → Monoid<Tuple3<T1, T2, T3>>
tuple3Semigroup<T1, T2, T3>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup, Semigroup<T3> value3Semigroup) → Semigroup<Tuple3<T1, T2, T3>>
tuple4<T1, T2, T3, T4>(T1 v1, T2 v2, T3 v3, T4 v4) → Tuple4<T1, T2, T3, T4>
tuple4Monoid<T1, T2, T3, T4>(Monoid<T1> value1Monoid, Monoid<T2> value2Monoid, Monoid<T3> value3Monoid, Monoid<T4> value4Monoid) → Monoid<Tuple4<T1, T2, T3, T4>>
tuple4Semigroup<T1, T2, T3, T4>(Semigroup<T1> value1Semigroup, Semigroup<T2> value2Semigroup, Semigroup<T3> value3Semigroup, Semigroup<T4> value4Semigroup) → Semigroup<Tuple4<T1, T2, T3, T4>>
tuple5<T1, T2, T3, T4, T5>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) → Tuple5<T1, T2, T3, T4, T5>
tuple6<T1, T2, T3, T4, T5, T6>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) → Tuple6<T1, T2, T3, T4, T5, T6>
tuple7<T1, T2, T3, T4, T5, T6, T7>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) → Tuple7<T1, T2, T3, T4, T5, T6, T7>
tuple8<T1, T2, T3, T4, T5, T6, T7, T8>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) → Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>
tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) → Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
tuplize2<A, B, C>(Function2<A, B, C> fun) → Function1<Tuple2<A, B>, C>
tuplize3<A, B, C, D>(Function3<A, B, C, D> fun) → Function1<Tuple3<A, B, C>, D>
tuplize4<A, B, C, D, E>(Function4<A, B, C, D, E> fun) → Function1<Tuple4<A, B, C, D>, E>
uncurry2<A, B, C>(Function1<A, Function1<B, C>> fun) → Function2<A, B, C>
uncurry3<A, B, C, D>(Function1<A, Function1<B, Function1<C, D>>> fun) → Function3<A, B, C, D>
uncurry4<A, B, C, D, E>(Function1<A, Function1<B, Function1<C, Function1<D, E>>>> fun) → Function4<A, B, C, D, E>
uncurry5<A, B, C, D, E, F>(Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, F>>>>> fun) → Function5<A, B, C, D, E, F>
uncurry6<A, B, C, D, E, F, G>(Function1<A, Function1<B, Function1<C, Function1<D, Function1<E, Function1<F, G>>>>>> fun) → Function6<A, B, C, D, E, F, G>
unorderedEquals(Iterable expected) → Matcher: Returns a matcher which matches Iterables that have the same length and the same elements as expected, but not necessarily in the same order.
unorderedMatches(Iterable expected) → Matcher: Returns a matcher which matches Iterables whose elements match the matchers in expected, but not necessarily in the same order.
wrapMatcher(Object? valueOrMatcher) → Matcher: Takes an argument and returns an equivalent Matcher.

Typedefs

Endo<A> = A Function(A a)
EqF<A> = bool Function(A a1, A a2)
ErrorFormatter = String Function(Object? actual, Matcher matcher, String? reason, Map matchState, bool verbose): The type used for functions that can be used to build up error reports upon failures in expect.
Func0<T> = T Function()
Func1<T, A> = T Function([A a])
Func2<T, A, B> = T Function([A a, B b])
Func3<T, A, B, C> = T Function([A a, B b, C c])
Func4<T, A, B, C, D> = T Function([A a, B b, C c, D d])
Func5<T, A, B, C, D, E> = T Function([A a, B b, C c, D d, E e])
Func6<T, A, B, C, D, E, F> = T Function([A a, B b, C c, D d, E e, F f])
Function0<A> = A Function()
Function1<A, B> = B Function(A a)
Function10<A, B, C, D, E, F, G, H, I, J, K> = K Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j)
Function11<A, B, C, D, E, F, G, H, I, J, K, L> = L Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k)
Function12<A, B, C, D, E, F, G, H, I, J, K, L, M> = M Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l)
Function13<A, B, C, D, E, F, G, H, I, J, K, L, M, N> = N Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m)
Function14<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> = O Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n)
Function15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> = P Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o)
Function16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> = Q Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p)
Function17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> = R Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q)
Function18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> = S Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r)
Function19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> = T Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r, S s)
Function2<A, B, C> = C Function(A a, B b)
Function20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> = U Function(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p, Q q, R r, S s, T t)
Function3<A, B, C, D> = D Function(A a, B b, C c)
Function4<A, B, C, D, E> = E Function(A a, B b, C c, D d)
Function5<A, B, C, D, E, F> = F Function(A a, B b, C c, D d, E e)
Function6<A, B, C, D, E, F, G> = G Function(A a, B b, C c, D d, E e, F f)
Function7<A, B, C, D, E, F, G, H> = H Function(A a, B b, C c, D d, E e, F f, G g)
Function8<A, B, C, D, E, F, G, H, I> = I Function(A a, B b, C c, D d, E e, F f, G g, H h)
Function9<A, B, C, D, E, F, G, H, I, J> = J Function(A a, B b, C c, D d, E e, F f, G g, H h, I i)
OrderF<A> = Ordering Function(A a1, A a2)

Exceptions / Errors

TestFailure: An exception thrown when a test assertion fails.
UnreachableError: Thrown when a part of the code is supposed to be unreachable.

modddels_annotation_dartz library

Classes

Enums

Extensions

Constants

Properties

Functions

Typedefs

Exceptions / Errors

modddels_annotation_dartz package

modddels_annotation_dartz library