Clover coverage report - DrJava Test Coverage (drjava-20120422-r5456)
Coverage timestamp: Sun Apr 22 2012 03:13:25 CDT
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 186   Methods: 11
NCLOC: 101   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
DelegatingAction.java 81.8% 86.3% 81.8% 84.5%
coverage coverage
 1    /*BEGIN_COPYRIGHT_BLOCK
 2    *
 3    * Copyright (c) 2001-2010, JavaPLT group at Rice University (drjava@rice.edu)
 4    * All rights reserved.
 5    *
 6    * Redistribution and use in source and binary forms, with or without
 7    * modification, are permitted provided that the following conditions are met:
 8    * * Redistributions of source code must retain the above copyright
 9    * notice, this list of conditions and the following disclaimer.
 10    * * Redistributions in binary form must reproduce the above copyright
 11    * notice, this list of conditions and the following disclaimer in the
 12    * documentation and/or other materials provided with the distribution.
 13    * * Neither the names of DrJava, the JavaPLT group, Rice University, nor the
 14    * names of its contributors may be used to endorse or promote products
 15    * derived from this software without specific prior written permission.
 16    *
 17    * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 18    * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 19    * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 20    * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 21    * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 22    * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 23    * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 24    * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 25    * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 26    * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 27    * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 28    *
 29    * This software is Open Source Initiative approved Open Source Software.
 30    * Open Source Initative Approved is a trademark of the Open Source Initiative.
 31    *
 32    * This file is part of DrJava. Download the current version of this project
 33    * from http://www.drjava.org/ or http://sourceforge.net/projects/drjava/
 34    *
 35    * END_COPYRIGHT_BLOCK*/
 36   
 37    package edu.rice.cs.util.swing;
 38   
 39    import javax.swing.*;
 40    import java.awt.event.*;
 41    import java.beans.*;
 42    import java.util.HashMap;
 43    import java.util.LinkedList;
 44   
 45    public class DelegatingAction implements Action {
 46    /** These keys will be copied from the delegatee. All other keys are held in this action itself.
 47    */
 48    private static final String[] KEYS_TO_DELEGATE = {
 49    //DEFAULT,
 50    NAME,
 51    //SHORT_DESCRIPTION,
 52    //LONG_DESCRIPTION,
 53    //SMALL_ICON,
 54    //ACTION_COMMAND_KEY,
 55    //ACCELERATOR_KEY,
 56    //MNEMONIC_KEY,
 57    };
 58   
 59    /** Can't use a more specific type parameter because of Action interface. */
 60    private HashMap<String, Object> _localProperties = new HashMap<String, Object>();
 61   
 62    /** The action to delegate to. If it's null, this action is disabled and all method calls will result in
 63    * IllegalStateExceptions.
 64    */
 65    private volatile Action _delegatee;
 66    private final LinkedList<PropertyChangeListener> _listenerList =
 67    new LinkedList<PropertyChangeListener>();
 68   
 69    /** Returns value of the key, from delegatee is it's in {@link #KEYS_TO_DELEGATE} or from this if not. */
 70  1981 public Object getValue(String key) {
 71  1981 _checkState();
 72   
 73  320 if (_isDelegatedKey(key)) return _delegatee.getValue(key);
 74  1661 else return _localProperties.get(key);
 75    }
 76   
 77  2285 private boolean _isDelegatedKey(String key) {
 78  2285 for (int i = 0; i < KEYS_TO_DELEGATE.length; i++) {
 79  396 if (KEYS_TO_DELEGATE[i].equals(key)) return true;
 80    }
 81  1889 return false;
 82    }
 83   
 84  304 public void putValue(String key, Object value) {
 85  304 _checkState();
 86   
 87  304 if (_isDelegatedKey(key)) {
 88  76 _delegatee.putValue(key, value);
 89    }
 90    else {
 91  228 Object old = _localProperties.get(key);
 92  228 _localProperties.put(key, value);
 93   
 94  228 PropertyChangeEvent event = new PropertyChangeEvent(this, key, old, value);
 95  228 for (PropertyChangeListener listener : _listenerList) {
 96  456 listener.propertyChange(event);
 97    }
 98    }
 99    }
 100   
 101  0 public void setEnabled(boolean b) {
 102  0 _checkState();
 103  0 _delegatee.setEnabled(b);
 104    }
 105   
 106  225 public boolean isEnabled() {
 107  225 _checkState();
 108  225 return _delegatee.isEnabled();
 109    }
 110   
 111  228 public void addPropertyChangeListener(PropertyChangeListener listener) {
 112  228 _checkState();
 113  228 _delegatee.addPropertyChangeListener(listener);
 114  228 _listenerList.add(listener);
 115    }
 116   
 117  0 public void removePropertyChangeListener(PropertyChangeListener listener) {
 118  0 _checkState();
 119  0 _delegatee.removePropertyChangeListener(listener);
 120  0 _listenerList.remove(listener);
 121    }
 122   
 123  1 public void actionPerformed(ActionEvent ae) {
 124  1 _checkState();
 125  1 _delegatee.actionPerformed(ae);
 126    }
 127   
 128  1 public Action getDelegatee() { return _delegatee; }
 129   
 130  512 public void setDelegatee(final Action newDelegatee) {
 131  512 if (newDelegatee == null) {
 132  0 throw new IllegalArgumentException("setDelegatee(null) is not allowed!");
 133    }
 134   
 135    // create property change notifications
 136  512 boolean isEnabled = newDelegatee.isEnabled();
 137   
 138  512 PropertyChangeEvent enabledEvent
 139    = new PropertyChangeEvent(newDelegatee, "enabled", Boolean.FALSE, isEnabled);
 140   
 141  512 PropertyChangeEvent[] events = null;
 142   
 143  512 if (_delegatee != null) {
 144  134 events = new PropertyChangeEvent[KEYS_TO_DELEGATE.length];
 145   
 146  134 for (int i = 0; i < KEYS_TO_DELEGATE.length; i++) {
 147  134 Object oldValue = _delegatee.getValue(KEYS_TO_DELEGATE[i]);
 148  134 Object newValue = newDelegatee.getValue(KEYS_TO_DELEGATE[i]);
 149   
 150  134 events[i] = new PropertyChangeEvent(newDelegatee,
 151    KEYS_TO_DELEGATE[i],
 152    oldValue,
 153    newValue);
 154    }
 155    }
 156   
 157    // remove listeners from old and add to new
 158  512 for (PropertyChangeListener listener : _listenerList) {
 159  396 if (_delegatee != null) {
 160  396 _delegatee.removePropertyChangeListener(listener);
 161    }
 162   
 163  396 newDelegatee.addPropertyChangeListener(listener);
 164   
 165    // fire property change events for all properties
 166   
 167  396 if (events != null) {
 168  396 for (int i = 0; i < events.length; i++) {
 169  396 listener.propertyChange(events[i]);
 170    }
 171    }
 172   
 173  396 listener.propertyChange(enabledEvent);
 174    }
 175   
 176  512 _delegatee = newDelegatee;
 177    }
 178   
 179  2739 private void _checkState() {
 180  2739 if (_delegatee == null) {
 181  0 throw new IllegalStateException("delegatee is null!");
 182    }
 183    }
 184    }
 185   
 186   
 
CloverReport generated by Clover Code Coverage v1.3.14
Sun Apr 22 2012 03:13:26 CDT.		   Open Source License registered to the DrJava Project. This license of Clover is provided to support the development of DrJava only.