Changeset 182


Ignore:
Timestamp:
10/22/2009 02:48:12 PM (10 years ago)
Author:
pedro.cuba
Message:

Minor corrections.
Added a new test.

Location:
ION/trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • ION/trunk/ION.Core/src/ion/Core/Action.java

    r45 r182  
    2323  09/04/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
    2424  First version. 
    25   ---   
     25  --- 
     26  22/05/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
     27  Changed Step Request scheduling method to pass through the process Events phase. 
     28  Stepped Event -> New Step Request | Started Event -> New Step Request | Resumed Event -> New Step Request 
     29  --- 
    2630*/ 
    2731package ion.Core; 
    2832 
     33import ion.Core.Events.IResumed; 
     34import ion.Core.Events.IStarted; 
     35import ion.Core.Events.IStepped; 
    2936import ion.Meta.Element; 
     37import ion.Meta.EventHandler; 
     38import ion.Meta.IEvent; 
    3039import ion.Meta.IReadOnlyQueue; 
    3140import ion.Meta.IReadOnlyQueueSet; 
     
    6473 
    6574    public Action() { 
    66         this.state = State.Idle; 
    67         try { 
    68             //Exception is assured to never be thrown when creating a SetValueHandler 
    69             this.getRequestHandlers().add(new ActionRequestHandler()); 
    70         } catch (Exception ex) { 
    71         } 
    72     } 
    73      
    74     //<editor-fold defaultstate="collapsed" desc="Requests"> 
     75                this.state = State.Idle; 
     76 
     77                this.getRequestHandlers().add(new ActionRequestHandler()); 
     78                this.getEventHandlers().add(new SteppedHandler()); 
     79        this.getEventHandlers().add(new StartedHandler()); 
     80        this.getEventHandlers().add(new ResumedHandler()); 
     81        } 
     82     
     83    // <editor-fold defaultstate="collapsed" desc="Requests"> 
    7584    protected final class StartRequest extends Request {} 
    7685    protected final class ResumeRequest extends  Request {} 
     
    94103    protected final class ActionRequestHandler extends RequestHandler{ 
    95104 
    96         public ActionRequestHandler() throws Exception { 
     105        public ActionRequestHandler(){ 
    97106            super(new TypeSet(StartRequest.class, StartArgumentsRequest.class, 
    98107                    StopSuccessRequest.class, StopFailRequest.class, 
     
    182191        this.raise(new Started<Action>(this, this.state)); 
    183192        this.state = State.Running; 
    184         this.schedule(new StepRequest()); 
    185193    } 
    186194     
     
    203211        this.raise(new Resumed<Action>(this, this.state)); 
    204212        this.state = State.Running; 
    205         this.schedule(new StepRequest()); 
    206213    } 
    207214 
    208215    private void executeStep() { 
    209         this.schedule(new StepRequest()); 
    210216        this.raise(new Stepped<Action>(this)); 
    211217    } 
     
    220226    //</editor-fold> 
    221227     
    222     //<editor-fold defaultstate="collapsed" desc="Action Members"> 
    223      
    224     /** 
    225      * Starts the Action. 
    226      */ 
     228    protected void onStep(IStepped evt) { 
     229                if (evt.getAction() == this) { 
     230                        this.schedule(new StepRequest()); 
     231                } 
     232        } 
     233 
     234        protected void onStart(IStarted evt) { 
     235                if (evt.getAction() == this) { 
     236                        this.schedule(new StepRequest()); 
     237                } 
     238        } 
     239 
     240        protected void onResume(IResumed evt) { 
     241                if (evt.getAction() == this) { 
     242                        this.schedule(new StepRequest()); 
     243                } 
     244        } 
     245         
     246        private class SteppedHandler extends EventHandler { 
     247                 
     248                public SteppedHandler() { 
     249                        super(IStepped.class); 
     250                } 
     251                 
     252                @Override 
     253                public void invoke(IEvent evt) { 
     254                        onStep((IStepped)evt); 
     255                } 
     256        } 
     257         
     258        private class StartedHandler extends EventHandler { 
     259                 
     260                public StartedHandler() { 
     261                        super(IStarted.class); 
     262                } 
     263                 
     264                @Override 
     265                public void invoke(IEvent evt) { 
     266                        onStart((IStarted)evt); 
     267                } 
     268        } 
     269         
     270        private class ResumedHandler extends EventHandler { 
     271                 
     272                public ResumedHandler() { 
     273                        super(IResumed.class); 
     274                } 
     275                 
     276                @Override 
     277                public void invoke(IEvent evt) { 
     278                        onResume((IResumed)evt); 
     279                } 
     280        } 
     281     
     282    // <editor-fold defaultstate="collapsed" desc="Action Members"> 
     283     
     284    /** 
     285         * Starts the Action. 
     286         */ 
    227287    public void start() { 
    228288        this.schedule(new StartRequest()); 
  • ION/trunk/ION.Core/src/ion/Core/Property.java

    r45 r182  
    2323  09/04/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
    2424  First version. 
    25   ---   
     25  --- 
     26  22/05/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
     27  Supply for different policies (First, Last, Random) for conflicting SetValue Requests.  
     28  --- 
    2629*/ 
    2730package ion.Core; 
     
    4245 */ 
    4346public class Property<TValue> extends Element { 
     47         
     48        public enum SetValuePolicy {First, Last, Random} 
    4449     
    4550    /** 
     
    5358     */ 
    5459    public Property() { 
    55         //Exception is assured to never be thrown when creating a SetValueHandler 
    56         this.getRequestHandlers().add(new PropertyRequestHandler()); 
    57         this.value = null; 
     60        this(null, SetValuePolicy.First); 
    5861    } 
    5962     
     
    6467     */ 
    6568    public Property(TValue value){ 
    66         this(); 
     69        this(value, SetValuePolicy.First); 
     70    } 
     71     
     72    /** 
     73     * Creates a Property with a particular policy to handle conflicting SetValues requests 
     74     */ 
     75    public Property(SetValuePolicy policy){ 
     76        this(null, policy); 
     77    } 
     78     
     79    /** 
     80     * Creates a Property with a particular initial value and a policy to handle conflicting SetValues requests 
     81     */ 
     82    public Property(TValue value, SetValuePolicy policy) 
     83    { 
    6784        this.value = value; 
     85        switch (policy) 
     86        { 
     87            case First: 
     88                this.getRequestHandlers().add(new ChooseFirstHandler()); 
     89                return; 
     90            case Last: 
     91                this.getRequestHandlers().add(new ChooseLastHandler()); 
     92                return; 
     93            case Random: 
     94                this.getRequestHandlers().add(new ChooseRandomHandler()); 
     95                return; 
     96            default: 
     97                throw new IllegalArgumentException("Unknown SetValuePolicy."); 
     98        } 
    6899    } 
    69100     
     
    87118     */ 
    88119    protected void changeValueChooseFirst(IReadOnlyQueueSet<Request> requests) { 
    89          
    90         for (SetValue request : requests.get(SetValue.class)) { 
    91             //Use reflection to instantiate the appropriate event type 
    92             //object[] arguments = { this, this.value }; 
    93             Event evt = new ValueChanged<TValue, TValue, Property>(this.value, request.newValue, this); 
    94  
    95             this.value = request.newValue; 
    96             this.raise(evt); 
    97  
    98             return; 
    99         } 
    100     } 
    101      
    102     protected final class PropertyRequestHandler extends RequestHandler{ 
    103  
    104         public PropertyRequestHandler(){ 
     120        this.executeSetValue(requests.get(SetValue.class).getFirst()); 
     121        return; 
     122    } 
     123     
     124    /** 
     125     * Change value policy that chooses the last request set value. 
     126     *  
     127     * @param requests the set of request queues to be processed 
     128     */ 
     129    protected void changeValueChooseLast(IReadOnlyQueueSet<Request> requests) { 
     130        this.executeSetValue(requests.get(SetValue.class).getLast()); 
     131        return; 
     132    } 
     133     
     134    /** 
     135     * Change value policy that chooses a random request set value. 
     136     *  
     137     * @param requests the set of request queues to be processed 
     138     */ 
     139    protected void changeValueChooseRandom(IReadOnlyQueueSet<Request> requests) { 
     140        this.executeSetValue(requests.get(SetValue.class).choose()); 
     141        return; 
     142    } 
     143     
     144    protected void executeSetValue(SetValue request) { 
     145                if (this.value == null && request.newValue == null) { 
     146                        return; 
     147                } 
     148 
     149                if (request.newValue == null || this.value == null 
     150                                || !this.value.equals(request.newValue)) { 
     151                        Event evt = new ValueChanged<TValue, TValue, Property>(this.value, 
     152                                        request.newValue, this); 
     153                        this.value = request.newValue; 
     154                        this.raise(evt); 
     155                } 
     156        } 
     157     
     158    protected final class ChooseFirstHandler extends RequestHandler{ 
     159 
     160        public ChooseFirstHandler(){ 
    105161            super(new TypeSet(SetValue.class)); 
    106162        } 
     
    112168    } 
    113169     
     170    protected final class ChooseLastHandler extends RequestHandler{ 
     171 
     172        public ChooseLastHandler(){ 
     173            super(new TypeSet(SetValue.class)); 
     174        } 
     175 
     176        @Override 
     177        public void invoke(IReadOnlyQueueSet<Request> requests) { 
     178            changeValueChooseLast(requests); 
     179        } 
     180    } 
     181     
     182    protected final class ChooseRandomHandler extends RequestHandler{ 
     183 
     184        public ChooseRandomHandler(){ 
     185            super(new TypeSet(SetValue.class)); 
     186        } 
     187 
     188        @Override 
     189        public void invoke(IReadOnlyQueueSet<Request> requests) { 
     190            changeValueChooseRandom(requests); 
     191        } 
     192    } 
     193     
    114194    //</editor-fold> 
    115195     
  • ION/trunk/ION.Core/test/ion/Core/Tests/PropertyTest.java

    r45 r182  
    2323  09/04/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
    2424  First version. 
    25   ---   
     25  --- 
     26  22/05/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
     27  Added new test to verify if the ChangedValue Event is not raised when the value of a property is set to the value that the property has.  
     28  --- 
    2629*/ 
    2730package ion.Core.Tests; 
     
    110113        simulation.getElements().add(property); 
    111114 
    112  
    113115        simulation.update(); 
    114116        property.setValue(dummy); 
     
    126128     
    127129    @Test 
    128     public void multipleValueSetTest() { 
    129         Simulation simulation = Simulation.instance; 
    130  
    131         final int initialValue = 1; 
    132  
    133         Property<Integer> property = new Property<Integer>(initialValue); 
    134         simulation.getElements().add(property); 
    135         simulation.update(); 
    136  
    137         final int expectedValue = initialValue + 1; 
    138  
    139         property.setValue(expectedValue); 
    140         property.setValue(expectedValue + 1); 
    141         assertEquals(property.getValue(), initialValue); 
    142  
    143         simulation.update(); 
    144         assertEquals(property.getValue(), expectedValue); 
    145     } 
    146      
    147     //</editor-fold> 
    148      
    149     //<editor-fold defaultstate="collapsed" desc="Launched Events Testing"> 
    150      
    151     @Test 
    152     public void testPropertyChangedValueEventLaunched(){ 
    153          
    154         Simulation simulation = Simulation.instance; 
    155             Property<Integer> property = new Property<Integer>(); 
    156             property.getEventHandlers().add(new IValueChangedHandler()); 
    157  
    158             simulation.getElements().add(property); 
    159             simulation.update(); 
    160              
    161             this.changedValueEventLaunched = false; 
    162  
    163             property.setValue(5); 
    164             assertFalse(this.changedValueEventLaunched); 
    165  
    166             simulation.update(); 
    167             assertTrue(this.changedValueEventLaunched); 
    168     } 
    169  
    170     //</editor-fold> 
    171      
    172     //<editor-fold defaultstate="collapsed" desc="Constructor Tests"> 
     130        public void multipleValueSetTest() { 
     131                Simulation simulation = Simulation.instance; 
     132 
     133                final int initialValue = 1; 
     134 
     135                Property<Integer> property = new Property<Integer>(initialValue); 
     136                simulation.getElements().add(property); 
     137                simulation.update(); 
     138 
     139                final int expectedValue = initialValue + 1; 
     140 
     141                property.setValue(expectedValue); 
     142                property.setValue(expectedValue + 1); 
     143                assertEquals(property.getValue(), initialValue); 
     144 
     145                simulation.update(); 
     146                assertEquals(property.getValue(), expectedValue); 
     147        } 
     148     
     149    // </editor-fold> 
     150     
     151    // <editor-fold defaultstate="collapsed" desc="Launched Events Testing"> 
     152     
     153    @Test 
     154        public void testPropertyChangedValueEventLaunched() { 
     155 
     156                Simulation simulation = Simulation.instance; 
     157                Property<Integer> property = new Property<Integer>(); 
     158                property.getEventHandlers().add(new ValueChangedHandler()); 
     159 
     160                simulation.getElements().add(property); 
     161                simulation.update(); 
     162 
     163                this.changedValueEventLaunched = false; 
     164 
     165                property.setValue(5); 
     166                assertFalse(this.changedValueEventLaunched); 
     167 
     168                simulation.update(); 
     169                assertTrue(this.changedValueEventLaunched); 
     170        } 
     171     
     172    /** 
     173         * Tests if the ValueChanged is not raised when there is a Set with the 
     174         * value that the property already has. 
     175         */ 
     176    @Test 
     177        public void testPropertyChangedValueOldValueEqualsNewValueEventNotLaunched() { 
     178                Simulation simulation = Simulation.instance; 
     179                int value = 5; 
     180                Property<Integer> property = new Property<Integer>(value); 
     181                property.getEventHandlers().add(new ValueChangedHandler()); 
     182 
     183                simulation.getElements().add(property); 
     184                simulation.update(); 
     185 
     186                this.changedValueEventLaunched = false; 
     187 
     188                property.setValue(property.getValue()); 
     189                assertFalse(this.changedValueEventLaunched); 
     190 
     191                simulation.update(); 
     192                assertFalse(this.changedValueEventLaunched); 
     193        } 
     194 
     195    // </editor-fold> 
     196     
     197    // <editor-fold defaultstate="collapsed" desc="Constructor Tests"> 
    173198     
    174199    @Test 
     
    191216    } 
    192217     
    193     private class IValueChangedHandler extends EventHandler{ 
    194  
    195         public IValueChangedHandler() { 
     218    private class ValueChangedHandler extends EventHandler{ 
     219 
     220        public ValueChangedHandler() { 
    196221            super(IValueChanged.class); 
    197222        } 
  • ION/trunk/ION.Meta/src/ion/Meta/EventFilter.java

    r45 r182  
    3939    } 
    4040     
    41     public abstract boolean blocks(IEvent request); 
     41    public abstract boolean blocks(IEvent event); 
    4242} 
  • ION/trunk/ION.SyncCollections/src/ion/SyncCollections/HashDictionary.java

    r45 r182  
    2323  09/04/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
    2424  First version. 
     25  --- 
     26  22/05/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
     27  Corrected CollectionModified Exception error on RemoveAll() method when the dictionary was outside a simulation.  
    2528  ---   
    2629*/ 
     
    296299     
    297300    public void removeAll() { 
    298         for (TKey key : this.getDictionary().keySet()) { 
     301        TKey[] keys = (TKey[]) this.getDictionary().keySet().toArray(); 
     302        for (TKey key : keys) { 
    299303            this.schedule(new RemoveRequest(key)); 
    300304        } 
  • ION/trunk/ION.SyncCollections/test/ion/SyncCollections/UnitTests/HashDictionaryTest.java

    r45 r182  
    2323  09/04/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
    2424  First version. 
     25  --- 
     26  22/05/2009      Pedro Cuba <pedro.cuba@tagus.ist.utl.pt> 
     27  Added test for removal of all elements while out of the simulation. 
    2528  ---   
    2629*/ 
     
    7073    public static void tearDownClass() throws Exception { 
    7174    } 
     75     
     76    @Test 
     77    public void RemoveAllTestOut(){ 
     78        HashDictionary<String, Dummy> dictionary = new HashDictionary<String, Dummy>(); 
     79        final String key1 = "dummy1"; 
     80        final String key2 = "dummy2"; 
     81        Dummy value1 = new Dummy(); 
     82        Dummy value2 = new Dummy(); 
     83 
     84        dictionary.add(key1, value1); 
     85        dictionary.add(key2, value2); 
     86        assertTrue(dictionary.contains(key1)); 
     87        assertTrue(dictionary.contains(key2)); 
     88 
     89        assertNull(dictionary.getSimulation()); 
     90        dictionary.removeAll(); 
     91 
     92        assertFalse(dictionary.contains(key1)); 
     93        assertFalse(dictionary.contains(key2)); 
     94        assertEquals(0, dictionary.count()); 
     95    } 
    7296 
    7397    //<editor-fold defaultstate="collapsed" desc="Simple Tests"> 
Note: See TracChangeset for help on using the changeset viewer.