Clover coverage report -
Coverage timestamp: Thu Jul 5 2007 20:02:32 EDT
file stats: LOC: 171   Methods: 13
NCLOC: 139   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
PropagationManagerImpl.java 85.7% 100% 100% 97.9%
coverage coverage
 1    package org.jboss.cache.pojo.test.propagation.impl;
 2   
 3    import org.jboss.cache.pojo.test.propagation.Node;
 4    import org.jboss.cache.pojo.test.propagation.PropagationManager;
 5    import org.jboss.cache.pojo.test.propagation.PropagationRule;
 6    import org.jboss.cache.pojo.test.propagation.StateItem;
 7   
 8    import java.util.HashMap;
 9    import java.util.List;
 10    import java.util.Map;
 11   
 12    public class PropagationManagerImpl implements PropagationManager
 13    {
 14    private Node rootNode_;
 15   
 16    private Map nodeMap_ = new HashMap();
 17   
 18    private transient PropagationRule orRule_;
 19   
 20  6 public PropagationManagerImpl()
 21    {
 22  6 orRule_ = PropagationRuleFactory.getPropagationRule();
 23    }
 24   
 25  4 public void setRootNode(String rdn)
 26    {
 27  4 this.rootNode_ = new NodeImpl();
 28  4 rootNode_.setNodeFDN(rdn);
 29  4 rootNode_.setNodeRDN(rdn);
 30  4 rootNode_.setPropagationRule(orRule_);
 31   
 32  4 StateItem summary = new StateItemImpl(0);
 33  4 summary.setState(PropagationRule.STATE_CLEAR);
 34  4 rootNode_.setSummaryStateItem(summary);
 35   
 36  4 registMap(rootNode_);
 37    }
 38   
 39  16 public void addNode(String parentFdn, String rdn)
 40    {
 41  16 Node parent = findNode(parentFdn);
 42  16 if (parent != null)
 43    {
 44  16 Node node = new NodeImpl();
 45  16 node.setNodeFDN(parentFdn + "." + rdn);
 46  16 node.setNodeRDN(rdn);
 47  16 node.setPropagationRule(orRule_);
 48   
 49  16 node.setParentNode(parent);
 50  16 parent.addChildNode(node);
 51   
 52  16 StateItem summary = new StateItemImpl(0);
 53  16 summary.setState(PropagationRule.STATE_CLEAR);
 54  16 node.setSummaryStateItem(summary);
 55   
 56  16 registMap(node);
 57   
 58  16 PropagationRule rule = node.getPropagationRule();
 59  16 rule.summaryUpperPropagate(node);
 60    }
 61    }
 62   
 63  22 public void addStateItem(String parentFdn, long itemId, long defaultState)
 64    {
 65  22 Node node = findNode(parentFdn);
 66  22 if (node != null)
 67    {
 68  22 StateItem item = new StateItemImpl(itemId);
 69  22 item.setState(defaultState);
 70   
 71  22 node.addStateItem(item);
 72   
 73  22 PropagationRule rule = node.getPropagationRule();
 74  22 rule.summaryUpperPropagate(node);
 75    }
 76    }
 77   
 78  8 public void stateChange(String parentFdn, long itemId, long newState)
 79    {
 80  8 Node node = findNode(parentFdn);
 81  8 if (node != null)
 82    {
 83  6 PropagationRule rule = node.getPropagationRule();
 84  6 rule.changeState(node, itemId, newState);
 85    }
 86    }
 87   
 88  46 public Node findNode(String fdn)
 89    {
 90  46 return (Node) nodeMap_.get(fdn);
 91    }
 92   
 93  20 private void registMap(Node node)
 94    {
 95  20 this.nodeMap_.put(node.getNodeFDN(), node);
 96    }
 97   
 98  12 public void printNodes()
 99    {
 100  12 printNode(rootNode_, "");
 101    }
 102   
 103  68 private void printNode(Node node, String prefix)
 104    {
 105  68 System.out.println(prefix + node.getNodeRDN() + " (Summary : "
 106    + node.getSummaryStateItem().getState() + ")");
 107   
 108  68 String itemPrefix = prefix + " | ";
 109  68 List items = node.getStateItems();
 110  68 int size = items.size();
 111  68 for (int idx = 0; idx < size; idx++)
 112    {
 113  94 StateItem item = (StateItem) items.get(idx);
 114  94 printStateItem(item, itemPrefix);
 115    }
 116   
 117  68 String childPrefix = prefix + " + ";
 118  68 List children = node.getChildren();
 119  68 size = children.size();
 120  68 for (int idx = 0; idx < size; idx++)
 121    {
 122  56 Node child = (Node) children.get(idx);
 123  56 printNode(child, childPrefix);
 124    }
 125    }
 126   
 127  94 private void printStateItem(StateItem item, String prefix)
 128    {
 129  94 System.out.println(prefix + "(" + item.getItemId() + " : "
 130    + item.getState() + ")");
 131    }
 132   
 133  20 private String toNodeString(Node node, String prefix)
 134    {
 135  20 StringBuffer buf = new StringBuffer();
 136   
 137  20 buf.append(prefix + node.getNodeRDN() + " (Summary : "
 138    + node.getSummaryStateItem().getState() + ")");
 139   
 140  20 String itemPrefix = prefix + " | ";
 141  20 List items = node.getStateItems();
 142  20 int size = items.size();
 143  20 for (int idx = 0; idx < size; idx++)
 144    {
 145  20 StateItem item = (StateItem) items.get(idx);
 146  20 buf.append(toStateItemString(item, itemPrefix));
 147    }
 148   
 149  20 String childPrefix = prefix + " + ";
 150  20 List children = node.getChildren();
 151  20 size = children.size();
 152  20 for (int idx = 0; idx < size; idx++)
 153    {
 154  16 Node child = (Node) children.get(idx);
 155  16 buf.append(toNodeString(child, childPrefix));
 156    }
 157   
 158  20 return buf.toString();
 159    }
 160   
 161  20 private String toStateItemString(StateItem item, String prefix)
 162    {
 163  20 return (prefix + "(" + item.getItemId() + " : "
 164    + item.getState() + ")");
 165    }
 166   
 167  4 public String toString()
 168    {
 169  4 return toNodeString(rootNode_, "+");
 170    }
 171    }