svn commit: r788877 [2/2] - in /myfaces/core/branches/2_0_0/api/src: main/java/javax/faces/component/ main/resources/META-INF/ test/java/javax/faces/component/

[lu...@apache.org]

Added: myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaList.java
URL: http://svn.apache.org/viewvc/myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaList.java?rev=788877&view=auto
==============================================================================
--- myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaList.java (added)
+++ myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaList.java Fri Jun 26 21:30:38 2009
@@ -0,0 +1,523 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package javax.faces.component;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+
+import javax.faces.context.FacesContext;
+
+/**
+ * This class handle deltas on facesListener and validatorList.
+ * 
+ * It is only used by this methods on UIComponentBase:
+ * 
+ * addFacesListener
+ * broadcast
+ * getFacesListeners
+ * removeFacesListener
+ * 
+ * A facesListener could hold PartialStateHolder instances, so it 
+ * is necessary to provide convenient methods to track deltas.
+ * 
+ * @author Leonardo Uribe (latest modification by $Author$)
+ * @version $Revision$ $Date$
+ */
+class _DeltaList<T> implements List<T>, PartialStateHolder
+{
+
+    private List<T> _delegate;
+    private UIComponent _component;
+    private Map<Object,Boolean> _deltas;
+    private boolean _initialStateMarked;
+    
+    public _DeltaList()
+    {
+    }
+    
+    public _DeltaList(List<T> delegate)
+    {
+        _delegate = delegate;
+    }
+    
+    private boolean _createDeltas()
+    {
+        if (initialStateMarked())
+        {
+            if (_deltas == null)
+            {
+                _deltas = new HashMap<Object, Boolean>(4);
+            }
+            return true;
+        }
+
+        return false;
+    }    
+
+    public void add(int index, T element)
+    {
+        if (_createDeltas())
+        {
+            _deltas.put(element, Boolean.TRUE);
+        }
+        _delegate.add(index, element);
+    }
+
+    public boolean add(T e)
+    {
+        if (_createDeltas())
+        {
+            _deltas.put(e, Boolean.TRUE);
+        }
+        return _delegate.add(e);
+    }
+
+    public boolean addAll(Collection<? extends T> c)
+    {
+        if (_createDeltas())
+        {
+            for (Iterator<? extends T> it = c.iterator(); it.hasNext();)
+            {
+                _deltas.put(it.next(), Boolean.TRUE);
+            }
+        }        
+        return _delegate.addAll(c);
+    }
+
+    public boolean addAll(int index, Collection<? extends T> c)
+    {
+        if (_createDeltas())
+        {
+            for (Iterator<? extends T> it = c.iterator(); it.hasNext();)
+            {
+                _deltas.put(it.next(), Boolean.TRUE);
+            }
+        }        
+        return _delegate.addAll(index, c);
+    }
+
+    public void clear()
+    {
+        if (_createDeltas())
+        {
+            for (Iterator<? extends T> it = _delegate.iterator(); it.hasNext();)
+            {
+                _deltas.put(it.next(), Boolean.FALSE);
+            }
+        }        
+        _delegate.clear();
+    }
+
+    public boolean contains(Object o)
+    {
+        return _delegate.contains(o);
+    }
+
+    public boolean containsAll(Collection<?> c)
+    {
+        return _delegate.containsAll(c);
+    }
+
+    public boolean equals(Object o)
+    {
+        return _delegate.equals(o);
+    }
+
+    public T get(int index)
+    {
+        return _delegate.get(index);
+    }
+
+    public int hashCode()
+    {
+        return _delegate.hashCode();
+    }
+
+    public int indexOf(Object o)
+    {
+        return _delegate.indexOf(o);
+    }
+
+    public boolean isEmpty()
+    {
+        return _delegate.isEmpty();
+    }
+
+    public Iterator<T> iterator()
+    {
+        return _delegate.iterator();
+    }
+
+    public int lastIndexOf(Object o)
+    {
+        return _delegate.lastIndexOf(o);
+    }
+
+    public ListIterator<T> listIterator()
+    {
+        return _delegate.listIterator();
+    }
+
+    public ListIterator<T> listIterator(int index)
+    {
+        return _delegate.listIterator(index);
+    }
+
+    public T remove(int index)
+    {
+        if (_createDeltas())
+        {
+            _deltas.put(_delegate.get(index), Boolean.FALSE);
+        }        
+        return _delegate.remove(index);
+    }
+
+    public boolean remove(Object o)
+    {
+        if (_createDeltas())
+        {
+            _deltas.put(o, Boolean.FALSE);
+        }                
+        return _delegate.remove(o);
+    }
+
+    public boolean removeAll(Collection<?> c)
+    {
+        if (_createDeltas())
+        {
+            for (Iterator it = c.iterator(); it.hasNext();)
+            {
+                _deltas.put(it.next(), Boolean.FALSE);
+            }
+        }
+        return _delegate.removeAll(c);
+    }
+
+    public boolean retainAll(Collection<?> c)
+    {
+        return _delegate.retainAll(c);
+    }
+
+    public T set(int index, T element)
+    {
+        if (_createDeltas())
+        {
+            _deltas.put(_delegate.get(index), Boolean.FALSE);
+            _deltas.put(element, Boolean.TRUE);
+        }
+        return _delegate.set(index, element);
+    }
+
+    public int size()
+    {
+        return _delegate == null ? 0 : _delegate.size();
+    }
+
+    public List<T> subList(int fromIndex, int toIndex)
+    {
+        return _delegate.subList(fromIndex, toIndex);
+    }
+
+    public Object[] toArray()
+    {
+        return _delegate.toArray();
+    }
+
+    public <T> T[] toArray(T[] a)
+    {
+        return _delegate.toArray(a);
+    }
+
+    public boolean isTransient()
+    {
+        return false;
+    }
+
+    public void setTransient(boolean newTransientValue)
+    {
+        throw new UnsupportedOperationException();
+    }
+
+    public void restoreState(FacesContext context, Object state)
+    {
+        if (state == null)
+        {
+            return;
+        }
+        
+        if (_createDeltas())
+        {            
+            //Restore delta
+            Object[] listAsMap = (Object[]) state;
+            for (int cnt = 0; cnt < listAsMap.length; cnt += 2)
+            {   
+                if (listAsMap[cnt] instanceof Boolean)
+                {
+                    Boolean value = (Boolean) listAsMap[cnt];
+                    T key = (T) UIComponentBase.
+                        restoreAttachedState(context, listAsMap[cnt+1]);
+                    _deltas.put(key,value);
+                    if (key != null)
+                    {
+                        if (value.booleanValue())
+                        {
+                            _delegate.add(key);
+                        }
+                        else
+                        {
+                            _delegate.remove(key);
+                        }
+                    }
+                }
+                else if (listAsMap[cnt+1] != null)
+                {
+                    if (listAsMap[cnt+1] instanceof _AttachedDeltaWrapper)
+                    {
+                        _AttachedDeltaWrapper wrapper = (_AttachedDeltaWrapper) listAsMap[cnt+1];
+                        //Restore delta state
+                        ((PartialStateHolder)_delegate.get((Integer)listAsMap[cnt])).restoreState(context, wrapper.getWrappedStateObject());
+                    }
+                    else
+                    {
+                        //Replace it
+                        _delegate.set((Integer)listAsMap[cnt], (T) UIComponentBase.restoreAttachedState(context, listAsMap[cnt+1]));
+                    }
+                }
+                else if (listAsMap[cnt] != null)
+                {
+                    _delegate.set((Integer)listAsMap[cnt],null);
+                }
+            }
+        }
+        else
+        {
+            //Restore delegate
+            Object[] lst = (Object[]) state;
+            _delegate = new ArrayList<T>(lst.length);
+            for (int i = 0; i < lst.length; i++)
+            {
+                _delegate.add((T) UIComponentBase.restoreAttachedState(context, lst[i]));
+            }
+        }
+    }
+
+    public Object saveState(FacesContext context)
+    {
+        if (initialStateMarked())
+        {
+            if (_deltas != null)
+            {
+                //Count stateHolder instances to keep track
+                int stateHolderKeyCount = 0;
+                for (int i = 0; i < _delegate.size(); i++)
+                {
+                    T key = _delegate.get(i);
+                    if (key instanceof StateHolder && !_deltas.containsKey(key))
+                    {
+                        stateHolderKeyCount+=2;
+                    }
+                }
+                
+                int cnt = 0;
+                boolean nullDelta = true;
+                Object[] mapArr = (Object[]) new Object[_deltas.size() * 2+stateHolderKeyCount];
+                for (Map.Entry<Object, Boolean> entry : _deltas.entrySet())
+                {
+                    mapArr[cnt] = entry.getValue();
+                    Object value = entry.getKey();
+                    if (value instanceof StateHolder ||
+                        value instanceof List ||
+                        !(value instanceof Serializable))
+                    {
+                        mapArr[cnt+1] = UIComponentBase.saveAttachedState(context, value);
+                    }
+                    else
+                    {
+                        mapArr[cnt+1] = value;
+                    }
+                    cnt += 2;
+                    nullDelta = false;
+                }
+    
+                //Deal with StateHolder instances
+                for (int i = 0; i < _delegate.size(); i++)
+                {
+                    T value = _delegate.get(i);
+                    if (value instanceof StateHolder && !_deltas.containsKey(value))
+                    {
+                        mapArr[cnt] = i;
+                        if (value instanceof PartialStateHolder)
+                        {
+                            //Could contain delta, save it as _AttachedDeltaState
+                            PartialStateHolder holder = (PartialStateHolder) value;
+                            if (holder.isTransient())
+                            {                                
+                                mapArr[cnt + 1] = null;
+                                nullDelta = false;
+                            }
+                            else
+                            {
+                                Object savedValue = holder.saveState(context);
+                                if (savedValue != null)
+                                {
+                                    mapArr[cnt+1] = new _AttachedDeltaWrapper(value.getClass(), savedValue);
+                                    nullDelta = false;
+                                }
+                                else
+                                {
+                                    mapArr[cnt] = null;
+                                    mapArr[cnt+1] = null;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            mapArr[cnt+1] = UIComponentBase.saveAttachedState(context, value);
+                            nullDelta = false;
+                        }
+                        cnt+=2;
+                    }
+                }
+                if (nullDelta)
+                {
+                    return null;
+                }
+                return mapArr;
+            }
+            else
+            {
+                //Count stateHolder instances to keep track
+                int stateHolderKeyCount = 0;
+                for (int i = 0; i < _delegate.size(); i++)
+                {
+                    T key = _delegate.get(i);
+                    if (key instanceof StateHolder)
+                    {
+                        stateHolderKeyCount += 2;
+                    }
+                }
+
+                int cnt = 0;
+                Object[] mapArr = (Object[]) new Object[stateHolderKeyCount];
+                boolean nullDelta = true;
+                //Deal with StateHolder instances
+                for (int i = 0; i < _delegate.size(); i++)
+                {
+                    T value = _delegate.get(i);
+                    if (value instanceof StateHolder)
+                    {
+                        mapArr[cnt] = i;
+                        if (value instanceof PartialStateHolder)
+                        {
+                            //Could contain delta, save it as _AttachedDeltaState
+                            PartialStateHolder holder = (PartialStateHolder) value;
+                            if (holder.isTransient())
+                            {                                
+                                mapArr[cnt + 1] = null;
+                                nullDelta = false;
+                            }
+                            else
+                            {
+                                Object savedValue = holder.saveState(context);
+                                if (savedValue != null)
+                                {
+                                    mapArr[cnt+1] = new _AttachedDeltaWrapper(value.getClass(), savedValue);
+                                    nullDelta = false;
+                                }
+                                else
+                                {
+                                    mapArr[cnt] = null;
+                                    mapArr[cnt+1] = null;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            mapArr[cnt+1] = UIComponentBase.saveAttachedState(context, value);
+                            nullDelta = false;
+                        }
+                        cnt+=2;
+                    }
+                }
+                if (nullDelta)
+                {
+                    return null;
+                }
+                return mapArr;                
+            }
+        }
+        else
+        {
+            Object [] lst = new Object[this.size()];
+            int i = 0;
+            for (Iterator it = _delegate.iterator(); it.hasNext();)
+            {
+                lst[i] = UIComponentBase.saveAttachedState(context, it.next());
+                i++;
+            }
+            return lst;
+        }
+    }
+
+    @Override
+    public void clearInitialState()
+    {
+        //Reset delta setting to null
+        _deltas = null;
+        _initialStateMarked = false;
+        if (_delegate != null)
+        {
+            for (T value : _delegate)
+            {
+                if (value instanceof PartialStateHolder)
+                {
+                    ((PartialStateHolder)value).clearInitialState();
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean initialStateMarked()
+    {
+        return _initialStateMarked;
+    }
+
+    @Override
+    public void markInitialState()
+    {
+        _initialStateMarked = true;
+        if (_delegate != null)
+        {
+            for (T value : _delegate)
+            {
+                if (value instanceof PartialStateHolder)
+                {
+                    ((PartialStateHolder)value).markInitialState();
+                }
+            }
+        }
+    }
+}

Propchange: myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaList.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaList.java
------------------------------------------------------------------------------
    svn:keywords = Date Author Id Revision HeadURL

Modified: myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaStateHelper.java
URL: http://svn.apache.org/viewvc/myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaStateHelper.java?rev=788877&r1=788876&r2=788877&view=diff
==============================================================================
--- myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaStateHelper.java (original)
+++ myfaces/core/branches/2_0_0/api/src/main/java/javax/faces/component/_DeltaStateHelper.java Fri Jun 26 21:30:38 2009
@@ -109,6 +109,21 @@
  *   <li>The state is handled in the same way on UIData, so components
  *   inside UIData share its state on all rows. There is no way to save 
  *   delta per row.</li>
+ *   <li>The map backed by method put(Serializable,String,Object) is
+ *   a replacement of UIComponentBase.attributesMap and UIComponent.bindings map.
+ *   Note that on jsf 1.2, instances saved on attributesMap should not be
+ *   StateHolder, but on jsf 2.0 it is possible to have it. PartialStateHolder
+ *   instances are not handled in this map, or in other words delta state is not
+ *   handled in this classes (markInitialState and clearInitialState is not propagated).</li>
+ *   <li>The list backed by method add(Serializable,Object) should be (is not) a 
+ *   replacement of UIComponentBase.facesListeners, but note that StateHelper
+ *   does not implement PartialStateHolder, and facesListener could have instances
+ *   of that class that needs to be notified when UIComponent.markInitialState or
+ *   UIComponent.clearInitialState is called, or in other words facesListeners
+ *   should deal with PartialStateHolder instances.</li>
+ *   <li>The list backed by method add(Serializable,Object) is 
+ *   a replacement of UIViewRoot.phaseListeners list. Note that instances of
+ *   PhaseListener are not expected to implement StateHolder or PartialStateHolder.</li>
  * </ul>
  * </p>
  * <p>
@@ -171,7 +186,7 @@
      */
     private boolean _createDeltas()
     {
-        if (isInitalStateMarked())
+        if (isInitialStateMarked())
         {
             if (_deltas == null)
             {
@@ -183,7 +198,7 @@
         return false;
     }
     
-    protected boolean isInitalStateMarked()
+    protected boolean isInitialStateMarked()
     {
         return _component.initialStateMarked();
     }
@@ -490,7 +505,7 @@
     @Override
     public Object saveState(FacesContext context)
     {
-        Map serializableMap = (isInitalStateMarked()) ? _deltas : _fullState;
+        Map serializableMap = (isInitialStateMarked()) ? _deltas : _fullState;
 
         if (serializableMap == null || serializableMap.size() == 0)
         {
@@ -594,7 +609,7 @@
             Object savedValue = UIComponentBase.restoreAttachedState(context,
                     serializedState[cnt + 1]);
 
-            if (isInitalStateMarked())
+            if (isInitialStateMarked())
             {
                 if (savedValue instanceof InternalDeltaListMap)
                 {

Modified: myfaces/core/branches/2_0_0/api/src/main/resources/META-INF/componentClass12.vm
URL: http://svn.apache.org/viewvc/myfaces/core/branches/2_0_0/api/src/main/resources/META-INF/componentClass12.vm?rev=788877&r1=788876&r2=788877&view=diff
==============================================================================
--- myfaces/core/branches/2_0_0/api/src/main/resources/META-INF/componentClass12.vm (original)
+++ myfaces/core/branches/2_0_0/api/src/main/resources/META-INF/componentClass12.vm Fri Jun 26 21:30:38 2009
@@ -104,6 +104,7 @@
 #set ($defaultValue = false)
 #end
     // Property: $property.name
+#if ($property.isStateHolder())
 #if ($property.isLiteralOnly() || $property.isTagExcluded() )
     private $type $field #if($defaultValue) = $defaultValue;#{else};#{end}
 
@@ -112,6 +113,13 @@
     private $type $field;
     
 #end
+
+    private boolean _$utils.getPrefixedPropertyName("isSet", $property.name)()
+    {
+        Boolean value = (Boolean) getStateHelper().get(PropertyKeys.${property.name}Set);
+        return value == null ? false : value;
+    }
+
 #if($utils.isPrimitiveClass($type) && !$property.isTagExcluded() )
     private boolean ${field}Set;
     
@@ -178,74 +186,263 @@
     public void $utils.getPrefixedPropertyName("set", $property.name)($type $utils.getVariableFromName($property.name))
     {
         this.$field = $utils.getVariableFromName($property.name);
+        if (initialStateMarked())
+        {
+            getStateHelper().put(PropertyKeys.${property.name}Set,Boolean.TRUE);
+        }
 #if ($utils.isPrimitiveClass($type) && !$property.isTagExcluded() )
         this.${field}Set = true;        
 #end
     }
+#else
+## StateHelper aware property
+#if ($property.name == "for")
+## To keep compatibility with RI, we should call it forVal
+#set ($field = "forVal")
+#else
+#set ($field = $property.name)
 #end
 
-    @Override
-    public Object saveState(FacesContext facesContext)
+    public $type $utils.getMethodReaderFromProperty($property.name, $type)()
+    {
+#if ($property.isLiteralOnly())
+#if ($defaultValue)
+        Object value = getStateHelper().get(PropertyKeys.$field);
+        if (value != null)
+        {
+            return $utils.castIfNecessary($type) value;        
+        }
+        return $defaultValue;        
+#else
+        return $utils.castIfNecessary($type) getStateHelper().get(PropertyKeys.$field);        
+#end
+#else
+#if ($defaultValue)
+        return $utils.castIfNecessary($type) getStateHelper().eval(PropertyKeys.$field, $defaultValue);
+#else
+        return $utils.castIfNecessary($type) getStateHelper().eval(PropertyKeys.$field);
+#end
+#end
+    }
+    
+    public void $utils.getPrefixedPropertyName("set", $property.name)($type $utils.getVariableFromName($property.name))
     {
-#set ($primitiveCount = $propertyList.size() + 1)
+        getStateHelper().put(PropertyKeys.$field, $utils.getVariableFromName($property.name) ); 
+    }    
+#end
+#end
+
+#if ($component.className.startsWith("javax.faces.component.html"))
+    protected enum PropertyKeys
+    {
+#else
+    enum PropertyKeys
+    {
+#end
+#set ($comma = "")
+#set ($addc = "false")
+#foreach( $property in $propertyList )
+#if ($property.name == "for")
+#set ($addc = "true")
+## To keep compatibility with RI, we should call it forVal
+#set ($field = "forVal")
+#else
+#set ($field = $property.name)
+#end
+#set ($type = $utils.getClassFromFullClass($property.className))
+#if($utils.getDefaultValueField($property)) 
+#set ($defaultValue = $utils.getDefaultValueField($property))
+#else
+#set ($defaultValue = false)
+#end
+#if ($property.name == "for")
+        $comma $field("for")
+#else
+#if ($property.isStateHolder())
+        $comma ${field}Set
+#else
+        $comma $field
+#end
+#end
+#set($comma = ",")
+#end
+#if ("true" == $addc)
+        ;
+        String c;
+        
+        PropertyKeys()
+        {
+        }
+        
+        //Constructor needed by "for" property
+        PropertyKeys(String c)
+        { 
+            this.c = c;
+        }
+        
+        public String toString()
+        {
+            return ((this.c != null) ? this.c : super.toString());
+        }
+#end
+    }
+
+#set ($primitiveCount = 1) ## $propertyList.size() + 1 
 #foreach( $property in $propertyList )
+#if ($property.isStateHolder())
+#set ($primitiveCount = $primitiveCount + 1)
 #if($utils.isPrimitiveClass($property.className))
 #set ($primitiveCount = $primitiveCount + 1)
 #end
 #end
-        Object[] values = new Object[$primitiveCount];
-        values[0] = super.saveState(facesContext);
+#end
+## saveState and restoreState methods only has sense if we have properties
+## that does not use StateHelper class.
+#if ($primitiveCount > 1)
+
+    public void markInitialState()
+    {
+        super.markInitialState();
+#foreach( $property in $propertyList )
+#set ($field = $property.fieldName)
+#if ($property.isStateHolder())        
+        if ($field != null && 
+            $field instanceof PartialStateHolder)
+        {
+            ((PartialStateHolder)$field).markInitialState();
+        }
+#end
+#end
+    }
+    
+    public void clearInitialState()
+    {
+        if (initialStateMarked())
+        {
+            super.clearInitialState();
+#foreach( $property in $propertyList )
+#set ($field = $property.fieldName)
+#if ($property.isStateHolder())
+##          //Only has sense propagate this method if is initialStateMarked
+            if ($field != null && 
+                $field instanceof PartialStateHolder)
+            {
+                ((PartialStateHolder)$field).clearInitialState();
+            }
+#end
+#end
+        }
+    }
+
+    @Override
+    public Object saveState(FacesContext facesContext)
+    {
+        if (initialStateMarked())
+        {
+            boolean nullDelta = true;
+            Object parentSaved = super.saveState(facesContext);
 #set ($arrayIndex = 0)
 #foreach( $property in $propertyList )
 #set ($field = $property.fieldName)
 #set ($type = $property.className)
+#if ($property.isStateHolder())
 #set ($arrayIndex = $arrayIndex + 1)
-#if ($property.jspName == "validator" && $property.isMethodBinding() )
-        values[$arrayIndex] = saveAttachedState(facesContext,${field}List);
-#elseif ( $property.isStateHolder() )## || $utils.isConverter($type)
-        values[$arrayIndex] = saveAttachedState(facesContext,$field);
-#elseif($utils.isPrimitiveClass($type))
-        values[$arrayIndex] = ${utils.getBoxedClass($type)}.valueOf($field);
-#else
-        values[$arrayIndex] = $field;
+            Object ${property.name}Saved = null;
+            if (!_$utils.getPrefixedPropertyName("isSet", $property.name)() &&
+                $field != null && $field instanceof PartialStateHolder)
+            {
+                //Delta
+                StateHolder holder = (StateHolder) $field;
+                if (!holder.isTransient())
+                {
+                    Object attachedState = holder.saveState(facesContext);
+                    if (attachedState != null)
+                    {
+                        nullDelta = false;
+                    }
+                    ${property.name}Saved = new _AttachedDeltaWrapper(${field}.getClass(),
+                        attachedState);
+                }
+            }
+            else
+            {
+                //Full
+                ${property.name}Saved = saveAttachedState(facesContext,$field);
+                nullDelta = false;
+            }        
+## StateHelper Properties does not need save and restore
+#end
+#end
+            if (parentSaved == null && nullDelta)
+            {
+                //No values
+                return null;
+            }
+            
+            Object[] values = new Object[$primitiveCount];
+            values[0] = parentSaved;
+## Save full state
+#set ($arrayIndex = 0)
+#foreach( $property in $propertyList )
+#set ($field = $property.fieldName)
+#set ($type = $property.className)
+#if ($property.isStateHolder())
+#set ($arrayIndex = $arrayIndex + 1)
+            values[$arrayIndex] = ${property.name}Saved;
+## StateHelper Properties does not need save and restore
+#end
 #end
-#if($utils.isPrimitiveClass($type) && !$property.isTagExcluded())
+            return values;
+        }
+        else
+        {
+            Object[] values = new Object[$primitiveCount];
+            values[0] = super.saveState(facesContext);
+## Save full state
+#set ($arrayIndex = 0)
+#foreach( $property in $propertyList )
+#set ($field = $property.fieldName)
+#set ($type = $property.className)
+#if ($property.isStateHolder())
 #set ($arrayIndex = $arrayIndex + 1)
-        values[$arrayIndex] = Boolean.valueOf(${field}Set);
+            values[$arrayIndex] = saveAttachedState(facesContext,$field);
+## StateHelper Properties does not need save and restore
 #end
 #end
-        return values; 
+            return values;
+        }
     }
 
     @Override
     public void restoreState(FacesContext facesContext, Object state)
     {
+        if (state == null)
+        {
+            return;
+        }
+        
         Object[] values = (Object[])state;
         super.restoreState(facesContext,values[0]);
 #set ($arrayIndex = 0)
 #foreach( $property in $propertyList )
 #set ($field = $property.fieldName)
 #set ($type = $property.className)
+#if ($property.isStateHolder())
 #set ($arrayIndex = $arrayIndex + 1)
-#if ( $property.isStateHolder() )
-#if ($property.jspName == "validator" && $property.isMethodBinding() )
-        ${field}List = (List<Validator>) restoreAttachedState(facesContext,values[$arrayIndex]);
-#elseif ($utils.isList($type))
-        $field = (List) restoreAttachedState(facesContext,values[$arrayIndex]);
-#else
-        $field = $utils.castIfNecessary($type) restoreAttachedState(facesContext,values[$arrayIndex]); 
-#end
-#elseif ($utils.isConverter($type)) 
-        $field = (Converter) restoreAttachedState(facesContext,values[$arrayIndex]);
-#elseif ($utils.isPrimitiveClass($type))
-        $field = ($utils.castIfNecessary($type) values[$arrayIndex]).${type}Value();
+        if (values[$arrayIndex] instanceof _AttachedDeltaWrapper)
+        {
+            //Delta
+            ((StateHolder)$field).restoreState(facesContext, ((_AttachedDeltaWrapper) values[$arrayIndex]).getWrappedStateObject());
+        }
+        else
+        {
+            //Full
+            $field = $utils.castIfNecessary($type) restoreAttachedState(facesContext,values[$arrayIndex]);
+        }         
 #else
-        $field = $utils.castIfNecessary($type) values[$arrayIndex];
-#end
-#if($utils.isPrimitiveClass($type) && !$property.isTagExcluded() )
-#set ($arrayIndex = $arrayIndex + 1)
-        ${field}Set = ((Boolean) values[$arrayIndex]).booleanValue();
+## StateHelper Properties does not need save and restore
 #end
 #end
     }
+#end
 }

Modified: myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_Delta2StateHelperTest.java
URL: http://svn.apache.org/viewvc/myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_Delta2StateHelperTest.java?rev=788877&r1=788876&r2=788877&view=diff
==============================================================================
--- myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_Delta2StateHelperTest.java (original)
+++ myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_Delta2StateHelperTest.java Fri Jun 26 21:30:38 2009
@@ -22,6 +22,9 @@
 import java.util.Map;
 
 import javax.faces.context.FacesContext;
+import javax.faces.event.PhaseEvent;
+import javax.faces.event.PhaseId;
+import javax.faces.event.PhaseListener;
 
 
 public class _Delta2StateHelperTest extends AbstractComponentTest
@@ -480,5 +483,125 @@
             assertNull(mapB.get("key2"));
             assertNull(mapB.get("key1"));
         }
+    }
+    
+    public static class TestPhaseListener1 implements PhaseListener
+    {
+        public TestPhaseListener1(){}
+        
+        @Override
+        public void afterPhase(PhaseEvent event){}
+
+        @Override
+        public void beforePhase(PhaseEvent event){}
+
+        @Override
+        public PhaseId getPhaseId()
+        {
+            return PhaseId.ANY_PHASE;
+        }
+        
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (obj instanceof TestPhaseListener1)
+                return true;
+            return false;
+        }
+    }
+    
+    public static class TestPhaseListener2 implements PhaseListener
+    {
+        public TestPhaseListener2(){}
+        
+        @Override
+        public void afterPhase(PhaseEvent event){}
+
+        @Override
+        public void beforePhase(PhaseEvent event){}
+
+        @Override
+        public PhaseId getPhaseId()
+        {
+            return PhaseId.ANY_PHASE;
+        }
+        
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (obj instanceof TestPhaseListener2)
+                return true;
+            return false;
+        }
+    }    
+        
+    public void testUIViewRootPhaseListener1() throws Exception
+    {
+        UIViewRoot a = new UIViewRoot();
+        UIViewRoot b = new UIViewRoot();
+        
+        PhaseListener phaseListener1 = new TestPhaseListener1();
+        
+        a.addPhaseListener(phaseListener1);
+        
+        b.restoreState(facesContext, a.saveState(facesContext));
+        
+        assertTrue(a.getPhaseListeners().contains(phaseListener1));
+        assertTrue(b.getPhaseListeners().contains(phaseListener1));
+    }
+    
+    public void testUIViewRootPhaseListener2() throws Exception
+    {
+        UIViewRoot a = new UIViewRoot();
+        UIViewRoot b = new UIViewRoot();
+        
+        a.markInitialState();
+        b.markInitialState();
+        
+        PhaseListener phaseListener1 = new TestPhaseListener1();
+        
+        a.addPhaseListener(phaseListener1);
+        
+        b.restoreState(facesContext, a.saveState(facesContext));
+        
+        assertTrue(a.getPhaseListeners().contains(phaseListener1));
+        assertTrue(b.getPhaseListeners().contains(phaseListener1));
+    }
+    
+    public void testUIViewRootPhaseListener3() throws Exception
+    {
+        UIViewRoot a = new UIViewRoot();
+        UIViewRoot b = new UIViewRoot();
+        UIViewRoot c = new UIViewRoot();
+
+        PhaseListener phaseListener2 = new TestPhaseListener1();
+        a.addPhaseListener(phaseListener2);
+        b.addPhaseListener(phaseListener2);
+        c.addPhaseListener(phaseListener2);
+        
+        a.markInitialState();
+        b.markInitialState();
+        c.markInitialState();
+        
+        PhaseListener phaseListener1 = new TestPhaseListener1();
+        
+        a.addPhaseListener(phaseListener1);
+        
+        b.restoreState(facesContext, a.saveState(facesContext));
+        
+        assertTrue(a.getPhaseListeners().contains(phaseListener1));
+        assertTrue(b.getPhaseListeners().contains(phaseListener1));
+        assertTrue(a.getPhaseListeners().contains(phaseListener2));
+        assertTrue(b.getPhaseListeners().contains(phaseListener2));
+        
+        a.removePhaseListener(phaseListener1);
+        a.removePhaseListener(phaseListener2);
+        
+        c.restoreState(facesContext, a.saveState(facesContext));
+        
+        assertFalse(a.getPhaseListeners().contains(phaseListener1));
+        assertFalse(c.getPhaseListeners().contains(phaseListener1));
+        assertFalse(a.getPhaseListeners().contains(phaseListener2));
+        assertFalse(c.getPhaseListeners().contains(phaseListener2));
     }    
 }

Added: myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaFacesListenerListTest.java
URL: http://svn.apache.org/viewvc/myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaFacesListenerListTest.java?rev=788877&view=auto
==============================================================================
--- myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaFacesListenerListTest.java (added)
+++ myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaFacesListenerListTest.java Fri Jun 26 21:30:38 2009
@@ -0,0 +1,494 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package javax.faces.component;
+
+import java.util.Arrays;
+import javax.faces.context.FacesContext;
+import javax.faces.event.FacesListener;
+
+public class _DeltaFacesListenerListTest extends AbstractComponentTest
+{
+    public _DeltaFacesListenerListTest(String arg0)
+    {
+        super(arg0);
+    }
+    
+    public static class UITestComponent extends UIComponentBase
+    {
+        
+        public UITestComponent()
+        {
+        }
+
+        @Override
+        public String getFamily()
+        {
+            return "javax.faces.Test";
+        }
+    }
+    
+    public static class NoStateFacesListener implements FacesListener
+    {
+        public NoStateFacesListener()
+        {
+        }
+
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (obj instanceof NoStateFacesListener)
+                return true;
+            return false;
+        }
+    }
+    
+    public static class NoStateFacesListener2 implements FacesListener
+    {
+        public NoStateFacesListener2()
+        {
+        }
+
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (obj instanceof NoStateFacesListener2)
+                return true;
+            return false;
+        }
+    }
+    
+    public static class StateFacesListener implements FacesListener, StateHolder
+    {
+        private boolean _transient;
+        
+        String value;
+        
+        public StateFacesListener()
+        {
+        }
+
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (obj instanceof StateFacesListener)
+            {
+                if (value == null)
+                {
+                    if (((StateFacesListener)obj).value == null)
+                    {
+                        return true;
+                    }
+                }
+                else if (value.equals(((StateFacesListener)obj).value))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public boolean isTransient()
+        {
+            return _transient;
+        }
+
+        public void setTransient(boolean _transient)
+        {
+            this._transient = _transient;
+        }
+
+        @Override
+        public void restoreState(FacesContext context, Object state)
+        {
+            value = (String) state;
+        }
+
+        @Override
+        public Object saveState(FacesContext context)
+        {
+            return value;
+        }
+
+        public String getValue()
+        {
+            return value;
+        }
+
+        public void setValue(String value)
+        {
+            this.value = value;
+        }
+    }
+    
+    public static class PartialStateFacesListener extends StateFacesListener implements PartialStateHolder
+    {
+        private boolean initialStateMarked;
+        
+        @Override
+        public void restoreState(FacesContext context, Object state)
+        {
+            if (state != null)
+            {
+                value = (String) state;
+            }
+        }
+
+        @Override
+        public Object saveState(FacesContext context)
+        {
+            if (!initialStateMarked())
+            {
+                return value;
+            }
+            return null;
+        }
+
+        @Override
+        public void clearInitialState()
+        {
+            initialStateMarked = false;
+        }
+
+        @Override
+        public boolean initialStateMarked()
+        {
+            return initialStateMarked;
+        }
+
+        @Override
+        public void markInitialState()
+        {
+            initialStateMarked = true;
+        }        
+    }
+
+    @Override
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    @Override
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    public void testSimpleAddRemove()
+    {
+        UITestComponent a = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        a.addFacesListener(listener1);
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        a.removeFacesListener(listener1);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore1()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener1);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore2()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        a.markInitialState();
+        b.markInitialState();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        a.addFacesListener(listener1);
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);       
+        b.restoreState(facesContext, savedState1);
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore3()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        FacesListener listener2 = new NoStateFacesListener();
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener2);
+        a.markInitialState();
+        b.markInitialState();
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        assertNull(savedState1 == null ? null : savedState1[1]);
+        b.restoreState(facesContext, savedState1);        
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore4()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        FacesListener listener2 = new NoStateFacesListener2();
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        a.addFacesListener(listener2);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener2));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener2));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        a.removeFacesListener(listener2);
+        b.removeFacesListener(listener2);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener2));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener2));
+    }
+    
+    public void testSimpleSaveRestore5()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        UITestComponent c = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        FacesListener listener2 = new NoStateFacesListener2();
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        a.addFacesListener(listener2);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener2));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener2));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        a.removeFacesListener(listener2);
+        b.removeFacesListener(listener2);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener2));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener2));
+        
+        //Save fully
+        b.clearInitialState();
+        c.restoreState(facesContext, b.saveState(facesContext));
+        //c._facesListeners should be empty
+        assertFalse(Arrays.asList(c.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(c.getFacesListeners(FacesListener.class)).contains(listener2));
+    }
+    
+    public void testSimpleSaveRestore6()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new StateFacesListener(); 
+        StateFacesListener listener2 = new StateFacesListener();
+        listener1.setValue("value1");
+        listener2.setValue("value2");
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener2);
+        a.markInitialState();
+        b.markInitialState();
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        // This is not null because StateFacesListener is instance of StateHolder 
+        // and always needs to be saved and restored!
+        assertNotNull(savedState1[0]);
+        b.restoreState(facesContext, savedState1);        
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore7()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        UITestComponent c = new UITestComponent();
+        StateFacesListener listener1 = new StateFacesListener(); 
+        StateFacesListener listener2 = new StateFacesListener();
+        listener1.setValue("value1");
+        listener2.setValue("value2");
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        a.addFacesListener(listener2);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener2));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener2));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        a.removeFacesListener(listener2);
+        b.removeFacesListener(listener2);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener2));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener2));
+        
+        //Save fully
+        b.clearInitialState();
+        c.restoreState(facesContext, b.saveState(facesContext));
+        //c._facesListeners should be empty
+        assertFalse(Arrays.asList(c.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(c.getFacesListeners(FacesListener.class)).contains(listener2));
+    }
+    
+    public void testSimpleSaveRestore8()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new PartialStateFacesListener(); 
+        listener1.setValue("value1");
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        // This is null because StateFacesListener is instance of PartialStateHolder 
+        assertNull(savedState1 == null ? null : savedState1[1]);
+        b.restoreState(facesContext, savedState1);        
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore9()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new PartialStateFacesListener(); 
+        listener1.setValue("value1");
+        StateFacesListener listener2 = new PartialStateFacesListener(); 
+        listener2.setValue("value2");        
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        a.addFacesListener(listener2);
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        // This is null because StateFacesListener is instance of PartialStateHolder but a
+        // listener was added after markInitialState
+        assertNotNull(savedState1[0]);
+        b.restoreState(facesContext, savedState1);        
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener2));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener2));
+        a.removeFacesListener(listener1);
+        b.removeFacesListener(listener1);
+        assertFalse(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener2));
+        assertTrue(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener2));
+    }    
+    
+    public void testSimpleSaveRestoreTransient1()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new StateFacesListener();
+        listener1.setTransient(true);
+        listener1.setValue("value");
+        a.addFacesListener(listener1);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+    }
+    
+    public void testSimpleSaveRestoreTransient2()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        a.markInitialState();
+        b.markInitialState();
+        StateFacesListener listener1 = new StateFacesListener();
+        listener1.setTransient(true);
+        listener1.setValue("value");
+        a.addFacesListener(listener1);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+    }
+    
+    public void testSimpleSaveRestoreTransient3()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        FacesListener listener2 = new NoStateFacesListener2();
+        a.addFacesListener(listener2);
+        b.addFacesListener(listener2);        
+        a.markInitialState();
+        b.markInitialState();
+        StateFacesListener listener1 = new StateFacesListener();
+        listener1.setTransient(true);
+        listener1.setValue("value");
+        a.addFacesListener(listener1);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+    }
+    
+    public void testSimpleSaveRestoreTransient4()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new StateFacesListener();
+        listener1.setTransient(true);
+        listener1.setValue("value");
+        a.addFacesListener(listener1);
+        b.addFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        //Since listener1 is transient
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        b.restoreState(facesContext, savedState1);  
+        assertTrue(Arrays.asList(a.getFacesListeners(FacesListener.class)).contains(listener1));
+        assertFalse(Arrays.asList(b.getFacesListeners(FacesListener.class)).contains(listener1));
+    }
+}

Propchange: myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaFacesListenerListTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaFacesListenerListTest.java
------------------------------------------------------------------------------
    svn:keywords = Date Author Id Revision HeadURL

Added: myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaListTest.java
URL: http://svn.apache.org/viewvc/myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaListTest.java?rev=788877&view=auto
==============================================================================
--- myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaListTest.java (added)
+++ myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaListTest.java Fri Jun 26 21:30:38 2009
@@ -0,0 +1,643 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package javax.faces.component;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.faces.context.FacesContext;
+import javax.faces.event.FacesListener;
+
+public class _DeltaListTest extends AbstractComponentTest
+{
+    public _DeltaListTest(String arg0)
+    {
+        super(arg0);
+    }
+    
+    public static class UITestComponent extends UIComponentBase
+    {
+        public _DeltaList<FacesListener> _facesListeners = null;
+        
+        public UITestComponent()
+        {
+        }
+
+        @Override
+        public String getFamily()
+        {
+            return "javax.faces.Test";
+        }
+        
+        public void addTestFacesListener(FacesListener listener)
+        {
+            if (listener == null)
+                throw new NullPointerException("listener");
+            if (_facesListeners == null)
+            {
+                _facesListeners = new _DeltaList<FacesListener>(new ArrayList<FacesListener>());
+            }
+            _facesListeners.add(listener);
+        }
+        
+        public FacesListener[] getTestFacesListeners(Class clazz)
+        {
+            if (clazz == null)
+            {
+                throw new NullPointerException("Class is null");
+            }
+            if (!FacesListener.class.isAssignableFrom(clazz))
+            {
+                throw new IllegalArgumentException("Class " + clazz.getName() + " must implement " + FacesListener.class);
+            }
+
+            if (_facesListeners == null)
+            {
+                return (FacesListener[]) Array.newInstance(clazz, 0);
+            }
+            List<FacesListener> lst = null;
+            for (Iterator<FacesListener> it = _facesListeners.iterator(); it.hasNext();)
+            {
+                FacesListener facesListener = it.next();
+                if (clazz.isAssignableFrom(facesListener.getClass()))
+                {
+                    if (lst == null)
+                        lst = new ArrayList<FacesListener>();
+                    lst.add(facesListener);
+                }
+            }
+            if (lst == null)
+            {
+                return (FacesListener[]) Array.newInstance(clazz, 0);
+            }
+
+            return lst.toArray((FacesListener[]) Array.newInstance(clazz, lst.size()));
+        }
+        
+        public void removeTestFacesListener(FacesListener listener)
+        {
+            if (listener == null)
+            {
+                throw new NullPointerException("listener is null");
+            }
+
+            if (_facesListeners != null)
+            {
+                _facesListeners.remove(listener);
+            }
+        }
+                
+        @Override
+        public void clearInitialState()
+        {
+            super.clearInitialState();
+            if (_facesListeners != null)
+            {
+                _facesListeners.clearInitialState();
+            }
+        }
+
+        @Override
+        public void markInitialState()
+        {
+            super.markInitialState();
+            if (_facesListeners != null)
+            {
+                _facesListeners.markInitialState();
+            }
+        }
+
+        @Override
+        public void restoreState(FacesContext facesContext, Object state)
+        {
+            if (state == null)
+            {
+                return;
+            }
+            
+            Object[] values = (Object[])state;
+            super.restoreState(facesContext,values[0]);
+            if (initialStateMarked())
+            {
+                if (values[1] instanceof _AttachedDeltaWrapper)
+                {
+                    //Delta
+                    if (_facesListeners != null)
+                        ((StateHolder)_facesListeners).restoreState(facesContext,
+                                ((_AttachedDeltaWrapper) values[1]).getWrappedStateObject());
+                }
+                else if (values[1] != null)
+                {
+                    //Full
+                    _facesListeners = (_DeltaList<FacesListener>) restoreAttachedState(facesContext,values[1]);
+                }
+            }
+            else
+            {
+                _facesListeners = (_DeltaList<FacesListener>) restoreAttachedState(facesContext,values[1]);
+            }
+        }
+        
+        private Object saveFacesListenersList(FacesContext facesContext)
+        {
+            PartialStateHolder holder = (PartialStateHolder) _facesListeners;
+            if (initialStateMarked() && _facesListeners != null && holder.initialStateMarked())
+            {                
+                Object attachedState = holder.saveState(facesContext);
+                if (attachedState != null)
+                {
+                    return new _AttachedDeltaWrapper(_facesListeners.getClass(),
+                            attachedState);
+                }
+                //_facesListeners instances once is created never changes, we can return null
+                return null;
+            }
+            else
+            {
+                return saveAttachedState(facesContext,_facesListeners);
+            }            
+        }
+
+        @Override
+        public Object saveState(FacesContext facesContext)
+        {
+            Object[] values = new Object[2];
+            values[0] = super.saveState(facesContext);
+            values[1] = saveFacesListenersList(facesContext);
+            
+            if (values[0] == null && values[1] == null)
+            {
+                //No values
+                return null;
+            }
+            return values;
+        }        
+    }
+    
+    public static class NoStateFacesListener implements FacesListener
+    {
+        public NoStateFacesListener()
+        {
+        }
+
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (obj instanceof NoStateFacesListener)
+                return true;
+            return false;
+        }
+    }
+    
+    public static class NoStateFacesListener2 implements FacesListener
+    {
+        public NoStateFacesListener2()
+        {
+        }
+
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (obj instanceof NoStateFacesListener2)
+                return true;
+            return false;
+        }
+    }
+    
+    public static class StateFacesListener implements FacesListener, StateHolder
+    {
+        private boolean _transient;
+        
+        String value;
+        
+        public StateFacesListener()
+        {
+        }
+
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (obj instanceof StateFacesListener)
+            {
+                if (value == null)
+                {
+                    if (((StateFacesListener)obj).value == null)
+                    {
+                        return true;
+                    }
+                }
+                else if (value.equals(((StateFacesListener)obj).value))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public boolean isTransient()
+        {
+            return _transient;
+        }
+
+        public void setTransient(boolean _transient)
+        {
+            this._transient = _transient;
+        }
+
+        @Override
+        public void restoreState(FacesContext context, Object state)
+        {
+            value = (String) state;
+        }
+
+        @Override
+        public Object saveState(FacesContext context)
+        {
+            return value;
+        }
+
+        public String getValue()
+        {
+            return value;
+        }
+
+        public void setValue(String value)
+        {
+            this.value = value;
+        }
+    }
+    
+    public static class PartialStateFacesListener extends StateFacesListener implements PartialStateHolder
+    {
+        private boolean initialStateMarked;
+        
+        @Override
+        public void restoreState(FacesContext context, Object state)
+        {
+            if (state != null)
+            {
+                value = (String) state;
+            }
+        }
+
+        @Override
+        public Object saveState(FacesContext context)
+        {
+            if (!initialStateMarked())
+            {
+                return value;
+            }
+            return null;
+        }
+
+        @Override
+        public void clearInitialState()
+        {
+            initialStateMarked = false;
+        }
+
+        @Override
+        public boolean initialStateMarked()
+        {
+            return initialStateMarked;
+        }
+
+        @Override
+        public void markInitialState()
+        {
+            initialStateMarked = true;
+        }        
+    }
+
+    @Override
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    @Override
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    public void testSimpleAddRemove()
+    {
+        UITestComponent a = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        a.addTestFacesListener(listener1);
+        assertTrue(a._facesListeners.contains(listener1));
+        a.removeTestFacesListener(listener1);
+        assertFalse(a._facesListeners.contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore1()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener1);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener1));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore2()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        a.markInitialState();
+        b.markInitialState();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        a.addTestFacesListener(listener1);
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);       
+        b.restoreState(facesContext, savedState1);
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener1));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore3()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        FacesListener listener2 = new NoStateFacesListener();
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener2);
+        a.markInitialState();
+        b.markInitialState();
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        assertNull(savedState1 == null ? null : savedState1[1]);
+        b.restoreState(facesContext, savedState1);        
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener1));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore4()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        FacesListener listener2 = new NoStateFacesListener2();
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        a.addTestFacesListener(listener2);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(a._facesListeners.contains(listener2));
+        assertTrue(b._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener2));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        a.removeTestFacesListener(listener2);
+        b.removeTestFacesListener(listener2);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(a._facesListeners.contains(listener2));
+        assertFalse(b._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener2));
+    }
+    
+    public void testSimpleSaveRestore5()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        UITestComponent c = new UITestComponent();
+        FacesListener listener1 = new NoStateFacesListener(); 
+        FacesListener listener2 = new NoStateFacesListener2();
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        a.addTestFacesListener(listener2);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(a._facesListeners.contains(listener2));
+        assertTrue(b._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener2));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        a.removeTestFacesListener(listener2);
+        b.removeTestFacesListener(listener2);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(a._facesListeners.contains(listener2));
+        assertFalse(b._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener2));
+        
+        //Save fully
+        b.clearInitialState();
+        c.restoreState(facesContext, b.saveState(facesContext));
+        //c._facesListeners should be empty
+        assertFalse(c._facesListeners.contains(listener1));
+        assertFalse(c._facesListeners.contains(listener2));
+    }
+    
+    public void testSimpleSaveRestore6()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new StateFacesListener(); 
+        StateFacesListener listener2 = new StateFacesListener();
+        listener1.setValue("value1");
+        listener2.setValue("value2");
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener2);
+        a.markInitialState();
+        b.markInitialState();
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        // This is not null because StateFacesListener is instance of StateHolder 
+        // and always needs to be saved and restored!
+        assertNotNull(savedState1[1]);
+        b.restoreState(facesContext, savedState1);        
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener1));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore7()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        UITestComponent c = new UITestComponent();
+        StateFacesListener listener1 = new StateFacesListener(); 
+        StateFacesListener listener2 = new StateFacesListener();
+        listener1.setValue("value1");
+        listener2.setValue("value2");
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        a.addTestFacesListener(listener2);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(a._facesListeners.contains(listener2));
+        assertTrue(b._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener2));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        a.removeTestFacesListener(listener2);
+        b.removeTestFacesListener(listener2);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(a._facesListeners.contains(listener2));
+        assertFalse(b._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener2));
+        
+        //Save fully
+        b.clearInitialState();
+        c.restoreState(facesContext, b.saveState(facesContext));
+        //c._facesListeners should be empty
+        assertFalse(c._facesListeners.contains(listener1));
+        assertFalse(c._facesListeners.contains(listener2));
+    }
+    
+    public void testSimpleSaveRestore8()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new PartialStateFacesListener(); 
+        listener1.setValue("value1");
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        // This is null because StateFacesListener is instance of PartialStateHolder 
+        assertNull(savedState1 == null ? null : savedState1[1]);
+        b.restoreState(facesContext, savedState1);        
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener1));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));        
+    }
+    
+    public void testSimpleSaveRestore9()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new PartialStateFacesListener(); 
+        listener1.setValue("value1");
+        StateFacesListener listener2 = new PartialStateFacesListener(); 
+        listener2.setValue("value2");        
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        a.addTestFacesListener(listener2);
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        // This is null because StateFacesListener is instance of PartialStateHolder but a
+        // listener was added after markInitialState
+        assertNotNull(savedState1[1]);
+        b.restoreState(facesContext, savedState1);        
+        assertTrue(a._facesListeners.contains(listener1));
+        assertTrue(b._facesListeners.contains(listener1));
+        assertTrue(a._facesListeners.contains(listener2));
+        assertTrue(b._facesListeners.contains(listener2));
+        a.removeTestFacesListener(listener1);
+        b.removeTestFacesListener(listener1);
+        assertFalse(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));
+        assertTrue(a._facesListeners.contains(listener2));
+        assertTrue(b._facesListeners.contains(listener2));
+    }    
+    
+    public void testSimpleSaveRestoreTransient1()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new StateFacesListener();
+        listener1.setTransient(true);
+        listener1.setValue("value");
+        a.addTestFacesListener(listener1);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));
+    }
+    
+    public void testSimpleSaveRestoreTransient2()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        a.markInitialState();
+        b.markInitialState();
+        StateFacesListener listener1 = new StateFacesListener();
+        listener1.setTransient(true);
+        listener1.setValue("value");
+        a.addTestFacesListener(listener1);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));
+    }
+    
+    public void testSimpleSaveRestoreTransient3()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        FacesListener listener2 = new NoStateFacesListener2();
+        a.addTestFacesListener(listener2);
+        b.addTestFacesListener(listener2);        
+        a.markInitialState();
+        b.markInitialState();
+        StateFacesListener listener1 = new StateFacesListener();
+        listener1.setTransient(true);
+        listener1.setValue("value");
+        a.addTestFacesListener(listener1);
+        b.restoreState(facesContext, a.saveState(facesContext));
+        assertTrue(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));
+    }
+    
+    public void testSimpleSaveRestoreTransient4()
+    {
+        UITestComponent a = new UITestComponent();
+        UITestComponent b = new UITestComponent();
+        StateFacesListener listener1 = new StateFacesListener();
+        listener1.setTransient(true);
+        listener1.setValue("value");
+        a.addTestFacesListener(listener1);
+        b.addTestFacesListener(listener1);
+        a.markInitialState();
+        b.markInitialState();
+        //Since listener1 is transient
+        Object [] savedState1 = (Object[]) a.saveState(facesContext);
+        b.restoreState(facesContext, savedState1);  
+        assertTrue(a._facesListeners.contains(listener1));
+        assertFalse(b._facesListeners.contains(listener1));
+    }
+}

Propchange: myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaListTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaListTest.java
------------------------------------------------------------------------------
    svn:keywords = Date Author Id Revision HeadURL

Modified: myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaStateHelperTest.java
URL: http://svn.apache.org/viewvc/myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaStateHelperTest.java?rev=788877&r1=788876&r2=788877&view=diff
==============================================================================
--- myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaStateHelperTest.java (original)
+++ myfaces/core/branches/2_0_0/api/src/test/java/javax/faces/component/_DeltaStateHelperTest.java Fri Jun 26 21:30:38 2009
@@ -72,7 +72,7 @@
         }
 
         @Override
-        protected boolean isInitalStateMarked()
+        protected boolean isInitialStateMarked()
         {
             return _initialStateMarked;
         }
@@ -112,10 +112,10 @@
     public void testIsInitalStateMarked()
     {
         assertTrue("Initial state must be marked", _instance
-                .isInitalStateMarked());
+                .isInitialStateMarked());
         _instance.setInitialStateMarked(false);
         assertFalse("Initial state must be false", _instance
-                .isInitalStateMarked());
+                .isInitialStateMarked());
     }
 
     /**