API Documentation | All Packages | Index | Frames No Frames |
All Classes

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.2.0 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 |

Thu Apr 10 2014, 08:07 AM +10:00