var a:int = 2 + 3 * 10;

var a:int = 32;

public function ServiceOwner

{

    private var _service:IService;

    public static function get service():IService

    {

          if (_service == null)

          {

               _service = new MyService();

           }

           return _service;

    }

}

package tests

{

        import com.***.net.tcp.NinjaEvent;

        import com.***.net.tcp.NinjaMethods;

        import com.***.net.tcp.NinjaService;

 

        import flash.events.Event;

 

        import flexunit.framework.Assert;

 

        import org.flexunit.async.Async;

 

        public class TestNinjaKillActivity

        {

                private var _activityDead:Boolean;

                // Падаван хотел это сделать синглотоном :) А тут внезапно их два - облом :)

                private var _sender:NinjaService = 

                        new NinjaService("123456", "127.0.0.1");

                private var _receiver:NinjaService = 

                        new NinjaService("654321", "127.0.0.1");

 

                public function TestNinjaKillActivity() { super(); }

 

                [Before(async)]

                public function before():void

                {

                        this._sender.addEventListener(Event.CONNECT, this.sender_connectHandler);

                        this._receiver.addEventListener(

                                Event.CONNECT, this.receiver_connectHandler);

                        this._receiver.addEventListener(

                                NinjaEvent.GET_ACTION, this.getActionHandler);

                        this._receiver.addEventListener(

                                NinjaEvent.CALL_RECEIVED, this.receiver_callReceivedHandler);

                        this._sender.addEventListener(

                                NinjaEvent.CALL_STARTED, this.sender_callStartedHandler);

                        Async.proceedOnEvent(this, this._receiver, "test", 10000);

                        this._sender.connect();

                        this._receiver.connect();

                }

 

                private function sender_connectHandler(event:Event):void

                {

                        if (this._receiver.connected) this.bothConnected();

                        trace("sender_connectHandler");

                }

 

                private function receiver_connectHandler(event:Event):void

                {

                        if (this._sender.connected) this.bothConnected();

                        trace("receiver_connectHandler");

                }

 

                private function sender_callStartedHandler(event:NinjaEvent):void

                {

                        this.killActivity();

                        trace("sender_callStartedHandler");

                }

 

                private function receiver_callReceivedHandler(event:NinjaEvent):void

                {

                        (this._receiver.methods as NinjaMethods)

                        .acceptCall(this._sender.clientId);

                        trace("receiver_callReceivedHandler");

                }

 

                public function bothConnected():void

                {

                        (this._sender.methods as NinjaMethods)

                        .startCall(this._receiver.clientId, "externalId", "a", "b", "c", "d");

                        trace("bothConnected");

                }

 

                private function killActivity():void

                {

                        (this._sender.methods as NinjaMethods)

                                .killActivity(this._receiver.clientId);

                }

 

                private function getActionHandler(event:NinjaEvent):void

                {

                        this._activityDead = true;

                        this._receiver.dispatchEvent(new Event("test"));

                        this.testReceive();

                        trace("getActionHandler");

                }

 

                [Test(async, timeout="10000")]

                public function testReceive():void

                {

                        Assert.assertTrue(this._activityDead);

                }

        }

}