Documentation for classes includes syntax, usage information, and code samples for methods, properties, and event handlers and listeners for those APIs that belong to a specific class in ActionScript. The classes are listed alphabetically. If you are not sure to which class a certain method or property belongs, you can look it up in the Index.
| Class | Package | Description | |
|---|---|---|---|
| AbstractFilter | org.flexunit.runner.manipulation.filters | Potential base class implementing IFilter | |
| ActionScriptEnvironmentBuilder | org.fluint.uiImpersonation.actionScript | Builds a visual test environment for ActionScript only projects | |
| ActionScriptVisualTestEnvironment | org.fluint.uiImpersonation.actionScript | A proxy visual test environment for ActionScript projects | |
| AllDefaultPossibilitiesBuilder | org.flexunit.internals.builders | The AllDeafultPossibilitiesBuilder is used to determine what type of IRunner can be used to run a specific testClass. | |
| AllMembersSupplier | org.flexunit.experimental.theories.internals | The AllMembersSupplier determines what values can be applied to parameters in theories in a specific theory test method. | |
| AnnotationArgumentConstants | org.flexunit.constants | ||
| AnnotationConstants | org.flexunit.constants | ||
| Assert | org.flexunit | A set of assert methods. | |
| AssertionError | org.flexunit | Error class used for failures in assertions | |
| Assignments | org.flexunit.experimental.theories.internals | The Assignments is responsible for keeping track of assigned and unassigned parameters for a given configuration of a theory method. | |
| AssignmentSequencer | org.flexunit.experimental.runners.statements | The AssignmentSequencer is responsible for the sequencing of parameters to be provided to a particular theory method test. | |
| Assume | org.flexunit | A set of methods useful for stating assumptions about the conditions in which a test is meaningful. | |
| AssumptionViolatedException | org.flexunit.internals | The AssumptionViolatedException is thrown when an assumption in a test evalutes to false. | |
| Async | org.flexunit.async | The Async class contains static methods used in the handling of events in asynchronous methods in a particular test case. | |
| AsyncCoreStartupToken | org.flexunit.token | The AsyncCoreStartupToken is used when the FlexUnit frameworks needs to wait for an asynchronous operation before it can begin test execution. | |
| AsyncEvent | org.flexunit.events | An AsyncEvent is fired by the AsyncHandler when an asynchronous event, registered by the TestCase, fires. | |
| AsyncHandler | org.flexunit.async | AsyncHandlers are created when the developer calls the TestCase.asyncHandler() method. | |
| AsyncListenerWatcher | org.flexunit.runner.notification.async | The AsyncListenerWatcher is responsible for determing whether all IAsyncStartupRunListeners that it is watching are ready. | |
| AsyncLocator | org.flexunit.async | The AsyncLocator is used to keep track of test cases that have implemented asynchronous functionality. | |
| AsyncNativeTestResponder | org.flexunit.async | A respoder for asynchronous tests that contains result and fault handlers for the test succeeding or the test failing to succeed. | |
| AsyncResponseEvent | org.flexunit.events | An AsyncResponseEvent is event that is fired when an asynchronous test has recieved a response from an IAsyncTestTresponder. | |
| AsyncStatementBase | org.flexunit.internals.runners.statements | The AsyncStatementBase is responsible for notifiying a parent token that a task has been completed. | |
| AsyncTestResponder | org.flexunit.async | A respoder for asynchronous tests that contains result and fault handlers for the test succeeding or the test failing to succeed. | |
| AsyncTestToken | org.flexunit.token | The AsyncTestToken is responsible for indicating that a given task has completed. | |
| BlockFlexUnit4ClassRunner | org.flexunit.runners | The BlockFlexUnit4ClassRunner is the heart of running FlexUnit4 tests. | |
| ChildResult | org.flexunit.token | The ChildResult stores an AsyncTestToken and a potential Error associated with the execution of an IAsyncStatement. | |
| ChildRunnerSequencer | org.flexunit.internals.runners | The ChildRunnerSequencer is used to sequence children of specific class. | |
| ClassDataCache | flex.lang.reflect.cache | ||
| ClassInheritanceOrderCache | org.flexunit.runner.manipulation.sortingInheritance | ISortingInheritanceCache implementation that will allow querying of the inheritance order of a given method relative to its definition super and subclasses | |
| ClassNameUtil | org.flexunit.utils | The ClassNameUtil is responsible for assisting in the formatting of class names. | |
| ClassRequest | org.flexunit.internals.requests | A Request that is used to determine what runner to use to run a specific test class. | |
| Constructor | flex.lang.reflect | Parses <constructor/> node returned from a call to describeType to provide an object wrapper for the Constructor | |
| CouldNotGenerateValueException | org.flexunit.experimental.theories.internals.error | Thrown when a value could not be generated. | |
| Description | org.flexunit.runner | A Description describes a suite, test case, or test which is to be run or has been run. | |
| DescriptionUtil | org.flexunit.utils | This is a temporary class to work around parsing name issues with the Description when using parameterized testing. | |
| Descriptor | org.flexunit.runner | Describes an IDescription based on its path, suite, and method | |
| DynamicFilter | org.flexunit.runner.manipulation.filters | The canonical case of filtering is when you want to run a single test method in a class. | |
| Each | org.flexunit.internals.matchers | Implements an EachMatcher for internal framework use | |
| EachTestNotifier | org.flexunit.internals.runners.model | The EachTestNotifier is responsible for instructing a provided IRunNotifier about the execution of a specific test. | |
| ErrorReportingRunner | org.flexunit.internals.runners | Runner responsible for reproting errors encountered when attempting to initialize a class instead of running tests | |
| EventExpectations | org.flexunit.events.rule | ||
| EventRule | org.flexunit.events.rule | User stories User sets a complex expectation on an event without a timeout User sets a complex expectations on two different events without a timeout User sets two different expectations on the same event without a timeout For example, the first time it has property A set the second time it has property B set User sets a complex expectation on an event with a timeout User sets a complex expectations on two different events with a timeout User sets two different expectations on the same event with a timeout | |
| ExecutionCompleteEvent | org.flexunit.internals.events | Dispatched when the runner has finished executing tests. | |
| ExpectAsync | org.flexunit.internals.runners.statements | The ExpectAsync is a decorator that is responsible for determing whether a specific test method is expecting an asynchronous response. | |
| ExpectationEvent | org.flexunit.events.rule | ||
| ExpectException | org.flexunit.internals.runners.statements | The ExpectException is a decorator that is responsible for determing whether a specific test method throws an expected exception. | |
| ExternalDependencyResolver | org.flexunit.internals.dependency | ||
| ExternalDependencyToken | org.flexunit.runner.external | ExternalDependencyToken follows a pattern similar to the AsyncToken in Flex to notify interested resolvers when a dependency has been resolved. | |
| ExternalRunnerDependencyWatcher | org.flexunit.internals.dependency | Watches for external dependencies to be resolved. | |
| Fail | org.flexunit.internals.runners.statements | The Fail class is responsible for throwing a failure error when it is evaluated. | |
| FailOnTimeout | org.flexunit.internals.runners.statements | The FailOnTimeout is a decorator that is responsible for determing whether a specific test method has exceeded a timeout period for execution. | |
| Failure | org.flexunit.runner.notification | A Failure holds a description of the failed test and the exception that was thrown while running it. | |
| FailureFormatter | org.flexunit.reporting | The FailureFormatter is responsible for formatting potential failures. | |
| Field | flex.lang.reflect | An object representing a property or variable of a class or instance. | |
| FieldBuilder | flex.lang.reflect.builders | ||
| FieldMetaDataSorter | org.flexunit.runner.manipulation.fields | A field sorter capable of sorting fields based on the order argument | |
| FilterRequest | org.flexunit.internals.requests | A Request that filters a test class. | |
| FlexEnvironmentBuilder | org.fluint.uiImpersonation.flex | Builds a visual test environment for Flex projects | |
| FlexMXVisualTestEnvironment | org.fluint.uiImpersonation.flex | A visual test environment for Flex projects | |
| FlexSparkVisualTestEnvironment | org.fluint.uiImpersonation.flex | Builds a visual test environment for Flex 4.0 and above projects | |
| FlexUnit1Builder | org.flexunit.internals.builders | The FlexUnit1Builder potentially builds a FlexUnit1ClassRunner for a provided testClass. | |
| FlexUnit1ClassRunner | org.flexunit.internals.runners | The FlexUnit1ClassRunner is responsible for running FlexUnit1 classes. | |
| FlexUnit4Builder | org.flexunit.internals.builders | The FlexUnit4Builder builds a BlockFlexUnit4ClassRunner for a provided testClass. | |
| FlexUnit4QualifiedBuilder | org.flexunit.internals.builders | This class is used as an alternate builder for FlexUnit 4. | |
| FlexUnitCore | org.flexunit.runner | FlexUnit4 Version: 4.1.00 The FlexUnitCore is responsible for executing objects that implement an IRequest interface. | |
| FrameWatcher | org.flexunit.internals.runners.watcher | ||
| FrameworkMethod | org.flexunit.runners.model | Represents a method on a test class to be invoked at the appropriate point in test execution. | |
| IAsyncCompletionRunListener | org.flexunit.runner.notification | An interface for listeners that may need to complete an asynchronous operation after a test run is complete and before the test runner is closed. | |
| IAsyncHandlingStatement | org.flexunit.internals.runners.statements | An IAsyncHandlingStatement is an interface for statements that handle asynchronous functionality for tests. | |
| IAsyncRunListener | org.flexunit.runner.notification | The IAsyncRunListener is an interface that is to be implemented by classes that are to be asynchronous run listeners. | |
| IAsyncStartupRunListener | org.flexunit.runner.notification | Interface to be implemented by listeners that need to perform async operations at startup that must be completed before the core can begin executing tests | |
| IAsyncStatement | org.flexunit.internals.runners.statements | An IAsyncStatement is an interface for statements that need to be evaluated and report to a parent when the statement has finish evaluating. | |
| IAsyncTestResponder | org.flexunit.async | This is a marker interface that allows others to substitute their own asynchronous test responsers for the ones that already exist. | |
| IAsyncTestToken | org.flexunit.token | Interface describing viable tokens to be passed between test stages | |
| IDescribable | org.flexunit.runner | The IDescribable interface is to be used by classes that can produce an IDescription of themselves. | |
| IDescription | org.flexunit.runner | An IDescription class that is being used in a test run. | |
| IEventExpectation | org.flexunit.events.rule | ||
| IExternalDependencyData | org.flexunit.runner.external | Extension to the IExternalDependencyLoader concept which allows a given class to act both as a loader and as the final data source without requiring a separate static variable. | |
| IExternalDependencyLoader | org.flexunit.runner.external | Allows the user to specify a static variable of type IExternalDependencyLoader. | |
| IExternalDependencyResolver | org.flexunit.internals.dependency | IExternalDependencyResolver are responsible for resolving external dependencies on a test class | |
| IExternalDependencyRunner | org.flexunit.runner.external | IExternalDependencyRunner instances are IRunners which support the notion of external dependencies or data that is not present until a potentially asynchronous operation occurs | |
| IExternalRunnerDependencyWatcher | org.flexunit.internals.dependency | ||
| IFieldSorter | org.flexunit.runner.manipulation.fields | Interface for all instances to be considered field sorters | |
| IFilter | org.flexunit.runner.manipulation | Interface describing an IFilter which can be applied to a Request to filter the executed tests | |
| IFilterable | org.flexunit.runner.manipulation | IRunners that allow filtering should implement this interface. | |
| IFixtureSorter | org.flexunit.runner.manipulation | Implemented by sorters that also wish to customize the sorting experience for fixture elements such as Before and After | |
| IgnoredBuilder | org.flexunit.internals.builders | The IgnoredBuilder potentially builds an IgnoredClassRunner for a provided testClass. | |
| IgnoredClassRunner | org.flexunit.internals.builders | The IgnoredClassRunner is an IRunner for test classes that are to be ignored. | |
| IMethodRule | org.flexunit.rules | ||
| IncludeAllFilter | org.flexunit.runner.manipulation.filters | Implementation of a filter that includes all children | |
| IncludeFlexClasses | org.flexunit | These classes should only be included in a Flex project | |
| InitializationError | org.flexunit.internals.runners | The InitializationError represents one or more problems encountered while initializing an IRunner. | |
| InvokeMethod | org.flexunit.internals.runners.statements | The InvokeMethod is responsible for invoking a specific test method in given test class. | |
| IParameterSupplier | org.flexunit.experimental.theories | The IParameterSupplier is an interface used by classes that supply values to parameters for a theory test method. | |
| IPotentialAssignment | org.flexunit.experimental.theories | The IPotentialAssignment interface is used by classes that want to store poential values that will be used by parameters in a theory test method. | |
| IReflectiveCallable | org.flexunit.internals.runners.model | When invoked, throws the exception from the reflected method, rather than wrapping it in an InvocationTargetException. | |
| IRequest | org.flexunit.runner | An IRequest is an abstract description of tests to be run. | |
| IRunListener | org.flexunit.runner.notification | The IRunListener is an interface used be classes that want to act as a run listener, responding to events that occur during a test run. | |
| IRunner | org.flexunit.runner | An IRunner runs tests and notifies a org.flexunit.runner.notification.RunNotifier of significant events as it does so. | |
| IRunnerBuilder | org.flexunit.runners.model | An IRunnerBuilder is a strategy for constructing IRunners for classes. Only writers of custom runners should use IRunnerBuilders. | |
| IRunNotifier | org.flexunit.runner.notification | IRunNotifiers are a type of class that FlexUnit4 uses to notify others of an event that occurred during testing. | |
| ISequenceAction | org.fluint.sequence | Interface that defines the requisite methods for the sequence classes. | |
| ISequencePend | org.fluint.sequence | Interface defined by any step who's primary purpose is to pend (or wait) for an action to occur before continuing the test. | |
| ISequenceStep | org.fluint.sequence | Interface describing a step in a sequence | |
| ISort | org.flexunit.runner.manipulation | Marker interface | |
| ISortable | org.flexunit.runner.manipulation | Interface for runners that allow sorting of tests. | |
| ISorter | org.flexunit.runner.manipulation | Sorters should implement this interface. | |
| ISortingInheritanceCache | org.flexunit.runner.manipulation.sortingInheritance | Interface for caching implementation that will allow querying of the inheritance order of a given method relative to its definition super and subclasses | |
| IStatement | org.flexunit.runners.model | Represents one or more actions to be taken at runtime in the course of running a FlexUnit test suite. | |
| ITemporalRunListener | org.flexunit.runner.notification | Interface to be implemented by a listener that needs information on a test methods total execution time. | |
| ITestResponder | org.flexunit.async | An ITestResponder is an interface for to be implemented by classes that want to handle the results of running a test. | |
| IVisualEnvironmentBuilder | org.fluint.uiImpersonation | Implemented by classes capable of building a visual test environment for the UIImpersonator to use | |
| IVisualTestEnvironment | org.fluint.uiImpersonation | Implemented by visual test environment facades | |
| Klass | flex.lang.reflect | Takes a Class defintion and converts it into an XML form this Klass is then used by FlexUnit to run methods associated with the Class | |
| MetaDataAnnotation | flex.lang.reflect.metadata | An object representing an annotation represented as a metadata tag, in the example [Test(arg="1")] Test is the annotation. | |
| MetaDataAnnotationBuilder | flex.lang.reflect.builders | ||
| MetaDataArgument | flex.lang.reflect.metadata | An object representing an argument of a metadata tag, in the example [Test(arg="1")] arg="1" is the argument. | |
| MetaDataBuilder | org.flexunit.internals.builders | The MetaDataBuilder potentially builds an IRunner runner that is specificed in the metadata tag for a specific test class. | |
| MetadataTools | flex.lang.reflect.utils | The MetadataTools contains methods that are responsible for the parsing and interpretation of XML metadata. | |
| Method | flex.lang.reflect | An object representing a method of a class or instance. | |
| MethodBuilder | flex.lang.reflect.builders | Object responsible for building method objects | |
| MethodCompleteWithParamsStatement | org.flexunit.experimental.runners.statements | The MethodCompleteWithParamsStaetement is responsible for executing a theory method with a single set of parameters. | |
| MethodNameFilter | org.flexunit.runner.manipulation.filters | Filter that matches method names. | |
| MethodRuleBase | org.flexunit.internals.runners.statements | Base implemention class for an IMethodRule. | |
| MultiMatcher | org.flexunit.events.rule | ||
| MultipleFailureException | org.flexunit.internals.runners.model | The MultipleFailureExecption is used to store information on multiple errors that were encountered during the execution of a task. | |
| NoTestsRemainException | org.flexunit.runner.manipulation | Thrown when a Filter removes all tests from an IRunner. | |
| NullBuilder | org.flexunit.internals.builders | The NullBuilder does not build an IRunner. | |
| OnlyRecognizedTestClassBuilder | org.flexunit.internals.builders | Unlike theAllDefaultPossibilitiesBuilder which always returns a test runner for a test by choosing the FlexUnit 4 builder as the default, this Builder only returns builders for recognized tests types. | |
| OrderArgumentPlusAlphaSorter | org.flexunit.runner.manipulation | A MetadataSorter compares two values to determine which value is greater. | |
| OrderArgumentPlusInheritanceSorter | org.flexunit.runner.manipulation | A MetadataSorter compares two values to determine which value is greater. | |
| OrderArgumentSorter | org.flexunit.runner.manipulation | A MetadataSorter compares two values to determine which value is greater. | |
| Parameterized | org.flexunit.runners | ||
| ParameterizedAssertionError | org.flexunit.experimental.theories.internals | Thrown when an assertion is false and provides the parameters that caused the test to fail. | |
| ParameterizedMethod | org.flexunit.runners.model | Used to expand on the number of methods in a class in the presence of a TestNG style Parameterized runner where a Test is provided a dataProvider. | |
| ParameterSignature | org.flexunit.experimental.theories | The ParameterSignature is the signautre for a specific parameter in a theory method. | |
| ParentRunner | org.flexunit.runners | The ParentRunner provides most of the functionality specific to an IRunner that implements a "parent node" in the test tree. | |
| PotentialAssignment | org.flexunit.experimental.theories | A PotentialAssignment stores information for a particular value that is assigned to a parameter in a theory method. | |
| QualifyingRequest | org.flexunit.internals.requests | A QualifyingRequest is a request that verifies each class passed to it is in fact a viable test before attempting to include it. | |
| QuantityMatcher | org.flexunit.events.rule | ||
| Request | org.flexunit.runner | A Request is an abstract description of tests to be run. | |
| Result | org.flexunit.runner | A Result collects and summarizes information from running multiple tests. | |
| RunAfters | org.flexunit.internals.runners.statements | The RunAfters is a SequencerWithDecoration for potential methods that have After metadata and should be run after a test has finished. | |
| RunAftersClass | org.flexunit.internals.runners.statements | The RunAftersClass is a SequencerWithDecoration for potential methods that have AfterClass metadata and should be run after all of the tests in the test class have finished. | |
| RunAftersInline | org.flexunit.internals.runners.statements | Runs the [After] methods of a test in the BlockFlexUnit4ClassRunner inline after the actual test has executed. | |
| RunBefores | org.flexunit.internals.runners.statements | The RunBefores is a SequencerWithDecoration for potential methods that have Before metadata and should be run before a test has started. | |
| RunBeforesClass | org.flexunit.internals.runners.statements | The RunBeforesClass is a SequencerWithDecoration for potential methods that have BeforeClass metadata and should be run before the test class has been created. | |
| RunBeforesInline | org.flexunit.internals.runners.statements | Runs the [Before] methods of a test in the BlockFlexUnit4ClassRunner inline before procceding to the actual test. | |
| RunListener | org.flexunit.runner.notification | If you need to respond to the events during a test run, extend RunListener and override the appropriate methods. | |
| RunnerBuilderBase | org.flexunit.runners.model | The RunnerBuilderBase is used as a base by other runner builders in FlexUnit4. | |
| RunNotifier | org.flexunit.runner.notification | The RunNotifier is a class that FlexUnit4 uses to notify registered IRunListeners of an event that occurred during testing. | |
| SequenceBindingWaiter | org.fluint.sequence | The sequence setter class tells the TestCase instance to pend until the eventName occurs or the timeout expires. | |
| SequenceCaller | org.fluint.sequence | A sequence step that calls a method | |
| SequenceDelay | org.fluint.sequence | A sequence step that delays the sequence for a given time period. | |
| SequenceEventDispatcher | org.fluint.sequence | The sequencer event dispatcher class is used by the TestCase sequence code to broadcast an event from a target. | |
| SequenceRunner | org.fluint.sequence | Allows developer to add a series of steps, execute those steps in order, until the sequence is complete. | |
| SequencerWithDecoration | org.flexunit.internals.runners.statements | Classes that inherit SequencerWithDecoration are used to run methods that run either before or after a class or before or after a test. | |
| SequenceSetter | org.fluint.sequence | The sequence setter class tells the TestCase instance to set properties on the target. | |
| SequenceWaiter | org.fluint.sequence | The sequence setter class tells the TestCase instance to pend until the eventName occurs or the timeout expires. | |
| Sorter | org.flexunit.runner.manipulation | A Sorter orders tests. | |
| SortingRequest | org.flexunit.internals.requests | A Request that sorts the ordering in a test class. | |
| StackAndFrameManagement | org.flexunit.internals.runners.statements | The StackAndFrameManagement decorator implements green threading to deal with flash frames. | |
| StatementSequencer | org.flexunit.internals.runners.statements | The StatementSequencer is a class that is responsible for the execution of IAsyncStatements. | |
| StoppedByUserException | org.flexunit.runner.notification | Thrown when a user has requested that the test run stop. | |
| Suite | org.flexunit.runners | A Suite is an IRunner that contains test cases and other Suites to be run during the course of a test run. | |
| SuiteMethod | org.flexunit.internals.runners | Extends FlexUnit1ClassRunner SuiteMethod adds in the testFromSuiteMethod static class that is used to create a suite method from the passed in Class | |
| SuiteMethodBuilder | org.flexunit.internals.builders | The SuiteMethodBuilder potentially builds a SuiteMethod for a provided testClass. | |
| TestClass | org.flexunit.runners.model | The TestClass wraps a class that is to be executing, providing method validation and annotation searching. | |
| TestResponder | org.flexunit.async | A respoder for tests that contains Functions for the test succeeding or the test failing to succeed. | |
| TextListener | org.flexunit.internals | A TextListener will record the events encountered during the course of a test run in a logger. | |
| Theories | org.flexunit.experimental.theories | The Theories runner is a runner that will run theory test methods. | |
| TheoryAnchor | org.flexunit.experimental.runners.statements | The TheoryAnchor is responsible for keeping track of the progress of a particular theory method. | |
| TheoryBlockRunner | org.flexunit.experimental.runners.statements | The TheoryBlockRunner is a runner used for running an indiviudal theory method that has had all of its parameters assigned values. | |
| TheoryBlockRunnerStatement | org.flexunit.experimental.runners.statements | The TheoryBlockRunnerStatement is responsible for reporting whether the theory method with specific arguments was successful. | |
| TimeoutMonitor | org.flexunit.events.rule | ||
| TraceListener | org.flexunit.internals | A TraceListener will trace the events encountered during the course of a test run. | |
| UIImpersonator | org.fluint.uiImpersonation | Provides access to the visual test environment through static methods | |
| UnknownError | org.flexunit.events | ||
| VisualTestEnvironment | org.fluint.uiImpersonation | ||
| VisualTestEnvironmentBuilder | org.fluint.uiImpersonation | TestEnvironment is a singleton class that allows tests to have visual components. | |
| WaitingListener | org.flexunit.runner.notification.async | This class is simply to test async startup listeners | |
| XMLListener | org.flexunit.runner.notification.async |