offline scheduler

fluid.prettyPrintJSON(fluid.defaults("berg.test.scheduler.offlineTestSequencer"))
"{
    "gradeNames": [
        "berg.test.scheduler.offlineTestSequencer",
        "berg.test.scheduler.testSequencer",
        "fluid.modelComponent",
        "fluid.component",
        "berg.test.scheduler.testSequencer.offline"
    ],
    "listeners": {
        "onCreate": [
            {
                "priority": "first",
                "funcName": "QUnit.asyncTest",
                "args": [
                    "{that}.options.name",
                    "{that}.run"
                ],
                "nameSpace": "runTests",
                "componentSource": "berg.test.scheduler.testSequencer"
            }
        ],
        "onRun": [
            {
                "func": "{that}.evaluateRegistrationSequence",
                "componentSource": "berg.test.scheduler.testSequencer"
            },
            {
                "func": "{that}.startClock",
                "componentSource": "berg.test.scheduler.testSequencer"
            }
        ],
        "{scheduler}.clock.events.onTick": [
            {
                "funcName": "berg.test.scheduler.testSequencer.incrementTick",
                "args": [
                    "{that}.applier",
                    "{that}.model"
                ],
                "componentSource": "berg.test.scheduler.testSequencer"
            },
            {
                "func": "{that}.evaluateRegistrationSequence",
                "args": [
                    0
                ],
                "componentSource": "berg.test.scheduler.testSequencer"
            }
        ],
        "onScheduledEvent": [
            {
                "funcName": "berg.test.scheduler.testCallback",
                "args": [
                    "{scheduler}",
                    "{arguments}",
                    "{that}.options.scoreEventSpecs",
                    "{that}.options.expectedSequence",
                    "{that}.model.currentEventIdx"
                ],
                "componentSource": "berg.test.scheduler.testSequencer"
            },
            {
                "funcName": "berg.test.scheduler.testSequencer.updateModel",
                "args": [
                    "{that}.applier",
                    "{that}.model"
                ],
                "namespace": "updateModel",
                "componentSource": "berg.test.scheduler.testSequencer"
            },
            {
                "func": "{that}.testQueue",
                "componentSource": "berg.test.scheduler.testSequencer"
            },
            {
                "funcName": "berg.test.scheduler.testSequencer.startAfterSequenceEnds",
                "args": [
                    "{that}.model.currentEventIdx",
                    "{that}.options.expectedSequence",
                    "{scheduler}.clock"
                ],
                "componentSource": "berg.test.scheduler.testSequencer"
            }
        ]
    },
    "invokers": {
        "startClock": {
            "func": "{scheduler}.clock.start",
            "funcName": undefined,
            "listener": undefined,
            "this": undefined,
            "method": undefined,
            "args": [
                "{scheduler}.clock",
                "{that}.options.numTicks"
            ],
            "componentSource": "berg.test.scheduler.testSequencer"
        },
        "run": {
            "func": "{that}.events.onRun.fire",
            "funcName": undefined,
            "listener": undefined,
            "this": undefined,
            "method": undefined,
            "args": {
                "value": "NO_VALUE"
            },
            "componentSource": "berg.test.scheduler.testSequencer"
        },
        "evaluateRegistrationSequence": {
            "func": undefined,
            "funcName": "berg.test.scheduler.testSequencer.evaluateRegistrationSequence",
            "listener": undefined,
            "this": undefined,
            "method": undefined,
            "args": [
                "{that}"
            ],
            "componentSource": "berg.test.scheduler.testSequencer"
        },
        "scheduleEvent": {
            "func": undefined,
            "funcName": "berg.test.scheduler.testSequencer.scheduleEvent",
            "listener": undefined,
            "this": undefined,
            "method": undefined,
            "args": [
                "{scheduler}",
                "{arguments}.0"
            ],
            "componentSource": "berg.test.scheduler.testSequencer"
        },
        "testQueue": {
            "func": undefined,
            "funcName": "berg.test.scheduler.testQueue",
            "listener": undefined,
            "this": undefined,
            "method": undefined,
            "args": [
                "{scheduler}",
                "{that}.options.expectedSequence",
                "{that}.model.currentEventIdx"
            ],
            "componentSource": "berg.test.scheduler.testSequencer"
        }
    },
    "name": "No test name was defined!",
    "scoreEventSpecs": {
        
    },
    "registrationSequence": {
        
    },
    "expectedSequence": [],
    "model": [
        {
            "currentEventIdx": 0,
            "tick": 0
        }
    ],
    "schedulerOptions": {
        "components": {
            "clock": {
                "options": {
                    "freq": 0.1
                }
            }
        }
    },
    "components": {
        "scheduler": {
            "type": "berg.scheduler",
            "options": "{testSequencer}.options.schedulerOptions"
        }
    },
    "events": {
        "onRun": null,
        "onScheduledEvent": null,
        "onTick": null,
        "onCreate": null,
        "onDestroy": null,
        "afterDestroy": null
    },
    "changeApplierOptions": {
        "relayStyle": true,
        "cullUnchanged": true
    },
    "members": {
        "model": {
            "0": {
                "expander": {
                    "funcName": "fluid.initRelayModel",
                    "args": [
                        "{that}",
                        "{that}.modelRelay"
                    ]
                }
            },
            "length": 1
        },
        "applier": {
            "0": {
                "expander": {
                    "funcName": "fluid.makeHolderChangeApplier",
                    "args": [
                        "{that}",
                        "{that}.options.changeApplierOptions"
                    ]
                }
            },
            "length": 1
        },
        "modelRelay": {
            "0": {
                "expander": {
                    "funcName": "fluid.establishModelRelay",
                    "args": [
                        "{that}",
                        "{that}.options.model",
                        "{that}.options.modelListeners",
                        "{that}.options.modelRelay",
                        "{that}.applier"
                    ]
                }
            },
            "length": 1
        }
    },
    "mergePolicy": {
        "model": {
            "noexpand": true,
            "func": { Function
                
            }
        },
        "modelListeners": { Function
            
        },
        "modelRelay": {
            "noexpand": true,
            "func": { Function
                
            }
        },
        "gradeNames": { Function
            
        },
        "distributeOptions": { Function
            
        },
        "members": {
            "noexpand": true,
            "func": { Function
                
            }
        },
        "invokers": {
            "noexpand": true,
            "func": { Function
                
            }
        },
        "transformOptions": "replace",
        "listeners": { Function
            
        }
    },
    "initFunction": "fluid.initLittleComponent",
    "argumentMap": {
        "options": 0
    }
}"