Flash and Flex

Performance Performance Performance

2011-07-11T14:52:00.000-07:00

Just how well can we measure performance?...Check this link.

briangenisio / ActionLinq / wiki / Home – Bitbucket

2011-01-04T17:03:00.000-08:00

briangenisio / ActionLinq / wiki / Home – Bitbucket
briangenisio / ActionLinq http://HouseOfBilz.com/

ActionLinq is a complete implementation of LINQ extensions for ActionScript 3. Although it follows ActionScript idoms, all of the expected functionality is there including deferred execution

Code Metrics with Sonar

2010-12-13T02:49:00.000-08:00

Sonar is a web service that allows you to perform code analysis on projects it has a plugin for flex projects that utilises FlexPMD, FlexCPD and FlexMetrics that can give you insight on the quality of the code in your project worth a look.

http://www.sonarsource.org/the-flex-plugin-for-sonar-a-further-step-toward-multi-language-support/

Get The Blueprint

2010-10-06T19:03:00.001-07:00

Blueprint is a plugin for Adobe® Flex® Builder™ 3 and Flash® Builder™ 4 that allows users to query for Adobe Flex and Adobe Flash code examples found on the Web directly inside of the development environment.

Give it a try http://labs.adobe.com/technologies/blueprint/

ErrorTestUtils

2010-04-27T09:35:00.001-07:00

package domain.utils
{
public class ErrorTestUtils
{
public function ErrorTestUtils()
{
}

public static function isErrorThrown(callMethodThatCausesError:Function,errorReport:String,args:Array):Boolean
{
var errorThrown:Boolean = false;
try
{
callMethodThatCausesError.apply(null,args);
}
catch(e:Error)
{
errorThrown = (e.message == errorReport)
}

return errorThrown;
}

}
}

Posted via email from fasanya's posterous

Testing Thrown Error Handling

2010-04-27T09:23:00.001-07:00

A quick way to test thrown errors are behaving as expected.

[Test]
public function testErrorHandling():void
{

            var errorThrown:Boolean = false;

            try
            {
                callMethodThatCausesError();
            }
            catch (e:Error)
            {
                errorThrown = (e.message == 'SomeClass.ERROR_IN_DATA_MESSAGE');
            }

            assertTrue(errorThrown);
        }

Posted via email from fasanya's posterous

Doc File Import Folder So you can move asdocs from pc to pc.

2010-04-27T08:27:00.001-07:00

C:\Documents and Settings\Lyndon Fasanya\Application Data\Doc.EE57A57224685151543546B0367A0BD876BF88FF.1\Local Store

Posted via email from fasanya's posterous

Improving application performance.

2010-04-24T10:10:00.001-07:00

Ways to improve app performance!!!!

Improving Performance of Charting Components

Performance Tuning and Profiling Your Own Flex Application

Support and Feedback

Sent from my iPhone

Posted via email from fasanya's posterous

Channels endpoints and destinations, AIR and Flex, courtesy of weborb and midnightcoders

2010-04-20T16:06:00.001-07:00

Endpoint - this is the URL where AIR/Flex app sends remoting/messaging requests to

Channel - a concept encapsulating the endpoint. Also identifies classes managing the channel on both client and server sides

Destination - identifies a server-side class exposed by WebORB. Used by Flex/AIR client to target method invocations against the referenced class.

Channels are configured in WEB-INF/flex/services-config.xml (and
weborb-services-config.xml if present in your system). Every channel has the "endpoint" element. For example, you have the following
channel definition:

<channel-definition id="my-amf"
class="mx.messaging.channels.AMFChannel">
<endpoint uri="weborb.php"
class="flex.messaging.endpoints.AMFEndpoint"/>
<properties>
<polling-enabled>false</polling-enabled>
</properties>
</channel-definition>

Notice the following line:

<endpoint uri="weborb.php"

"weborb.php" here is actually a URL. The reason it does not look like a URL is because it is relative. If your Flex app is loaded from

http://myhost/foo/AwesomeApp.html

then your application will be sending remoting requests to the following URL:

http://myhost/foo/weborb.php

(This is the reason why WebORB for PHP requires that you put weborb.php into the same directory containing your SWF.)

So how does the client know what channel to use. The answer lies in remoting-config.xml. This is where all the destinations are defined.
Most of the destinations do not explicitly reference the channels. For those, there's a special declaration at the top that establishes the default channel:

<default-channels>
<channel ref="my-amf"/>
</default-channels>

As a result, when you create a RemoteObject to talk to GenericDestination, remoting requests will be sent to the endpoint defined in the my-amf channel.

Now, suppose you need to get AIR to talk to WebORB. Obviously the my-amf channel will not work for you since the endpoint is relative.
You can definitely change the endpoint to be an absolute URL and it will solve the problem. Alternatively, take a look at the channel with
the following ID:

my-air-amf

Notice the endpoint URL for that channel is absolute. Now take a look at the GenericAIRDestination destination in remoting-config.xml. You will see it references the my-air-amf channel. As a result, if your
AIR application uses "GenericAIRDestination", your AIR client will talk to WebORB and send remoting requests to the endpoint URL from the
my-air-amf channel. It is important to adjust the URL to reflect the location of your WebORB instance.

Posted via email from fasanya's posterous

Using Enterprise Architect to create a Class Model from an AS project.

2010-04-15T15:06:00.001-07:00

1. Open EA the application.
2. From the app (if plugin in Eclipse select the Enterprise Architect option then ) Create a New Project.
3. Navigate to where you want your project to placed.
4. Your Project Browser perspective should be open and you'll see a tab called Model this is the project you've just created a project is a collection models in EA. Select it.
5. Right Click on this and select 'Add a new model' using wizard.
6. Check the class model box. and Ok this, a class model icon will appear under the model icon in your project.
7. Right Click on the Class Model folder looking icon (not the blue one).
8. Mouse Over Code Engineering and select 'Import Source Directory'.
9. In the dialog box select ActionScript ensure file extension are .as and the options you prefer
10. Choose the Root Directory you want to generate a Class Model for.

11. To generate rtf documentation select the icon 4th from right on the toolbar with OR select F8 it looks like lines with ticks and crosses although there are two of them.

Posted via email from fasanya's posterous

Mockito Test Structures

2010-04-15T06:57:00.001-07:00

/*    Generalisation for verifying a method (testedFunction) of system under test (sut)
            is called that depends on a method (someOperation) of (dependency)

            var dependency:Dependency = Dependency(mock(Dependency));
            // given
            var sut:Sut = new Sut(dependency);
            // when
            sut.testedFunction(10);
            // then
            mockito.verify().that(dependency.someOperation(10));
        */

Posted via email from fasanya's posterous

Comprehensive Documentation

2010-04-13T08:02:00.001-07:00

Now there's a one stop shop, for the Flash Platform API checkout the ActionScript 3.0 Reference for the Adobe Flash Platform.

http://help.adobe.com/en_US/FlashPlatform//reference/actionscript/3/index.html?filter_flex=4

Posted via email from fasanya's posterous

flash flex links and resources courtesy of jexchen hence some chinese characters!

2010-04-10T17:53:00.001-07:00

Flash, Flex resources collected Shiquandabu

07月23rd, 2008 Posted in ActionScript3 , Collection , Flash , Flex3 , Lib , RIA , Tool July 23rd, 2008 Posted in ActionScript3 , Collection , Flash , Flex3 , Lib , RIA , Tool

断断续续收集了Flash、Flex相关的不少资源，但好多存着都没看，加上自己没太整理好，反而到想找的时候找不到。 Intermittent collection of Flash, Flex-related resources, it has a lot of deposit with no view, coupled with his order not too good, but can not find the time to looking. 在此做个“十全大补”，来个群英汇萃，一来方便自己，二来大家也可参考参考。 This to be a "Shiquandabu" to a Beat Festival, the one convenience, and second, you can refer to the reference. 这些资源均来自网上，感谢这些作者们。 These resources are from the Internet, for these authors. 不断更新中…… Constantly update ... ...

[毕竟是自己辛苦整理的，转载的话请注明出处： http://www. jexchen .com谢谢] [After all their hard order, and reproduced if the source is acknowledged: http://www. jexchen. COM Thank you]

APIs、Libs、Components APIs, Libs, Components

1、 as3ebaylib 1, as3ebaylib
http://code.google.com/p/as3ebaylib/ http://code.google.com/p/as3ebaylib/
2、 as3youtubelib 2, as3youtubelib
http://code.google.com/p/as3youtubelib/ http://code.google.com/p/as3youtubelib/
3、 as3flickrlib 3, as3flickrlib
http://code.google.com/p/as3flickrlib/ http://code.google.com/p/as3flickrlib/
4、 Yahoo ASTRA Flash Components 4, Yahoo ASTRA Flash Components
http://developer.yahoo.com/flash/astra-flash/ http://developer.yahoo.com/flash/astra-flash/
5、 facebook-as3 5, facebook-as3
http://code.google.com/p/facebook-as3/ http://code.google.com/p/facebook-as3/
6、 as3awss3lib 6, as3awss3lib
http://code.google.com/p/as3awss3lib/ http://code.google.com/p/as3awss3lib/
7、 Adobe ActionScript 3:resources:apis:libraries （官方，包括corelib、FlexUnit、Flickr、Mappr、RSS and Atom libraries、Odeo、YouTube） 7, Adobe ActionScript 3: resources: apis: libraries (government, including the corelib, FlexUnit, Flickr, Mappr, RSS and Atom libraries, Odeo, YouTube)
http://labs.adobe.com/wiki/index.php/ActionScript_3:resources:apis:libraries http://labs.adobe.com/wiki/index.php/ActionScript_3:resources:apis:libraries
8、 Tweener用于过渡与切换的一组动画库 8, Tweener for the transition and to switch a group of animation library
http://code.google.com/p/tweener/ http://code.google.com/p/tweener/
9、 uicomponents-as3一组轻量级的AS3 UI组件库 9, uicomponents-as3 a lightweight AS3 UI component library
http://code.google.com/p/uicomponents-as3/ http://code.google.com/p/uicomponents-as3/
10、 as3ds AS3的数据结构实现 10, as3ds AS3 data structures to achieve
http://code.google.com/p/as3ds/ http://code.google.com/p/as3ds/

11、 mecheye-as3-libraries一组主要用于Flash 游戏开发的AS3库 11, mecheye-as3-libraries of a major group of game development for Flash AS3 library
http://code.google.com/p/mecheye-as3-libraries/ http://code.google.com/p/mecheye-as3-libraries/
12、 XIFF一套XMPP协议的AS3实现 12, XIFF AS3 implementation of a XMPP protocol
http://svn.igniterealtime.org/svn/repos/xiff/branches/xiff_as3_flexlib_beta1/ http://svn.igniterealtime.org/svn/repos/xiff/branches/xiff_as3_flexlib_beta1/
13、 FZip一套AS3库，可用作对ZIP压缩文件的载入、修改与创建 13, FZip a AS3 library can be used as the load on the ZIP compressed files, modify and create
http://codeazur.com.br/lab/fzip/ http://codeazur.com.br/lab/fzip/
14、 FlexLib一套开源的Flex界面组件库 14, FlexLib a set of open source Flex component library interface
http://code.google.com/p/flexlib/ http://code.google.com/p/flexlib/
15、 AnimatedGIfLoader Flex Component可载入GIF的Flex组件 15, AnimatedGIfLoader Flex Component can be loading GIF in Flex component
http://dougmccune.com/blog/animatedgifloader-flex-component/ http://dougmccune.com/blog/animatedgifloader-flex-component/
16、 goplayground一套轻量级的，可用创建属于你自己的AS3 动画工具的库 16, goplayground a lightweight, can be used to create your own AS3 animation tools library
http://code.google.com/p/goplayground/ http://code.google.com/p/goplayground/
17、 AlivePDF开源的用于PDF创建的AS3库 17, AlivePDF open source library for PDF creation in AS3
http://www.alivepdf.org/ http://www.alivepdf.org/
18、 jwopitz-lib一组开源的Flex用户界面组件 18, jwopitz-lib a set of open source Flex user interface components
http://code.google.com/p/jwopitz-lib/ http://code.google.com/p/jwopitz-lib/
19、 as3crypto AS3实现的一套加密库，包括多种加密算法 19, as3crypto AS3 implementation of a cryptographic library, including a variety of encryption algorithms
http://code.google.com/p/as3crypto/ http://code.google.com/p/as3crypto/
20、 flare一套强大的可视化交互的AS3类库 20, flare of a powerful visual interactive AS3 library
http://flare.prefuse.org/ http://flare.prefuse.org/
21、 SWFAddress一小而强大的库，可以为Flash和Ajax提供深链接的功能 21, SWFAddress a small but powerful library for Flash and Ajax features to provide deep links
http://www.asual.com/swfaddress/ http://www.asual.com/swfaddress/
22、 SWFObject用于嵌入Flash，Adobe官方也认可了 22, SWFObject to embed Flash, Adobe has officially recognized
http://code.google.com/p/swfobject/ http://code.google.com/p/swfobject/
23、 ulse Particle System一套开源的强大的AS3动态粒子系统 23, ulse Particle System a set of open source AS3 powerful dynamic particle system
http://code.google.com/p/pulse-particle/ http://code.google.com/p/pulse-particle/
http://www.rogue-development.com/pulseParticles.html http://www.rogue-development.com/pulseParticles.html
24、 SpringGraph Flex Component 24, SpringGraph Flex Component
http://mark-shepherd.com/blog/springgraph-flex-component/ http://mark-shepherd.com/blog/springgraph-flex-component/
25、 GoASAP AS3动画库 25, GoASAP AS3 Animation Library
http://code.google.com/p/goasap/ http://code.google.com/p/goasap/
http://www.goasap.org/index.html http://www.goasap.org/index.html
26、 asaplibrary一套开源的Flash Actionscript3.0 RIA库 26, asaplibrary a set of open source Flash Actionscript3.0 RIA Library
http://code.google.com/p/asaplibrary/ http://code.google.com/p/asaplibrary/
http://asaplibrary.org/ http://asaplibrary.org/
http://asapframework.org http://asapframework.org
27、 as3mathlib开源Flex/Actionscript数学库 27, as3mathlib open source Flex / Actionscript Math Library
http://code.google.com/p/as3mathlib/ http://code.google.com/p/as3mathlib/
28、 as3corelib包含一些基础功能AS3库 28, as3corelib AS3 library contains some basic functions
http://code.google.com/p/as3corelib/ http://code.google.com/p/as3corelib/
29、 minimalcomps一组AS3 UI组件 29, minimalcomps a AS3 UI Components
http://www.bit-101.com/minimalcomps/ http://www.bit-101.com/minimalcomps/
30、 as3gif 30, as3gif
http://code.google.com/p/as3gif/ http://code.google.com/p/as3gif/
31、 queueloader-as3一组AS3库，用来进行资源序列载入及监测 31, queueloader-as3 a AS3 library sequence used for loading and monitoring resources
http://code.google.com/p/queueloader-as3/ http://code.google.com/p/queueloader-as3/
32、 TweenMax (AS3) 32, TweenMax (AS3)
http://blog.greensock.com/tweenmaxas3/ http://blog.greensock.com/tweenmaxas3/
33、 Atellis Reflection Component一款Flex反射效果组件 33, Atellis Reflection Component effect of a reflection component Flex
http://labs.atellis.com/2007/07/11/atellis-reflection-component/ http://labs.atellis.com/2007/07/11/atellis-reflection-component/
34、 AS3Eval简单来说，就是用AS3实现的AS3编译器 34, AS3Eval simply put, is realized with AS3 AS3 compiler
http://eval.hurlant.com/ http://eval.hurlant.com/
35、 ByteArray的组件、库合集，包括liquid components、mousegesture、ASZip、GIF Player、GIF Animation Encoder、AlivePDF、Live JPEG Encoder、ScaleBitmap等 35, ByteArray component, library collection, including liquid components, mousegesture, ASZip, GIF Player, GIF Animation Encoder, AlivePDF, Live JPEG Encoder, ScaleBitmap etc.
http://www.bytearray.org/?page_id=82 http://www.bytearray.org/?page_id=82
36、 AS3C针对AVM2虚拟机，用C#写的字节码编译器 36, AS3C for AVM2 virtual machine, using C # to write the byte-code compiler
http://code.google.com/p/as3c/ http://code.google.com/p/as3c/
37、 as3httpclientlib as3实现的http客户端 37, as3httpclientlib as3 http client implementation
http://code.google.com/p/as3httpclientlib/ http://code.google.com/p/as3httpclientlib/
38、 as3ui一组常规的as3 ui界面库 38, as3ui a conventional as3 ui interface library
http://code.google.com/p/as3ui/ http://code.google.com/p/as3ui/
39

Posted via email from fasanya's posterous

Using registerClassAlias

2010-04-08T09:04:00.001-07:00

NOTE: registerClassAlias should be called before any instances of the class you are aliasing is instantiated!!!!!

The contents of this message and any attachments to it are confidential and may be legally privileged. If you have received this message in error you should delete it from your system immediately and advise the sender. dunnhumby may monitor and record all emails. The views expressed in this email are those of the sender and not those of dunnhumby.

Posted via email from fasanya's posterous

Registering a remoteclass alias dynamically

2010-04-07T04:57:00.001-07:00

Say you've got a value object (VO) and you have defined a remote class alias on it. You can change(add?) another alias dynamically at runtime.
When you perform the execution of a service call.

eg [RemoteClass(alias="lf.Project.Service.ServiceProxy.ObjectivesServiceProxy.StoreCluster")] on the class

com.fasanya.application.vo.StoreClusterVO.

To change this at runtime particularly useful if the same VO is used by different services you can do this...

public function execute(event:CairngormEvent):void //often done in this method of a command
{

var clientClassName:String = 'com.fasanya.application.vo.StoreClusterVO';

var clientClass:Class = getDefinitionByName(clientClassName) as Class;

var newAlias:String = ''lf.Project.NewService.NewServiceProxy.NewServiceProxyName.StoreCluster";

registerClassAlias(newAlias, clientClass);

...other code...

delegate.serviceRequest(clientClass);
}

Posted via email from fasanya's posterous

Emergent Design - These few simple rules, applied locally, can help a high quality global design to emerge.

2010-04-06T11:46:00.001-07:00

In a posting on the Agile Modeling mailing list, Alan Shalloway of Net Objectives, proposed some rules on well designed code:

Runs all the tests

Follows once and only once rule
(which I believe means “contains no duplicate code”)

Has high cohesion (clarity)

Has loose coupling

Alan comments:

“If you look at design patterns, you can see that most of them follow these rules. High cohesion and loose coupling can often be achieved by decomposing your problem domain with the distinctions of commonality / variability analysis. That is, find how things are similar and then find out how they are different.

“The other thing I like about this set of rules is that they are easy to teach and understand. Cohesion has to do with clarity. Method cohesion means a method is focused on one purpose. Class cohesion means all of the methods in a class are focused on one larger purpose.”

via xprogramming.com

Posted via web from fasanya's posterous

Flex Comp Startup courtesy of JexChen

2010-04-01T09:28:00.001-07:00

Download now or preview on posterous

flexcustomcomponentlifecyclepractice-090506052019-phpapp01.ppt (557 KB)

Posted via email from fasanya's posterous

Flex Comp lifecycle diagram courtesy of Jex Chen @ http://www.jexchen.com/

2010-04-01T09:16:00.001-07:00

Posted via email from fasanya's posterous

Transforming the Mind - Telic and Paratelic States

2010-03-31T08:19:00.001-07:00

Telic and Paratelic States

The term 'state' in psychology is used to describe something about a person at a given moment in time. States can change quickly, can last for various durations of time (from seconds to days) and can be affected by environmental cues, interpersonal transactions, cognitive processes, biological changes and motivation. There are thousands of adjectives that may be used to characterize a person's current operative state, such as 'angry', 'fearful', 'bored', 'serious', 'excited', 'sensation-seeking' and many others. This is clearly impractical as a basis for the understanding of psychological processes; a better solution is to look for clusters of inter-related states or behaviors that are amenable either to direct observation or psychometric measurement. Such a model would need to explain why individuals do not remain in one constant state of arousal, but introvert or extravert, withdraw or become involved, be thoughtful or spontaneous.

Take the example of a person riding a bicycle: the behavior is cycling, the goal is arriving at a certain place. If the cyclist needs to get to work on time, his behavior is chosen to meet the goal (arrival) that is in the foreground; the means of doing this is secondary. This is a telic state - the person is serious-minded, planning oriented and seeks to avoid arousal.

The alternative experience is for the behavior to be in the foreground and the goal in the background - the person may simply like the feeling of the wind in his hair as he cycles down a hill; where he is going is secondary. This is a paratelic state - the person is playful, prefers to be spontaneous, is 'here and now' oriented (pursues goals only insofar as they add to the immediate pleasure of the situation) and prefers arousal to be high, since it is pleasurable.

A certain behavior (cycling) may then be associated with contrasting motivational states (ends: goal achievement versus means: behavioral satisfaction), and the cyclist may switch between these states on different occasions or even several times during one cycle ride. This helps to explain why individuals do not seek to remain at a 'safe' medium level of arousal all the time, but engage in exploration, curiosity, risk-taking, play, art, religion and humor, sometimes because they lead to the achievement of a goal and sometimes because they are pleasurable in themselves. Neurosis or distorted thinking will however reduce this range and flexibility of experience due to fears of consequences.

Contingent events, i.e. genuine setbacks, may trigger a reversal from a paratelic state of pleasurable excitement to a telic state of unpleasant arousal or anxiety; or the reverse may occur if things suddenly go well. Frustration in which the needs of the person are not being satisfied may cause such a reversal, and a person may become satiated with one mode and increasingly sensitive to cues that may trigger a reversal.

The distinction between telic and paratelic states relates to many features of the experience of motivation:

Motivations TELIC PARATELIC

Means-Ends motivation: Essential goals
Imposed goals
Unavoidable goals
Reactive
Goal-oriented
End-oriented
Not essential goals
Freely chosen goals
Avoidable goals
Proactive
behavior oriented
Process-oriented

Time motivations: Wish to complete
Future-oriented
Planned
Pleasure of anticipation
Wish to prolong
Present-oriented
Spontaneous
Pleasure of sensation

Intensity motivations: High rationality preferred
Low arousal preferred
Low rationality preferred
High arousal preferred

The psychological variables most central to the distinction between telic and paratelic states in respect of intensity, are felt arousal (the degree to which a person feels 'stirred up' or aroused) and hedonic tone (the degree of pleasure experienced). The following diagram illustrates this relationship:

High felt arousal may be experienced as unpleasant in the telic mode (anxiety) or pleasant in the paratelic (excitement). A climber may enjoy his climb and feel really excited at being near the summit and then remembering a sudden fall under similar circumstances, experience a panic-attack. Similarly a low felt arousal may reverse from pleasant relaxation (in the telic mode) to unpleasant boredom (in the paratelic), when the person has become satiated with that way of operating, and finds present circumstances inadequately stimulating. So a circumstance becomes stressful when it forces the person into a mode of operation that he would prefer not to be in.

An event or situation (such as a bank raid or an examination) that is associated with an increase in arousal (i.e. one that would typically be perceived as a 'stressful' event) is likely to be experienced as stressful only when one is in the telic state, and may be viewed as an exciting challenge in the paratelic state. Radically different responses to the same situation, in terms of affect, behavior and cognitions would be expected for individuals in these different states of mind. The one would involve anxiety, avoidance, resistance and a variety of defensive 'coping' strategies, while the other would be characterized by excitement, exhilaration, 'approach' strategies and a sense of challenge.

“A circumstance becomes stressful when it forces the person into a mode of operation that he would prefer not to be in.”
Thus paratelic dominant individuals have a higher threshold for high-arousal stress; on the other hand they are more susceptible to stress that results from under-stimulation, and may find boring, monotonous activities very stressful. These factors will be examined in greater depth later on.

via trans4mind.com

What state are you in when programming.

Posted via web from fasanya's posterous

Component LifeCycle courtesy of Shrikant Patil at http://flexscript.wordpress.com/2008/10/24/flex-component-lifecycle-and-flex-component-framework/

2010-03-31T01:56:00.001-07:00

Flex is component based framework. It has many components like button, datagrid, containers etc. There are times when we want to write our own component when any of standard Flex components doesn’t meet our application needs. There are two ways to achieve this, either create the required custom component by extending exiting Flex standard components else create a component according to our requirements from scratch (completely new component).
To create a custom component using either of any way, we must have knowledge of component Life cycle,
All standard Flex components goes internally under a life cycle, form its creation to deletion. The life cycle of Flex Components divided into three phases, and phases divided into many stages.
1) Initialization Phase
2) Update Phase
3) Destruction Phase
Let us dig more each phases of flex component life cycle;
1) Initialization Phase: This is first phase of flex components life cycle; it contains three stages;
- Construction Stage
- Configuration Stage
- Attachment Stage
- Initialization Stage.

We will look into the each stages of this Phase:

a) Construction Stage (Initialization Phase):
In this stage of initialization Phase, the constructor of the component is called by component tag in MXML or using new operator using ActionScript. This is very first stage from where components life cycle begins. Constructor of the component calls the super () to invoke the super class constructor. Commonly we create out custom component by extending the UIComponent class, as it is base class for all display components of flex framework. This stage defines the structure of the constructor of our component. We should not create any display objects in constructor, for that purpose we use different stage. We can use this stage to;
1) Set some of initial values for the component properties.
2) To add event listeners to the component.
3) And initialize the other objects.

b) Configuration Stage (Initialization Phase):
This stage occur only once in component life cycle. During this step the values assigned for properties of the component using setters are set internally to refer them later in configuration of component.

c) Attachment Stage (Initialization Phase):
This stage of Initialization Phase gets triggered when component is added to the display list using either addChild(), addChildAt() Or component created in MXML tags. In this stage the components parent is defined because the component is now added to the display list. When this component is added to display list it calls initialize () method to initiate the next stage of this phase, i.e. Initialization Stage.

d) Initialization Stage (Initialization Phase):
After component is attached (Attachment Stage) to the display list, initialization Stage starts. This is important Stage of the component life cycle. This is responsible to create children objects of the component, sizing and placing the component and its children, and applying the property, style values to the component. During this stage following steps occurs;
Step1: Dispatch preinitialize event.
Step2: Calls createChildren() method to create children of the component.
Step3: Dispatch Initialize event
Step4: Invalidation: Marks the component for Invalidation which results the component to go with methods invalidateProperties(), invalidateSize() and invalidateDisplayList(). (We see more about Invalidation after some lines)
Step5: Validation: Invalidation of last step results to validation methods like commitProperties(), measure() and updateDisplayLiIst().(we see more about Validation after some lines)
Step6: Dispatch creationComplete event.

We must understand createChildren(), Invalidation and Validation to implement the above steps in custom component development.

CreateChildren() : This method is called by the flex during the Initialization Stage. This method is used to create and attach the sub objects (Child Components) of the component at the initial stage of the component life cycle. The child components might be any of UIComponent or any type of native display object. For example you may want to add three buttons at the top right corner for the TitleWindow component to provide maximize, minimize and close functionality to your custom component. The three buttons are created and added at top right corner of the TitleWindow in createChildren() method. The createChildren() method is called only once during the component life cycle, so this is ideal place to add our child objects to the component. The first statement of the createChildren() method is ; super.createChildren();
So that the super class create its sub objects. Later we can create required sub components and initialize them and add them to the components display list.

Invalidation:
Changes made to the component’s properties, styles, sub components from either user or by framework are noted and the component is marked to update (render) those changes on component. The process of marking the component to update (render) according to the changes done either by user or by framework is known as Invalidation. During the invalidation the values which were noted as changed are actually rendered (Not all values).
Invalidation can occur at two places of components life cycle, Initialization Phase and Update Phase.
In Initialization Phase, all values are not yet assigned for rendering, so the Invalidation marks whole component for Validation. In Update Phase, only changed values are marked for validation.
Invalidation includes the following methods to invalidate the component;
invalidateProperties() – This method is used to mark changed properties of the component for validation (render).
InvalidateSize() – This method is used to mark the component for resizing according to the value changed. Suppose say that width property of a component changed, and then the component is marked for validation using this method.
invalidateDisplayList() – This method is used to mark the component for validation (render), when any visual related changes occur in component.

Validation:
Validation is like response for invalidation. When component marks value (Invalidation) then the related method is called and requested changes are rendered on the component. The process of rendering or processing the invalidated values on component is known as Validation. The validation also includes three methods relative to the Invalidation methods.

commitProperties() – This method is used for commit the property values which are marked by Invalidation. When any property of the component changed component is marked for validation, and this method is called to update that property value to the component. This method is called as a result of invalidation’s invalidateProperty() method. Means the property value which was marked for update at invalidation is updated on the component in this method. The first statement of this method is super.commitProperties();

Measure (): This method is used to perform the measurement calculation and provide the measurement information to the framework, so that framework uses these measurement details to layout this component on its container. Measure() method requires that we set the values of the measuredWidth, measuredHeight and measnuredMinWidth(optional) and measuredMinHeight(optional) properties. The first code line of the method must be super.measure(). While setting the component default size and assigning sizing calculations to the framework, we need to consider all sub component’s sizes within our component. To get the height and width of the children components use getExplicitOrMeasuredWidth() and getExplicitOrMeasuredHeight() methods.

measuredWidth & measuredHeight – default value’s of the component for width and width. We can set these values during measure () method to set the component required default height and width.

measuredMinWidth & measuredMinHeight – Minimum value’s of the component for height and width. Commonly we set these value as same as measuredHeight and measuredWidth values.

updateDisplayList () –
This method is end point of the validation process. This method is called as a result of invalidateDisplayList() mentioned in Invalidation process. This method performs laying out the components contents and does any visual updates by rendering on components. The first line of code we need to write within this component is super.updateDisplayList(). This method receives two parameters: unscaledWidth and unscaledHeight. These parameters contains the height and width which were set at measure () method.

Validation and invalidation are relative stages.
The invalidateProperties() method of Invalidation calls commitProperties() method of Validation.
The invalidateSize() method of Invalidation calls measure() method of Validation.
The invalidateDisplayList() method of Invalidation calls updateDisplayList() of the Validation.

Keep the invalidation and validation steps in mind, because the same steps occur at the phase of update. After completing Validation the last step of initialize stage is to dispatch the creationComplete event. Overall of the initialization Stage we can see below;
2) Update Phase:
This phase of component life cycle is related to the updating the components internal values and rendering them on component. The updating depends on user interaction or framework processes which change the values of the component to update. The process of update includes waiting to changes happen and note each change and mark it as invalidate (Invalidation) using any of invalidation methods. After invalidation the component goes related validation method to update or render the changed values on component. After validation the component again resides waiting (update state).
3) Destruction Phase:
This is final Phase of component life cycle. This phase occurs when component is removed from the display list. It will get removed form any other references and soon it will get garbage collected, so that it will get completely removed by the memory and free the memory.

Posted via email from fasanya's posterous

Flex 4 Component Development

2010-03-25T16:52:00.001-07:00

Check out this SlideShare Presentation:

Flex 4 Component Development

View more presentations from michael.labriola.

Adobe Flex 3 Component Life Cycle by RJOwen

2010-03-25T16:51:00.001-07:00

Check out this SlideShare Presentation:

Adobe Flex 3 Component Life Cycle

View more presentations from rjowen.

Component Class Hierarchy courtesy of flexcomps.files.wordpress.com

2010-03-25T10:50:00.001-07:00

Posted via email from fasanya's posterous

Unit Testing Flex – Mocking « compactcode A Great Framework For Flex Mocking Called MOCKITO

2010-03-24T09:56:00.000-07:00

26
Aug/091
Unit Testing Flex – Mocking

If you have experimented with unit testing either recently or in the past you will be aware that sometimes it can get difficult. There are many challenges you might encounter including the following:

* You need to ensure something happened, without going into detail.
* You have to do too much to write a single test.
* You need to test something that you don't have control over.

In this post I want to show some ways to get around these common unit testing roadblocks using a concept called mock objects. Basically a mock object is just an object that can simulate the behaviour of another object in order to make unit tests easier to write.

Imagine yourself working as a developer at an exciting new tech startup...

Your company is launching a new website tomorrow that lets users advertise and sell their cars online. Your boss turns up at your desk at 10 am in the morning, he has a rather worried look on his face. It turns out that he forgot to schedule the feature that actually allows users to publish vehicles to the site. Oops! Your boss tells you to drop everything and get this done by the end of the day because if you don't, your fired!

You look through the code and find that a service method exists that does what you want:

package com.compact.mocking {
public class VehicleService {
public function publish(item:Vehicle): void {
...
}
}
}

Excellent now all we need to do is ensure we call this function from our GUI model.

package com.compact.mocking {
public class VehicleModel {
public var service:VehicleService;
public function publish(item:Vehicle): void {
service.publish(item);
}
}
}

Easy, next on the list is to write a unit test so we are 100% sure that we are calling the right function. This is were things get a little tricky, we know the VehicleService works and we don't need to test it again. All we really need to do is make sure that we call the vehicle service... but after that we don't really care what happens.

You need to ensure something happened, without going into detail.

Using mockito-flex we are going to create a mock version of our service. We will then replace the real service with the mock version. Thanks to mockito-flex our mock will automatically record all invocations it receives. We can then inspect these records to verify if the publish function has been called.

package com.compact.mocking {
import org.mockito.MockitoTestCase;

// MockitoTestCase extends the standard FlexUnit TestCase.
public class CustomerModelTest extends MockitoTestCase {
private var _model:VehicleModel;
public function CustomerModelTest() {
// Tell mockito which classes will need to be mocked.
super([VehicleService]);
}
override public function setUp(): void {
_model = new VehicleModel();
// Replace the real service with a mock version.
_model.service = mock(VehicleService);
}
public function testPublishDelegatesToService(): void {
var item:Vehicle = new Vehicle();

// This should call the publish function of our mock service.
_model.publish(item);

// Verify that the mock service received the right call.
verify().that(_model.service.publish(item));
}
}
}

Your boss is impressed, you finished ALL that within 5 minutes! Unfortunately the victory is short lived because he just remembered something... that's right you need make sure the vehicle is valid before publishing.

You have a look through the code and find that this validation method exists on the vehicle:

package com.compact.mocking {
[Bindable]
public class Vehicle {
public var make:String;
public var model:String;
public var price:Number;

public var ownerName:String;
public var locationName:String;

public function isValid(): Boolean {
var valid:Boolean = true;
valid = valid && notEmpty(make);
valid = valid && notEmpty(model);
valid = valid && notEmpty(ownerName);
valid = valid && notEmpty(locationName);
valid = valid && price > 0;
return valid;
}
private function notEmpty(value:String): Boolean {
return value && value.length > 0
}
}
}

So you change your model to take advantage of it.

package com.compact.mocking {
public class VehicleModel {
public var service:VehicleService;
public function publish(item:Vehicle): void {
if(item.isValid()) {
service.publish(item);
}
}
}
}

And then expertly update your test.

package com.compact.mocking {
import org.mockito.MockitoTestCase;

public class CustomerModelTest extends MockitoTestCase {
private var _model:VehicleModel;
public function CustomerModelTest() {
super([VehicleService]);
}
override public function setUp(): void {
_model = new VehicleModel();
_model.service = mock(VehicleService);
}
public function testPublishDelegatesToService(): void {
var item:Vehicle = new Vehicle();
item.make = "a";
item.model = "b"
item.price = 5;
item.ownerName = "fred";
item.locationName = "australia"

_model.publish(item);

verify().that(_model.service.publish(item));
}
}
}

You get the job done but you feel like you had to do a lot of work to get there. You also remember that your colleague Fred is currently working on adding more conditions to the validation function. That means you will need to add even more setup to this test.

You have to do too much to write a single test.

You wish there was a way to avoid having to do all that work to make your vehicle valid. Wouldn't it be great if you could just create a mock vehicle that is always valid? Well actually... you can!

package com.compact.mocking {
import org.mockito.MockitoTestCase;

public class CustomerModelTest extends MockitoTestCase {
private var _model:VehicleModel;
private var _item:Vehicle;
public function CustomerModelTest() {
// We are mocking the vehicle as well.
super([VehicleService, Vehicle]);
}
override public function setUp(): void {
_model = new VehicleModel();
_model.service = mock(VehicleService);
// Create the mock vehicle.
_item = mock(Vehicle);
}
public function testPublishDelegatesToService(): void {
// Update the mock so the isValid() function always return true.
given(_item.isValid()).willReturn(true);

_model.publish(_item);

verify().that(_model.service.publish(_item));
}
}
}

Your boss is definitely impressed now.. you just cut five lines out of that test and when Fred updates the validation function.. your test won't break!

Everything is going well as you get ready for the big release, it's 3pm and your just about to celebrate over a few drinks when your boss remembers something... You need to record the time that every vehicle was published, because you are planning on charging your users 50c for each day they have their vehicle on your website.

Amazingly it turns out this functionality is already there on the service!

package com.compact.mocking {
public class VehicleService {
public function publish(item:Vehicle): void {
...
}
public function recordPublishTime(item:Vehicle, time:Date): void {
...
}
}
}

No problem, we just need to add a call to this function in our model.

package com.compact.mocking {
public class VehicleModel {
public var service:VehicleService;
public function publish(item:Vehicle): void {
if(item.isValid()) {
service.publish(item);
service.recordPublishTime(item, new Date());
}
}
}
}

Ok so that's looking good, except how can we verify this call using mockito?
A first attempt might look like this:

public function testPublishRecordsPublishTimeUsingService(): void {
given(_item.isValid()).willReturn(true);

_model.publish(_item);

verify().that(_model.service.recordPublishTime(_item, new Date()));
}

Unfortunately that won't work. The date we are using in our verify is not the same as the date we are creating in our model because the two dates have different millisecond values. How do we take control of the date creation process so that we can match these dates and complete the test?

You need to test something that you don't have control over.

Fortunately it's not too hard, we just need to introduce a date factory. Once we have this factory, we can then use a mock to precisely control the date creation process. This is what the factory looks like.

package com.compact.mocking {
public class TimeFactory {
public function currentTime(): Date {
return new Date();
}
}
}

We then change our model to use the factory instead of directly creating dates.

package com.compact.mocking {
public class VehicleModel {
public var service:VehicleService;
public var timeFactory:TimeFactory = new TimeFactory();
public function publish(item:Vehicle): void {
if(item.isValid()) {
service.publish(item);
service.recordPublishTime(item, timeFactory.currentTime());
}
}
}
}

Now we can fairly easily mock the factory and complete the test.

package com.compact.mocking {
import org.mockito.MockitoTestCase;

public class CustomerModelTest extends MockitoTestCase {
private var _model:VehicleModel;
private var _item:Vehicle;
public function CustomerModelTest() {
super([VehicleService, Vehicle, TimeFactory]);
}
override public function setUp(): void {
_model = new VehicleModel();
_model.service = mock(VehicleService);
_model.timeFactory = mock(TimeFactory);
_item = mock(Vehicle);
}
public function testPublishRecordsPublishTimeUsingService(): void {
var publishDate:Date = new Date();

given(_item.isValid()).willReturn(true);
given(_model.timeFactory.currentTime()).willReturn(publishDate);

_model.publish(_item);

verify().that(_model.service.recordPublishTime(_item, publishDate));
}
}
}

Phew! You did it.

You just saved the company! You completed the feature that allows your customers to publish their vehicles onto your new website. You unit tested your code and did so in an elegant way using mock objects and the mockito-flex framework. You encountered three common problems on your journey and overcame them all. Now all you need to do is continue the good work you have been doing and try your hand writing more unit tests.
Filed under: flexunit, testing

BetterDataGrid Improved

2010-03-18T04:10:00.001-07:00

package
{
import flash.display.Sprite;
import flash.geom.Point;

import mx.collections.CursorBookmark;
import mx.controls.DataGrid;
import mx.controls.dataGridClasses.DataGridColumn;
import mx.controls.listClasses.IListItemRenderer;
import mx.core.mx_internal;
use namespace mx_internal;

/**
* A DataGrid subclass that has faster horizontal scrolling
*/
public class BetterDataGrid extends DataGrid
{
    public function BetterDataGrid()
    {
        super();
    }

    /**
    * remember the number of columns in case it changes
    */
    private var lastNumberOfColumns:int;

    /**
    * a flag as to whether we can use the optimized scrolling
    */
    private var canUseScrollH:Boolean;

    /**
    * when the horizontal scrollbar is changed it will eventually set horizontalScrollPosition
    * This value can be set programmatically as well.
    */
    override public function set horizontalScrollPosition(value:Number):void
    {
        // remember the setting of this flag. We will tweak it in order to keep DataGrid from
        // doing its default horizontal scroll which essentially refreshes every renderer
        var lastItemsSizeChanged:Boolean = itemsSizeChanged;

        // remember the current number of visible columns. This can get changed by DataGrid
        // as it recomputes the visible columns when horizontally scrolled.
        lastNumberOfColumns = visibleColumns.length;

// reset the flag for whether we use our new technique
canUseScrollH = false;

// call the base class. If we can use our technique we'll trip that flag
super.horizontalScrollPosition = value;

        // if the flag got tripped run our new technique
        if (canUseScrollH)
        {
            scrollLeftOrRight();
            configureScrollBars();
        }

// reset the flag
itemsSizeChanged = lastItemsSizeChanged;

}

    // remember the parameters to scrollHorizontally to be used in our new technique
    private var pos:int;
    private var deltaPos:int;
    private var scrollUp:Boolean;

public function get attrColumnIndex():int {

return _attrColumnIndex;
}

    public function set attrColumnIndex(o:int):void {
        _attrColumnIndex = o;
    }

protected var _attrColumnIndex:int = null;

    // override this method. If it gets called that means we can use the new technique
    override protected function scrollHorizontally(pos:int, deltaPos:int, scrollUp:Boolean):void
    {
        // just remember the args for later;
        this.pos = pos;
        this.deltaPos = deltaPos;
        this.scrollUp = scrollUp;
        if (deltaPos < visibleColumns.length)
        {
            canUseScrollH = true;

            // need this to prevent DG from asking for a full refresh
            itemsSizeChanged = true;
        }
    }

    /**
    * The new technique does roughly what we do vertically. We shift the renderers on screen and in the
    * listItems array and only make the new renderers.
    * Because we can't get internal access to the header, we fully refresh it, but that's only one row
    * of renderers. There's significant gains to be made by not fully refreshing the every row of columns
    *
    * Key thing to note here is that visibleColumns has been updated, but the renderer array has not
    * That's why we don't do this in scrollHorizontally as the visibleColumns hasn't been updated yet
    * But because of that, sometimes we have to measure old renderers, and sometimes we measure the columns
    */
    private function scrollLeftOrRight():void
    {
        // trace("scrollHorizontally " + pos);
        var i:int;
        var j:int;

var numCols:int;
var uid:String;

var curX:Number;

        var rowCount:int = rowInfo.length;
        var columnCount:int = listItems[0].length;
        var cursorPos:CursorBookmark;

var moveBlockDistance:Number = 0;

        var c:DataGridColumn;
        var item:IListItemRenderer;
        var itemSize:Point;
        var data:Object;

var xx:Number;
var yy:Number;

        if (scrollUp) // actually, rows move left
        {
            // determine how many columns we're discarding
            var discardCols:int = deltaPos;

// measure how far we have to move by measuring the width of the columns we
// are discarding

moveBlockDistance = sumColumnWidths(discardCols, true);
// trace("moveBlockDistance = " + moveBlockDistance);

            // shift rows leftward and toss the ones going away
            for (i = 0; i < rowCount; i++)
            {
                numCols = listItems[i].length;

if(numCols == 0) //empty row
continue;

                // move the positions of the row, the item renderers for the row,
                // and the indicators for the row
                moveRowHorizontally(i, discardCols, -moveBlockDistance, numCols);
                // move the renderers within the array of rows
                shiftColumns(i, discardCols, numCols);
                truncateRowArray(i);
            }

// generate replacement columns
cursorPos = iterator.bookmark;

var firstNewColumn:int = lastNumberOfColumns - deltaPos;
curX = listItems[0][firstNewColumn - 1].x + listItems[0][firstNewColumn - 1].width;

            for (i = 0; i < rowCount; i++)
            {
                if(iterator == null || iterator.afterLast || !iteratorValid)
                   continue;
                data = iterator.current;
                iterator.moveNext();
                uid = itemToUID(data);

                xx = curX;
                yy = rowInfo[i].y;
                for (j = firstNewColumn; j < visibleColumns.length; j++)
                {
                    c = visibleColumns[j];
                    item = setupColumnItemRenderer(c, listContent, i, j, data, uid);
                    //if(!item) return;
                    itemSize = layoutColumnItemRenderer(c, item, xx, yy);
                    xx += itemSize.x;
                }
                // toss excess columns
                while (listItems[i].length > visibleColumns.length)
                {
                    addToFreeItemRenderers(listItems[i].pop());
                }
            }

            iterator.seek(cursorPos, 0);
        }
        else
        {
            numCols = listItems[0].length;

if(deltaPos > visibleColumns.length)
deltaPos = visibleColumns.length;

moveBlockDistance = sumColumnWidths(deltaPos, false);

            // shift the renderers and slots in array
            for (i = 0; i < rowCount; i++)
            {
                numCols = listItems[i].length;
                 if(numCols == 0)
                   continue;

                moveRowHorizontally(i, 0, moveBlockDistance, numCols);
                // we add placeholders at the front for new renderers
                addColumnPlaceHolders(i, deltaPos);

}

cursorPos = iterator.bookmark;

            for (i = 0; i < rowCount; i++)
            {
                data = iterator.current;
                iterator.moveNext();
                uid = itemToUID(data);

                xx = 0;
                yy = rowInfo[i].y;
                for (j = 0; j < deltaPos; j++)
                {
                    c = visibleColumns[j];
                    item = setupColumnItemRenderer(c, listContent, i, j, data, uid);
                    itemSize = layoutColumnItemRenderer(c, item, xx, yy);
                    xx += itemSize.x;
                }
                // toss excess columns
                while (listItems[i].length > visibleColumns.length)
                {
                    addToFreeItemRenderers(listItems[i].pop());
                }
            }

iterator.seek(cursorPos, 0);
}

        // force update the header
        header.headerItemsChanged = true;
        header.visibleColumns = visibleColumns;
        header.invalidateDisplayList();
        header.validateNow();

        // draw column lines and backgrounds
        drawLinesAndColumnBackgrounds();
    }

    /* override protected function addToFreeItemRenderers(item:IListItemRenderer):void
    {
        if (item) super.addToFreeItemRenderers(item);
    } */

    // if moving left, add up old renderers
    // if moving right, add up new columns
    private function sumColumnWidths(num:int, left:Boolean):Number
    {
        var i:int;
        var value:Number = 0;
        if (left)
        {
            for (i = 0; i < num; i++)
            {
                value += listItems[0][i].width;
            }
        }
        else
            for (i = 0; i < num; i++)
            {
                value += visibleColumns[i].width;
            }

return value;
}

    // shift position of renderers on screen
    private function moveRowHorizontally(rowIndex:int, start:int, distance:Number, end:int):void
    {
        for (;start < end; start++)
        if(listItems[rowIndex][start]){
            listItems[rowIndex][start].x += distance;
        }
    }

    // shift renderer assignments in listItems array
    private function shiftColumns(rowIndex:int, shift:int, numCols:int):void
    {
        var item:IListItemRenderer;
        var uid:String = itemToUID(listItems[rowIndex][0].data);
        for (var i:int = 0; i < shift; i++)
        {
            item = listItems[rowIndex].shift();
            if(item){
                addToFreeItemRenderers(item);
            }
        }
        //rebuild the listContent.visibleData map entry
        listContent.visibleData[uid] = listItems[rowIndex][0];
    }

    // add places in front of row for new columns
    private function addColumnPlaceHolders(rowIndex:int, count:int):void
    {
        for (var i:int = 0; i < count; i++)
        {
            listItems[rowIndex].unshift(null);
        }
    }

    // remove excess columns
    private function truncateRowArray(rowIndex:int):void
    {
        while (listItems[rowIndex].length > visibleColumns.length)
        {
            var item:IListItemRenderer;
            {
                item = listItems[rowIndex].pop();
                addToFreeItemRenderers(item);
            }
        }
    }

    override protected function drawVerticalLine(s:Sprite, colIndex:int, color:uint, x:Number):void
    {
        if(!attrColumnIndex){
            super.drawVerticalLine(s:Sprite, colIndex:int, color:uint, x:Number);
            return;
        }
        if (colIndex == attrColumnIndex-pos)
        {
            var colour:uint = 0xFF0000;
            super.drawVerticalLine(s,colIndex,colour,x);
            return;
        }
        super.drawVerticalLine(s,colIndex,color,x);
    }

}
}

Posted via email from fasanya's posterous

Mockito

2010-03-11T14:43:00.001-08:00

Mockito is a framework to help you create stubs and mocks quickly if you do Unit Testing.

Check the link out and the tutorial.

http://bitbucket.org/loomis/mockito-flex/wiki/Home

Tutorial for version 1.0

This tutorial is unit testing framework agnostic. For examples on how to use it with specific unit testing frameworks please check the integrations section.

Let's

Before you will be able to create your mock objects you need to tell Mockito to prepare for it. You do it by calling:

1	mockito .prepareClasses([...]) ;

and providing all the classes to mock in given test case. Since the bytecode generation is an asynchronous process it is recommended to use one of the integration test cases as they address this issue. You may find more answers inAsmock documentation.

After preparing classes you can create mock objects by invoking:

1	var dependency:Dependency = Dependency(mockito.mock(Dependency));

Then setup the System Under Test (SUT)

1	var sut:Sut = new Sut(dependency);

And execute tested code.

1	sut.testedFunction(10);

Given the testedFunction looks like this:

1 2 3 4

function testedFunction(input:int):void  {  dependencyResult = dependency.someOperation(input);  }

Notice that there is no 'unexpected call' exception.

Instead you are free to choose what you want to verify:

1	verify().that(dependency.someOperation(input));

The full test would look like this:

 1  2  3  4  5  6  7  8  9 10

...  mockito.prepareClasses([Dependency]);  ...  var dependency:Dependency = Dependency(mockito.mock(Dependency));  // given  var sut:Sut = new Sut(dependency);  // when  sut.testedFunction(10);  // then  mockito.verify().that(dependency.someOperation(10));

As you can see, verification happens where assertions go. Not before the tested code. Important note is that verify() is equivalent to verify(times(1)).

If you need to stub dependency, you define it upfront.

1	mockito.given(dependency.someOperation(10)).willReturn(1);

When used in test it would look like this:

 1  2  3  4  5  6  7  8  9 10 11

...  mockito.prepareClasses([Dependency]);  ...  var dependency:Dependency = Dependency(mockito.mock(Dependency));  // given  var sut:Sut = new Sut(dependency);  mockito.given(dependency.someOperation(10)).willReturn(1);  // when  sut.testedFunction(10);  // then  assertEquals(1, sut.dependencyResult);

It may be useful to verify or define stubbing with various arguments at a time or have ability of matching the specific cases. For that purpose Mockito provides Matchers. Below example verifies any arguments passed to the function:

1	mockito.verify().that(dependency.someOperation(mockito.any()));

Similar you can do with stubbing:

1	mockito.given(dependency.someOperation(any())).willReturn(1);

As you can see you can either use explicit values or matchers when defining stubs or verifying. But you cannot mix it within single stub definition or verification. So for instance:

1	mockito.verify().that(progress.update(10, mockito.any()))

is invalid. Mockito will not be able to figure out which argument type to match against the any() matcher. You may want to verify multiple executions of a method at time. It's easy. Just tell how to verify:

1	mockito.verify(mockito.times(3)).that(dependency.someOperation(mockito.any()));

Sometimes you may want to make sure method has not been called. Do it by verifying:

Posted via email from fasanya's posterous

Ever wondered how to see the entire stack trace how you got to a particular method? (without trawling through eclipse and tons fo breakpoints)

2010-03-11T05:53:00.001-08:00

trace(new Error().getStackTrace())

Handy …. J

The contents of this message and any attachments to it are confidential and may be legally privileged. If you have received this message in error you should delete it from your system immediately and advise the sender. dunnhumby may monitor and record all emails. The views expressed in this email are those of the sender and not those of dunnhumby.

Posted via email from fasanya's posterous

Nice Css list for flex.

2010-03-11T05:48:00.001-08:00

http://www.loscavio.com/downloads/blog/flex3_css_list/flex3_css_list.htm

The contents of this message and any attachments to it are confidential and may be legally privileged. If you have received this message in error you should delete it from your system immediately and advise the sender. dunnhumby may monitor and record all emails. The views expressed in this email are those of the sender and not those of dunnhumby.

Posted via email from fasanya's posterous

Getters&Setters done easily in as3 eclipse

2010-03-01T03:38:00.001-08:00

http://eokyere.blogspot.com/2007/09/productivity-with-dash-in-eclipse.html.

My Eclipse Installations Reference

2010-02-26T01:31:00.001-08:00

The contents of this message and any attachments to it are confidential and may be legally privileged. If you have received this message in error you should delete it from your system immediately and advise the sender. dunnhumby may monitor and record all emails. The views expressed in this email are those of the sender and not those of dunnhumby.

Posted via email from fasanya's posterous

Doc for flex and flash.

2010-02-15T11:30:00.000-08:00

Yep you can get documentation on as3 from within eclipse but not offline and now its a whole lot easier to set up, you can even bookmark pages, and it's done in air check it out and show your support:
http://www.airdoc.be/

The eclipse plugin and other downloads:
http://www.airdoc.be/download#eclipse

Use a filter on a component with text to modify the texts alpha

2010-02-02T11:36:00.000-08:00

Rather than embed text you can set the filters array of a UIComponent with a filter to change the alpha of the text in a UIComponent!

Dependcy Injection and using an IoC container for Unit Testing not Functional Testing

2010-01-16T14:08:00.000-08:00

I had to justify at work that there were benefits to using an Inversion of Control container for benefitting Unit testing.

The argument follows in the letter; Comments please.

Hi I'm emailing this to you to let me know what you think it to convince developers to use an IOC container for DI to facilitate TDD.

Many tests that are called unit tests are actually functional tests in that the method under test is in a class that uses other classes and these classes in turn use even more classes.

VERSUS

See href="http://www.javaranch.com/unit-testing/too-functional.jsp

To me a unit test should test a method as that is a true unit. Especially if you are doing TDD as private/internal methods needed to be tested too. Not just APIs of classes and if a high target test coverage is to be measurably achieved then limiting tests to APIs of classes is inadequate.

Now because of our classes using classes that in turn use even more classes, what happens is to test a method we have to satisfy all the dependencies that our method uses not only in the class the method sits in but in all the other classes that method depends on. Thus creating a dependency chain.

These other classes which are dependencies are rarely written by one developer in fact they are often written by several developers of varying abilities and in doing so progamming methods are not employed that facilitate dependency injection.

In particular:
1) Avoiding the instantiation of the dependency in the class itself by the use of interfaces and then using setter or constructor injection.
2) Writing code like classAInstance.classBInstance.property creating a dependency chain and tight coupling.
3) Using Flex's data binding mechanism to pass dependencies through the application instead of setters/getters.
4) Creating dependency chains by having in ClassX object1, in Class Y object1.object2 where object1 was got from ClassX and in Class Z object2.object3. where object2 was got from classY.

This fourth one is particularly subtle in that only when you look at the classes as a set can you often see the problem.
And often arises when we pass a complex object from a service into ClassX and then pick apart this object in classes Y and Z it would also help if we had shallower objects rather than deeply nested ones requiring this picking apart.

To alleviate these it's useful for a class to contain only the things it must have and nothing else.

To develop with this in mind given that we are often given complex objects with sub-objects need parsing and refining before we can use them in a particular method being tested. Often we use a delegateStub that passes in this complex data that is then put through the uravelling process in 4), and then passed to the method under test. However this creates functional tests rather than unit tests and hides the need for doing 1).

For effcient TDD only the objects that the method under test needs should be passed in. This isolation is important as it allows to distinguish more clearly what's necessary for a particular method and what's not, than passing in additional unused data. To pass in this data for a test in a way that doesn't require the unravelling of a delegate stub means having stubs for the method under test and being able to inject this stub or the real thing into the method. This is where a IOC Container is useful as a easily modifiable central and shared repository for all the stub types that all the tests and developers are aware of and can use rather than them being created in several TestCase/TestSuite classes hidden away until the next developer happens to come across the class AND the method within that class. The Container highlights and calls out the data and models being injected and facilitates their use throughout the application by simply using the [Inject] metatag.

Now once our classes are set up so that they can be injected into with concrete implementations of interfaces. We can inject stubs or the real classes that are used in implementation and the configuration that a container provides facilitates this in short. A container allows us to move away from functional testing created by 1)-4) and closer to unit testing.

Thanks,

Comments will be appreciated.

Eclipse plugins for flex development

2009-12-14T04:27:00.000-08:00

A collection of useful plugins:
Flex Formatter:
This is an Eclipse editor tool to provide source code formatting for Adobe Flex code (i.e. Actionscript and MXML). the guy ernestpasour a set of formatting options which hopefully covers the most popular coding conventions.
http://sourceforge.net/projects/flexformatter/

AnyEdit:
Plugin adds several new tools to the context menu of text- based Eclipse editors, to output consoles, to Eclipse main menu and editor toolbar. AnyEdit contributes also Import/Export working sets wizards:
http://andrei.gmxhome.de/anyedit/index.html

AIR GEAR:
Is an Eclipse Plug-In which provides RAD development for Adobe AIR. AIR GEAR provides following features:
http://amateras.sourceforge.jp/cgi-bin/fswiki_en/wiki.cgi?page=AmaterasAIR

IDE Factory:
The Source for Enterprise Flex Development Tools apparently currently beta and I don't think this will be free when released.
http://www.idefactory.com/

KeepResident:
Supposed to improve performance by Windows virtual memory manager not keeping resident RAM for eclipses java processes. This is supposed to help with that.
http://suif.stanford.edu/pub/keepresident/index.html

Power laws in the social economy

2009-12-12T05:38:00.000-08:00

Great Article on 22 Power laws that will govern what many see as the economy of the 21st century - the social economy by Dion Hinchcliffe.

http://blogs.zdnet.com/Hinchcliffe/?p=961&tag=nl.e539

Here are the laws in summary:
Amara's law:
We tend to overestimate the effect of a technology in the short run and underestimate the effect in the long run.

Beckstroms law:
The value of a network equals the net value of each user’s transactions conducted through that network, valued from the perspective of each user, and summed for all.

Dunbar’s Number:
150 the number of social relationships that the average person can effectively maintain before overload occurs.

Gilder’s Law:
Network bandwidth triples every 18 months... thus raw communication capability is improving faster than computing power is increasing also means the cost of communication, no matter how complex, is collapsing rapidly towards zero.

Goodharts Law:
Once a social or economic indicator or other surrogate measure is made a target for the purpose of conducting social or economic policy, then it will lose the information content that would qualify it to play such a role.

Hawthorne Effect:
Shows you tend to manage what you measure and goes hand in hand with Goodharts, it states - Subjects in a setting will improve aspects of their behavior being experimentally measured simply in response to the fact that they are being studied.

Hotelling’s Law:
This is a product rule that says it’s natural and rational for businesses to make their products as similar as possible. Even in the age of mass customisation and differentiation this shows the importance of determining what should follow this law and what shouldn't and instead be customised.

Jakob’s Law:
Users spend most of their time on other sites, and so you must be there too. Take a look at the ways you should push your solution rather than pull them to a site.

http://web2.socialcomputingjournal.com/building_modern_web_apps_better_a_have_deep_competency_in_w.htm

Kurtosis Risk:
Kurtosis Risk occurs whenever observations are occur at high frequency at high frequency at normal distribution end tails.

Long Tail:
The Long Tail or long tail is a retailing concept describing the niche strategy of selling a large number of unique items in relatively small quantities – usually in addition to selling fewer popular items in large quantities. The concept was popularised by Chris Anderson in an October 2004 Wired magazine article, in which he mentioned Amazon.com and Netflix as examples of businesses applying this strategy.

Metcalfe's law:
Metcalfe's law states that the value of a network is proportional to the square of the number of connected nodes of the system. Precisely its the triangle number n(n-1)/2 where n is the number of nodes this is proportional to n squared asymptotically. (for large n). See Reed’s Law.

Moore's Law:
Computing power doubles every eighteen months(see Gilder’s Law). However the speed and capacity of storage and communication networks has greatly exceeded Moore’s Law for quite some time now and consequently is driving dislocation in many traditional computing models where processing power used to dominate. Not only is this making distributed computing more attractive and making new techniques possible, the fact that computing hasn’t kept up with the network ensures that the network will continue to dominate as a growth engine in terms of it’s overall ability to deliver real business value. The fundamental (and slightly oversimplified) implication is that business models tied to computing can’t compete with business models that are tied to communication, which as we’ll see with Reed’s Law, is significant.

Network Effect:
Is the effect that one user of a good or service has on the value of that product to other people. When network effect is present, the value of a product or service increases as more people use it.
Enterprise software is now experiencing the network effect of viral, Web 2.0 platforms, and Dion's seen numerous recurring instances of platforms such as MediaWiki pushing larger, established enterprise installations (Sharepoint!!) to the sides of their organizations through simple patterns such as network effects by default.

Pareto Principle:
80/20 Roughly 80% of the effects come from 20% of the causes.
Any complex system, including social ones, and increasingly social and community dynamics are seen as falling under this rule in numerous ways.

Principle Of Least Power:
Given a choice among computer languages, classes of which range from descriptive to procedural, the less procedural, more descriptive the language one chooses, the more one can do with the data stored in that language.
In practice, it has considerable implications for the knowledge economy. Data that is trapped in complex or obscure formats can’t be searched or otherwise processed, and the success of the Web as a content medium has largely been responsible for giving this principle its credibility. HTML and SQL are good examples of this.

Principle Of Least Effort:
Postulates that animals, people, even well designed machines will naturally choose the path of least resistance or "effort".
An information seeking client will tend to use the most convenient search method, in the least exacting mode available. Information seeking behavior stops as soon as minimally acceptable results are found. This theory holds true regardless of the user's proficiency as a searcher, or their level of subject expertise. Also this theory takes into account the user’s previous information seeking experience. The user will use the tools that are most familiar and easy to use that find results. The principle of least effort is known as a “deterministic description of human behavior.”[1] The principle of least effort applies not only in the library context, but also to any information seeking activity. For example, one might consult a generalist co-worker down the hall rather than a specialist in another building, so long as the generalist's answers were within the threshold of acceptability.

Reed’s Law:
Reed's law is the assertion of David P. Reed that the utility of large networks, particularly social networks, can scale exponentially with the size of the network.

The reason for this is that the number of possible sub-groups of network participants is 2^N - N - 1 \, where N is the number of participants. This grows much more rapidly than either

* the number of participants, N, or
* the number of possible pair connections, \frac{N(N-1)}{2} (which follows Metcalfe's law)

so that even if the utility of groups available to be joined is very small on a peer-group basis, eventually the network effect of potential group membership can dominate the overall economics of the system.

Reflexivity (The Social Theory)
In effect action and reaction can feed off each other to create a positive feedback loop that eventually changes the action and reaction and the actors and reactors particularly their expectations and objectives! Explaining the tendency of social systems to move away from equilibrium and often towards extremes (flame wars, viral feedback loops, rapid information propagation, etc including inadvertently falling in love!

Sarnoff’s Law:
Another way to value the network, Sarnoff’s Law, created to describe older one-way networks such as broadcast medium like TV or radio, says “the value of a broadcast network is proportional to the number of viewers.” A more modern version of this is Beckstrom’s Law.

Taleb distribution:
The Taleb distribution is a probability distribution where there is a high likelihood of a small gain combined with a small probability of a very large loss, which would more than outweighs any gain. Taleb distribution is interesting to the social economy for the same reasons as Kurtosis Risk: It can make social business options such as crowdsourcing and other open business models more balanced when looked at in this light because it can appropriately highlight the lack of predictability and identify unacceptable risk profiles.

Thomas Theorem:
The Thomas Theorem identifies a trend that is particularly common within social worlds that any definition of the situation will influence the present. The theorem stresses social situations including in family, business, or other life as fundamental to the role of the participant when mentally creating a social world “in which subjective impressions can be projected on to life and thereby become real to projectors.” This is how social worlds, on a network or otherwise, can take on a life of their own. The reputation and standing of individuals as they perceived on networks, is often very different from what they have in real life. This has implications for HR, promotions, rewards, and motivations in enterprise social computing environments.

Unloading Modules

2009-11-11T05:57:00.000-08:00

Having spent signigicant time investigating module unloading - I want to highlight the importance of removing focus from the module before being unloaded - see Alex Harui's blog enrty on unloading modules - http://blogs.adobe.com/aharui/.

I tried to set the focus onto something external to my module containing an clickable Advdatagrid however this didn't work so I then ensured that focus couldnt be set on the Advdatagrid not by using ADG.focusEnabled but by setting the selectable property of the ADG to false and then adding event listeners to the column to listen for item click events.

This raised a question finding the item associated with a col when the above properties are disabled the solution was to add a listener to the column as events are still flowing.

the code to get the selctedItem looks like tGhis:

private function firstColumnItemClick(evt:ListEvent):void
{
selectedItem = AdvancedDataGrid(evt.currentTarget).selectedItem;
//first column
if(evt.columnIndex==0)
{
var adgGIR:AdvancedDataGridGroupItemRenderer =
//get the ADGGItemRenderer off the list event
evt.itemRenderer as AdvancedDataGridGroupItemRenderer;

//get the AdvancedDataGridListData open which lives the item property.
var listData:AdvancedDataGridListData = adgGIR.listData as AdvancedDataGridListData;
//set slectedItem to the listData's Item.
selectedItem = listData.item;
//a method to expand the tree node given that you know what item:Object (representing row data)
expandDataGridItem(evt);
}
}

private function expandDataGridItem(evt:Event):void
{
rangerReviewsDataGrid.expandItem(selectedItem, true, true);
}

EPSON

2008-10-28T10:29:00.000-07:00

This is a custom interactive dynamic carousel I made for the epson homepage while at Sapient. The path of the motion and the easing are all configurable.

http://www.epson.co.uk/

Or in french!
http://www.epson.fr/;

Or in Spanish!!
http://www.epson.es/

SMILE Mathematics

2008-03-13T08:56:00.000-07:00

Here are several older applications that I did at SMILE Mathematics which is no more.

Division Buster
Like the old TV Show BlockBuster but with division questions... Anyway the path checking algorithm was interesting in this!

Nim
The objective of this game is to make sure your opponent is the last person to pick up a pencil I think this game is played with matchsticks but that wasn't deemed appropriate for schools! This game can be played against the computer and again required the development of a logic and a bit of research on the problem to determine a good computer strategy. you'll be hard pressed to beat the comp, and this one does require reading the instructions!

Towers of Hanoi
A classic game that's been seen many times before event on the web. This one records moves and replays them and if you can do three ring easily enough. Change the options.

Enlarging Pentominoes
This is basically a jigsaw but the interesting thing about it is there are several ways to complete each jigsaw this required developing algorithms to analyse that the jigsaw had been completed in a more abstract way.

Building Pentominoes
Similarly as with Enlarging Pentominoes this simple to play game used graph theory to analyse the pentominoes to determine which ones they were regardless of symmetry. So if you created the same shape upside down the program would recognise it. See if you can find all twelve pentominoes!

Darts
Here you're forced to do the maths in this game, one version requires a modicum of skill!

Adds Up To
Again this game required the computer to analyse potential moves - breadth first search - while also preventing the other player from winning.

As did this....Minimax
This requires you to play against and beat the computer using skill this was a good one to do for developing the computer logic for making moves as the numbers come up arbitrarily.The instructions in this are for a different game (The instructions never got finished!) you must try and beat your opponent (try and beeat the computer) by getting either the smallest or largest result.

Frogs
Simple game of can you get the frogs to the other side, this main view is from an isometric perspective. The number of frogs can be changed dynamically and the moves you've made are recorded, tabulated and can be replayed.

Magic Squares
A simple game to play but not so simple to complete. If you like Sudoku you might like this!

Boat
Another nice one to play. Can you get the bugs all other to the other side!

Jugs
This one was another one where the recording and replay was seen as useful.

Some others from way back!
Angle Fit
Maximum Remainder
Tensprint

Projects at MRM

2008-03-05T03:00:00.000-08:00

I've worked on several projects at MRM Worldwide (www.mrmworlwide.com) Here are some of the more significant ones...

www.msnsearchstar.com

www.msnsearchladder.com

www.microsoft.com/dynamics/everyonegetsit/default.mspx

www.microsoft.com/uk/office/newday/default.mspx

http://int-crackthecode.mrmpweb.co.uk

	Answer
0 (Homepage/login)	tcp/ip
1 (top left)	62658591
2 (top right)	0011000100110111
3 (bottom left)	25257
4 (bottom right)	1257632

A True 3d Carousel for a Microsoft Page - used a pretty useful component for this one.
http://www.microsoft.com/uk/amazingoffice/

Another 3d Carousel for the newspaper and marketing association no component this time.
http://nma.mrmpweb.co.uk/brand-landing-page/

An app whose development is near completion is the Unilever - Walls Kids Fun
http://uni-kidsfun.mrmpweb.co.uk/en-GB/index.html
Or if you prefer in French!
http://uni-kidsfun.mrmpweb.co.uk/fr-fr/index.html

Microsoft being a big client of ours has meant that I have been learning Silverlight the first app I worked on being a simple videoplayer. Except that compare to Flash it's not so simple this was done in the older version of Silverlight(1.0) That uses javascript!
http://microsoft-mnp-uk.mrmpweb.co.uk/uk/expression/webharmony/default.aspx
The new version of Silverlight (used to be 1.1 now called 2.0) is out soon. This uses .net languages -and in particular the one I have done some work in - c sharp.

Imagine Cup 2007
This application was developed forMicrosoft as a facebook application it used the user profile pic and the friends pic in conjunction with a .swf and server side code to create and save an image of a friend or users face superimposed on a customisable robot. Unfortunately as it was part of a competition that has now closed its no longer available.

Flash Video Progress Bar

2007-08-08T04:57:00.000-07:00

Progress Bar Dragging only works currently with Flash Media Server
see below:

Lyndon Fasanya - [08/Aug/07 11:40 AM ]

I had a look at this issue and to get the playhead to be manipulated manually requires a different set up from the one we have.

We can only do this in Flash if the video is actually streaming from a Flash Media Server (aka Flash Communication Server);

This is what happens on sites like you tube.

Because the videos aren't deployed from this server the playhead can' t be moved - a limitation of Flash.

[ Permlink | « Hide ]

Lyndon Fasanya - [08/Aug/07 11:43 AM ]

Check out this link for verification of this - to set the play action at a certain time can only occur with the server aforementioned

http://livedocs.adobe.com/flash/8/main/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Parts&file=00002565.html

OCC

2007-07-09T02:32:00.000-07:00

I'm currently developing a suite of user configurable educational mathematical tools for a leading schools publisher.
Within a CMS that teachers can use.

Flash and Flex

2007-07-09T02:23:00.000-07:00

This blog is all about Flash, Flex and related technologies and their derivatives!
With the aim of making things with these techs faster and easier.

*Motivations*	TELIC	PARATELIC
Means-Ends motivation:	Essential goals Imposed goals Unavoidable goals Reactive Goal-oriented End-oriented	Not essential goals Freely chosen goals Avoidable goals Proactive behavior oriented Process-oriented
Time motivations:	Wish to complete Future-oriented Planned Pleasure of anticipation	Wish to prolong Present-oriented Spontaneous Pleasure of sensation
Intensity motivations:	High rationality preferred Low arousal preferred	Low rationality preferred High arousal preferred