package
{
    import flash.display.*;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.system.Capabilities;
    import flash.text.*;
    import flash.utils.*;

    /**
    *   An app to test function call performance
    *   @author Jackson Dunstan
    */
    public class FunctionPerformanceTest extends Base implements IInterface
    {
        private function privateFunction(): void {}
        protected function protectedFunction(): void {}
        internal function internalFunction(): void {}
        public function publicFunction(): void {}

        private function get privateGetFunction(): int { return 0; }
        protected function get protectedGetFunction(): int { return 0; }
        internal function get internalGetFunction(): int { return 0; }
        public function get publicGetFunction(): int { return 0; }

        private function set privateSetFunction(val:int): void {}
        protected function set protectedSetFunction(val:int): void {}
        internal function set internalSetFunction(val:int): void {}
        public function set publicSetFunction(val:int): void {}

        private static function staticPrivateFunction(): void {}
        protected static function staticProtectedFunction(): void {}
        internal static function staticInternalFunction(): void {}
        public static function staticPublicFunction(): void {}

        override protected function overrideProtectedFunction(): void {}
        override internal function overrideInternalFunction(): void {}
        override public function overridePublicFunction(): void {}

        final private function finalPrivateFunction(): void {}
        final protected function finalProtectedFunction(): void {}
        final internal function finalInternalFunction(): void {}
        final public function finalPublicFunction(): void {}

        final override protected function finalOverrideProtectedFunction(): void {}
        final override internal function finalOverrideInternalFunction(): void {}
        final override public function finalOverridePublicFunction(): void {}

        public function interfaceFunction(): void {}

        private var logger:TextField;
        private const ITERATIONS:int = 10000000;
        private var testing:Boolean;

        /**
        *   Application entry point
        */
        public function FunctionPerformanceTest() {
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            logger = new TextField();
            logger.autoSize = TextFieldAutoSize.LEFT;
            addChild(logger);
            log("          Click to test.");
            graphics.beginFill(0xFFFFFF);
            graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
            graphics.endFill();

            addEventListener(MouseEvent.CLICK, init);
        }

        private function setVersionString():void {
            logger.text = "  ";
            logger.appendText((Capabilities.supports64BitProcesses ? "64" : Capabilities.supports32BitProcesses ? "32" : "16") + " bit ");
            logger.appendText(Capabilities.os + " ");
            logger.appendText(Capabilities.cpuArchitecture + " ");
            logger.appendText(Capabilities.version.split(",").join(".").split(" ")[1] + " ");
            logger.appendText(Capabilities.isDebugger ? "Debug " : "Release ");
            logger.appendText(Capabilities.playerType);
            logger.appendText("\n");
        }

        private function init(ev:Event = null):void {
            if (!testing) {
                testing = true;
                setVersionString();
                addEventListener(Event.ENTER_FRAME, testDynamicFunctions);
            }
        }

        private function testDynamicFunctions(ev:Event): void {
            removeEventListener(Event.ENTER_FRAME, testDynamicFunctions);
            var beforeTime:int;
            var i:int;
            const NUM_ITERATIONS:int = ITERATIONS;

            function localFunction(): void {}
            var functionVarFunction:Function = function(): void {}

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                localFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Local  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                functionVarFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Local Function var " + beforeTime);

            log("");

            addEventListener(Event.ENTER_FRAME, testCalls);
        }

        private function testCalls(ev:Event):void {
            removeEventListener(Event.ENTER_FRAME, testCalls);
            var beforeTime:int;
            var i:int;
            const NUM_ITERATIONS:int = ITERATIONS;

            var functionVarFunction:Function = this.finalPrivateFunction;
            var functionVarFunction2:Function = functionVarFunction.apply;

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                plainFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Plain  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                functionVarFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("NonLocal Function var  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                functionVarFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("NonLocal Function var 'call' direct    " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                functionVarFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("NonLocal Function var 'apply' direct   " + beforeTime);

            functionVarFunction = functionVarFunction.call;

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                functionVarFunction(null);
            }
            beforeTime = getTimer()-beforeTime;
            log("NonLocal Function var 'call' indirect  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                functionVarFunction2(null);
            }
            beforeTime = getTimer()-beforeTime;
            log("NonLocal Function var 'apply' indirect " + beforeTime);

            log("");

            addEventListener(Event.ENTER_FRAME, testMethods);
        }

        private function testMethods(ev:Event): void {
            removeEventListener(Event.ENTER_FRAME, testMethods);
            var beforeTime:int;
            var i:int;
            const NUM_ITERATIONS:int = ITERATIONS;

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                privateFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Private    " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                protectedFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Protected  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                internalFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Internal   " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                publicFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Public " + beforeTime);

            log("");

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                this.privateFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("this.Private   " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                this.protectedFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("this.Protected " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                this.internalFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("this.Internal  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                this.publicFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("this.Public    " + beforeTime);

            log("");

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                staticPrivateFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Static private " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                staticProtectedFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Static protected   " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                staticInternalFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Static internal    " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                staticPublicFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Static public  " + beforeTime);

            log("");

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                overrideProtectedFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Override protected " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                overrideInternalFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Override internal  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                overridePublicFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Override public    " + beforeTime);

            log("");

            addEventListener(Event.ENTER_FRAME, testSupersAndInterfaces);
        }

        private function testSupersAndInterfaces(ev:Event): void {
            removeEventListener(Event.ENTER_FRAME, testSupersAndInterfaces);
            var beforeTime:int;
            var i:int;
            const NUM_ITERATIONS:int = ITERATIONS;

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                super.overrideProtectedFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Super protected    " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                super.overrideInternalFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Super internal " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                super.overridePublicFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Super public   " + beforeTime);

            log("");

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                interfaceFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Interface direct   " + beforeTime);

            var inter:IInterface = this;
            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                inter.interfaceFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Interface via interface    " + beforeTime);

            var clazz:FunctionPerformanceTest = this;
            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                clazz.interfaceFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Interface via class    " + beforeTime);

            log("");

            addEventListener(Event.ENTER_FRAME, testGettersAndSetters);
        }

        private function testGettersAndSetters(ev:Event): void {
            removeEventListener(Event.ENTER_FRAME, testGettersAndSetters);
            var beforeTime:int;
            var i:int;
            const NUM_ITERATIONS:int = ITERATIONS;

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                privateGetFunction;
            }
            beforeTime = getTimer()-beforeTime;
            log("Private Get    " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                protectedGetFunction;
            }
            beforeTime = getTimer()-beforeTime;
            log("Protected Get  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                internalGetFunction;
            }
            beforeTime = getTimer()-beforeTime;
            log("Internal Get   " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                publicGetFunction;
            }
            beforeTime = getTimer()-beforeTime;
            log("Public Get " + beforeTime);

            log("");

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                privateSetFunction = 0;
            }
            beforeTime = getTimer()-beforeTime;
            log("Private Set    " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                protectedSetFunction = 0;
            }
            beforeTime = getTimer()-beforeTime;
            log("Protected Set  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                internalSetFunction = 0;
            }
            beforeTime = getTimer()-beforeTime;
            log("Internal Set   " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                publicSetFunction = 0;
            }
            beforeTime = getTimer()-beforeTime;
            log("Public Set " + beforeTime);

            log("");

            addEventListener(Event.ENTER_FRAME, testFinals);
        }

        private function testFinals(ev:Event): void {
            removeEventListener(Event.ENTER_FRAME, testFinals);
            var beforeTime:int;
            var i:int;
            const NUM_ITERATIONS:int = ITERATIONS;

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                finalPrivateFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Final Private  " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                finalProtectedFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Final Protected    " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                finalInternalFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Final Internal " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                finalPublicFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Final Public   " + beforeTime);

            log("");

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                finalOverrideProtectedFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Final Override protected   " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                finalOverrideInternalFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Final Override internal    " + beforeTime);

            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                finalOverridePublicFunction();
            }
            beforeTime = getTimer()-beforeTime;
            log("Final Override public  " + beforeTime);

            testing = false;
        }

        private function log(msg:*): void {
            logger.appendText(msg + "\n");
        }
    }
}
internal function plainFunction(): void {}
internal interface IInterface {
    function interfaceFunction(): void;
}