From: <th...@us...> - 2007-03-03 15:43:48
|
Revision: 2357 http://svn.sourceforge.net/pcgen/?rev=2357&view=rev Author: thpr Date: 2007-03-03 07:43:47 -0800 (Sat, 03 Mar 2007) Log Message: ----------- CDOM: Catch up to Trunk 2354 Performance improvement in hot spot of CDOM (edge addition) Modified Paths: -------------- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractListMapGraph.java branches/cdom/code/src/java/pcgen/cdom/graph/PCGenGraph.java branches/cdom/code/src/java/pcgen/core/chooser/AbstractComplexChoiceManager.java branches/cdom/code/src/java/pcgen/core/chooser/ChooserUtilities.java branches/cdom/code/src/java/pcgen/gui/pcGenGUI.java branches/cdom/code/src/java/pcgen/gui/prop/LanguageBundle.properties branches/cdom/code/src/java/pcgen/gui/tabs/InfoAbility.java branches/cdom/code/src/java/pcgen/persistence/lst/AbilityLoader.java branches/cdom/code/src/java/pcgen/util/chooser/ChooserFactory.java branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java branches/cdom/code/src/java/plugin/lsttokens/NaturalattacksLst.java branches/cdom/code/src/java/plugin/lsttokens/skill/VisibleToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/CtToken.java branches/cdom/code/src/java/plugin/lsttokens/template/VisibleToken.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java branches/cdom/code/src/java/pcgen/base/graph/core/DirectionalSetMapGraph.java branches/cdom/code/src/java/pcgen/core/chooser/UserInputChoiceManager.java branches/cdom/code/src/java/pcgen/gui/utils/SwingChooserUserInput.java branches/cdom/code/src/test/pcgen/base/graph/core/DirectionalSetMapGraphTest.java Modified: branches/cdom/code/src/java/pcgen/base/graph/core/AbstractListMapGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractListMapGraph.java 2007-03-03 15:37:57 UTC (rev 2356) +++ branches/cdom/code/src/java/pcgen/base/graph/core/AbstractListMapGraph.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -275,11 +275,6 @@ return false; } /* - * containsNode test means we don't need to check return value of remove - * we 'know' it is present (barring an internal error!) - */ - nodeList.remove(gn); - /* * Note: This method is command sequence sensitive. * * First, the remove (from nodeEdgeMap) below is "guaranteed" to work, @@ -299,6 +294,13 @@ // FUTURE Consider Check of return values here to ensure success?? removeEdge(edge); } + /* + * containsNode test means we don't need to check return value of remove + * we 'know' it is present (barring an internal error!). This remove + * must happen after removeEdge above, as removeEdge may trigger side + * effects that will expect this Node to still be present in the Graph. + */ + nodeList.remove(gn); gcs.fireGraphNodeChangeEvent(gn, NodeChangeEvent.NODE_REMOVED); return true; } Added: branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java (rev 0) +++ branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -0,0 +1,433 @@ +/* + * Copyright (c) Thomas Parker, 2004-2007. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * + * Created on Aug 26, 2004 + * + * Current Ver: $Revision: 1650 $ Last Editor: $Author: thpr $ Last Edited: + * $Date: 2006-11-12 20:40:28 -0500 (Sun, 12 Nov 2006) $ + * + */ +package pcgen.base.graph.core; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * @author Thomas Parker (thpr [at] yahoo.com) + * + * This Graph uses redundant storage to improve query speed for certain methods. + * In addition to simple lists of the nodes and edges present in a Graph, a Map + * from each node to the adjacent edges is maintained. + * + * This class provides a more balanced query speed for querying adjacent graph + * elements. Specifically, an edge knows to which nodes it is connected. To + * determine which edges a node is connected to requires a query to the Graph. + * The Map maintained by this class prevents an iteration over the entire List + * of edges whenever getAdjacentEdgeList(GraphNode n) is called. + * + * WARNING: This AbstractSetMapGraph contains a CACHE which uses the Nodes as a + * KEY. Due to the functioning of a Map (it uses the .hashCode() method), if a + * Node is modified IN PLACE in the Graph (without being removed and readded), + * it WILL cause the caching to FAIL, because the cache will have indexed the + * Node by the old hash code. It is therefore HIGHLY advised that this Graph + * implementation ONLY be used where the Nodes are either Immutable or do not + * override Object.equals(). + * + * Note: It is NOT possible for an edge to connect to a node which is not in the + * graph. There are (at least) two side effects to this limit: (1) If an edge is + * added when the nodes to which it is not connected are not in the Graph, those + * nodes will be implicitly added to the graph. (2) If a node is removed from + * the Graph, all of the edges connected to that node will also be removed from + * the graph. + * + * WARNING: This Graph has SIDE EFFECTS. When any GraphNode is deleted from the + * graph, ANY and ALL Edges connected to that GraphNode are implicitly deleted + * from the graph. You CANNOT rely on the GraphNodeRemoved event, as it will + * occur AFTER all of the attached edges have been removed. You must check for + * and clean up adjacent edges BEFORE removing any GraphNode if you wish for + * those edges (in a modified form) to remain in the graph. + */ +public abstract class AbstractSetMapGraph<N, ET extends Edge<N>> implements + Graph<N, ET> +{ + + /** + * The List of nodes contained in this Graph. + */ + private final Map<N, N> nodeMap; + + /** + * The List of edges contained in this Graph. An edge must be connected to a + * node which is already in the nodeList (this makes no statement about + * whether this addition is done implicitly by addEdge [it is in + * AbstractSetMapGraph] or whether it is explicit). + */ + private final Set<ET> edgeSet; + + /** + * A Map indicating which nodes are connected to which edges. This is + * redundant information to what is actually contained in the edges + * themselves, but is present in AbstractSetMapGraph in order to speed calls + * to getAdjacentEdges + */ + private final transient Map<N, Set<ET>> nodeEdgeMap; + + /** + * The GraphChangeSupport object which provides management of + * GraphChangeListeners and fires events to the listeners. + */ + private final GraphChangeSupport<N, ET> gcs; + + /** + * Creates a new, empty AbstractSetMapGraph + */ + public AbstractSetMapGraph() + { + super(); + edgeSet = new HashSet<ET>(); + nodeMap = new HashMap<N, N>(); + gcs = new GraphChangeSupport<N, ET>(this); + nodeEdgeMap = new HashMap<N, Set<ET>>(); + } + + /** + * Adds the given Node to the Graph. Returns true if the given Node was + * successfully added. + * + * @see pcgen.base.graph.core.Graph#addNode(java.lang.Object) + */ + public boolean addNode(N v) + { + if (v == null) + { + return false; + } + if (nodeMap.containsKey(v)) + { + // Node already in this Graph + return false; + } + nodeMap.put(v, v); + nodeEdgeMap.put(v, new HashSet<ET>()); + gcs.fireGraphNodeChangeEvent(v, NodeChangeEvent.NODE_ADDED); + return true; + } + + public N getInternalizedNode(N v) + { + if (v == null) + { + return null; + } + // TODO FIXME Consider whether to return null or v... if not in the + // Graph? + return nodeMap.get(v); + } + + /** + * Adds the given Edge to the Graph. Returns true if the given Edge was + * successfully added. Implicitly adds any Nodes connected to the given Edge + * to the Graph. + * + * @see pcgen.base.graph.core.Graph#addEdge(java.lang.Object) + */ + public boolean addEdge(ET e) + { + if (e == null) + { + return false; + } + boolean added = edgeSet.add(e); + if (!added) + { + return false; + } + List<N> graphNodes = e.getAdjacentNodes(); + for (N node : graphNodes) + { + addNode(node); + nodeEdgeMap.get(node).add(e); + } + gcs.fireGraphEdgeChangeEvent(e, EdgeChangeEvent.EDGE_ADDED); + return true; + } + + /** + * Returns true if this Graph contains the given Node. + * + * @see pcgen.base.graph.core.Graph#containsNode(java.lang.Object) + */ + public boolean containsNode(Object v) + { + // This is presumably faster than searching through nodeList + return nodeEdgeMap.containsKey(v); + } + + /** + * Returns true if this Graph contains the given Edge + * + * @see pcgen.base.graph.core.Graph#containsEdge(pcgen.base.graph.core.Edge) + */ + public boolean containsEdge(Edge<?> e) + { + return edgeSet.contains(e); + } + + /** + * Returns a List of Nodes in this Graph. + * + * Ownership of the returned List is transferred to the calling Object. No + * reference to the List Object is maintained by AbstractSetMapGraph. + * + * However, the Nodes contained in the List are returned BY REFERENCE, and + * modification of the returned Nodes will modify the nodes contained within + * the AbstractSetMapGraph. + * + * *WARNING*: Modification of the Nodes in place may result in failure of + * the AbstractSetMapGraph to return appropriate values from various methods + * of AbstractSetMapGraph. If a Node is modified in place, the modifications + * must not alter the hash code (as returned by the Node's .hashCode() + * method) for AbstractSetMapGraph to maintain proper operation. + * + * @see pcgen.base.graph.core.Graph#getNodeList() + */ + public List<N> getNodeList() + { + return new ArrayList<N>(nodeMap.keySet()); + } + + /** + * Returns a List of Edges in this Graph. + * + * Ownership of the returned List is transferred to the calling Object. No + * reference to the List Object is maintained by AbstractSetMapGraph. + * However, the Edges contained in the List are returned BY REFERENCE, and + * modification of the returned Edges will modify the Edges contained within + * the AbstractSetMapGraph. + * + * @see pcgen.base.graph.core.Graph#getEdgeList() + */ + public List<ET> getEdgeList() + { + return new ArrayList<ET>(edgeSet); + } + + /** + * Removes the given Node from the AbstractSetMapGraph. As a byproduct of + * this removal, all Edges connected to the Node will also be removed from + * the Graph. + * + * @see pcgen.base.graph.core.Graph#removeNode(java.lang.Object) + */ + public boolean removeNode(N gn) + { + if (gn == null) + { + return false; + } + if (!containsNode(gn)) + { + return false; + } + /* + * Note: This method is command sequence sensitive. + * + * First, the remove (from nodeEdgeMap) below is "guaranteed" to work, + * since the graph must contain the node (test above) and it is assumed + * that the addNode method initialized nodeEdgeMap. + * + * Second, the use of remove is significant, in that it removes the set + * of connected edges from the Map. This is important, since removeEdge + * is called from within the loop, and removeEdge will alter sets within + * nodeEdgeMap. Therefore, the use of get in place of remove for + * creation of this Iterator would result in a + * ConcurrentModificationException (since the set for GraphNode gn would + * be modified by removeEdge while inside this Iterator). + */ + for (ET edge : nodeEdgeMap.remove(gn)) + { + // FUTURE Consider Check of return values here to ensure success?? + removeEdge(edge); + } + /* + * containsNode test means we don't need to check return value of remove + * we 'know' it is present (barring an internal error!). This remove + * must happen after removeEdge above, as removeEdge may trigger side + * effects that will expect this Node to still be present in the Graph. + */ + nodeMap.remove(gn); + gcs.fireGraphNodeChangeEvent(gn, NodeChangeEvent.NODE_REMOVED); + return true; + } + + /** + * Removes the given Edge from the AbstractSetMapGraph. + * + * @see pcgen.base.graph.core.Graph#removeEdge(java.lang.Object) + */ + public boolean removeEdge(ET ge) + { + if (ge == null) + { + return false; + } + boolean removed = edgeSet.remove(ge); + if (!removed) + { + return false; + } + /* + * Must be present in the Graph if we made it to this point + */ + List<N> graphNodes = ge.getAdjacentNodes(); + for (N node : graphNodes) + { + nodeEdgeMap.get(node).remove(ge); + } + gcs.fireGraphEdgeChangeEvent(ge, EdgeChangeEvent.EDGE_REMOVED); + return true; + } + + /** + * Returns a Set of the Edges which are Adjacent (connected) to the given + * Node. Returns null if the given Node is not in the Graph. + * + * Ownership of the returned Set is transferred to the calling Object. No + * reference to the Set Object is maintained by AbstractSetMapGraph. + * However, the Edges contained in the Set are returned BY REFERENCE, and + * modification of the returned Edges will modify the Edges contained within + * the AbstractSetMapGraph. + * + * @see pcgen.base.graph.core.Graph#getAdjacentEdges(java.lang.Object) + */ + public Set<ET> getAdjacentEdges(N gn) + { + // implicitly returns null if gn is not in the nodeEdgeMap + Set<ET> s = nodeEdgeMap.get(gn); + return s == null ? null : new HashSet<ET>(s); + } + + /** + * Adds the given GraphChangeListener as a GraphChangeListener of this + * Graph. + * + * @see pcgen.base.graph.core.Graph#addGraphChangeListener(pcgen.base.graph.core.GraphChangeListener) + */ + public void addGraphChangeListener(GraphChangeListener<N, ET> arg0) + { + gcs.addGraphChangeListener(arg0); + } + + /** + * Returns an array of the GraphChangeListeners to this Graph. + * + * Ownership of the returned Array is transferred to the calling Object. No + * reference to the Array is maintained by AbstractSetMapGraph. However, the + * GraphChangeListeners contained in the Array are (obviously!) returned BY + * REFERENCE, and care should be taken with modifying those + * GraphChangeListeners. + * + * @see pcgen.base.graph.core.Graph#getGraphChangeListeners() + */ + public GraphChangeListener<N, ET>[] getGraphChangeListeners() + { + return gcs.getGraphChangeListeners(); + } + + /** + * Removes the given GraphChangeListener as a GraphChangeListener of this + * Graph. + * + * @see pcgen.base.graph.core.Graph#removeGraphChangeListener(pcgen.base.graph.core.GraphChangeListener) + */ + public void removeGraphChangeListener(GraphChangeListener<N, ET> arg0) + { + gcs.removeGraphChangeListener(arg0); + } + + /** + * Tests to see if this Graph is equal to the provided Object. This will + * return true if the given Object is also a Graph, and that Graph contains + * equal Nodes and Edges. + * + * @param o + * The Object to be tested for equality with this Graph + * @return true if the given Object is a Graph that contains equal Nodes and + * Edges to this Graph; false otherwise + */ + @Override + public boolean equals(Object other) + { + if (!(other instanceof Graph)) + { + return false; + } + Graph<N, ET> otherGraph = (Graph<N, ET>) other; + List<N> otherNodeList = otherGraph.getNodeList(); + int thisNodeSize = nodeMap.size(); + if (thisNodeSize != otherNodeList.size()) + { + System.err.println("Not equal node count"); + return false; + } + // (potentially wasteful, but defensive copy) + otherNodeList = new ArrayList<N>(otherNodeList); + if (otherNodeList.retainAll(nodeMap.keySet())) + { + // Some nodes are not identical + System.err.println("Not equal node list"); + System.err.println(nodeMap.keySet()); + System.err.println(otherNodeList); + return false; + } + // Here, the node lists are identical... + List<ET> otherEdgeList = otherGraph.getEdgeList(); + int thisEdgeSize = edgeSet.size(); + if (thisEdgeSize != otherEdgeList.size()) + { + System.err.println("Not equal edge count"); + return false; + } + // (potentially wasteful, but defensive copy) + otherEdgeList = new ArrayList<ET>(otherEdgeList); + if (otherEdgeList.retainAll(edgeSet)) + { + // Other Graph contains extra edges + System.err.println("not equal edge retain"); + System.err.println(edgeSet); + System.err.println(otherEdgeList); + return false; + } + return true; + } + + /** + * Returns the hashCode for this Graph. + * + * @return the hashCode for this Graph. + */ + @Override + public int hashCode() + { + // This is really simple, but it works... and prevents a deep hash + return nodeMap.size() + edgeSet.size() * 23; + } +} \ No newline at end of file Added: branches/cdom/code/src/java/pcgen/base/graph/core/DirectionalSetMapGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/DirectionalSetMapGraph.java (rev 0) +++ branches/cdom/code/src/java/pcgen/base/graph/core/DirectionalSetMapGraph.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -0,0 +1,168 @@ +/* + * Copyright (c) Thomas Parker, 2005, 2006. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * + * Created on May 18, 2005 + * + * Current Ver: $Revision: 1650 $ Last Editor: $Author: thpr $ Last Edited: + * $Date: 2006-11-12 20:40:28 -0500 (Sun, 12 Nov 2006) $ + * + */ +package pcgen.base.graph.core; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Set; + +/** + * @author Thomas Parker (thpr [at] yahoo.com) + * + * A DirectionalSetMapGraph is a DirectionalGraph. Thus, it requires that all + * Edges added to the Graph are DirectionalEdges. Failure to abide by this + * restriction will result in the addition of the edge failing. + * + * This Graph uses redundant storage to improve query speed for certain methods. + * In addition to simple lists of the nodes and edges present in a Graph, a Map + * from each node to the adjacent edges is maintained. + * + * This class provides a more balanced query speed for querying adjacent graph + * elements. Specifically, an edge knows to which nodes it is connected. To + * determine which edges a node is connected to requires a query to the Graph. + * The Map maintained by this class prevents an iteration over the entire List + * of edges whenever getAdjacentEdgeList(GraphNode n) is called. + * + * WARNING: This DirectionalSetMapGraph contains a CACHE which uses the Nodes as + * a KEY. Due to the functioning of a Map (it uses the .hashCode() method), if a + * Node is modified IN PLACE in the Graph (without being removed and readded), + * it WILL cause the caching to FAIL, because the cache will have indexed the + * Node by the old hash code. It is therefore HIGHLY advised that this Graph + * implementation ONLY be used where the Nodes are either Immutable or do not + * override Object.equals(). + * + * Note: It is NOT possible for an Edge to connect to a Node which is not in the + * graph. There are (at least) two side effects to this limit: (1) If an Edge is + * added when the Nodes to which it is not connected are not in the Graph, those + * Nodes will be implicitly added to the graph. (2) If a Node is removed from + * the Graph, all of the Edges connected to that Node will also be removed from + * the graph. + * + * WARNING: This Graph has SIDE EFFECTS. When any Node is deleted from the + * graph, ANY and ALL DirectionalEdges connected to that Node are implicitly + * deleted from the graph. You CANNOT rely on the GraphNodeRemoved event, as it + * will occur AFTER all of the attached Edges have been removed. You must check + * for and clean up adjacent Edges BEFORE removing any Node if you wish for + * those Edges to remain (in a modified form, of course) in the + * DirectionalSetMapGraph. + */ +public class DirectionalSetMapGraph<N, ET extends DirectionalEdge<N>> extends + AbstractSetMapGraph<N, ET> implements DirectionalGraph<N, ET> { + + /** + * Creates a new, empty DirectionalSetMapGraph + */ + public DirectionalSetMapGraph() { + super(); + } + + /** + * Returns a List of the Edges for which the given Node is a Sink. + * + * Ownership of the returned List is transferred to the calling Object. No + * reference to the List Object is maintained by DirectionalSetMapGraph. + * However, the Edges contained in the List are returned BY REFERENCE, and + * modification of the returned Edges will modify the Edges contained within + * the DirectionalSetMapGraph. + * + * @see pcgen.base.graph.core.DirectionalGraph#getInwardEdgeList(java.lang.Object) + */ + public List<ET> getInwardEdgeList(N v) { + Set<ET> adjacentEdgeList = super.getAdjacentEdges(v); + if (adjacentEdgeList == null) { + return null; + } + List<ET> inwardEdgeList = new LinkedList<ET>(); + for (ET edge : adjacentEdgeList) { + if ((edge.getNodeInterfaceType(v) & DirectionalEdge.SINK) != 0) { + inwardEdgeList.add(edge); + } + } + return inwardEdgeList; + } + + /** + * Returns a List of the Edges for which the given Node is a source. + * + * Ownership of the returned List is transferred to the calling Object. No + * reference to the List Object is maintained by DirectionalSetMapGraph. + * However, the Edges contained in the List are returned BY REFERENCE, and + * modification of the returned Edges will modify the Edges contained within + * the DirectionalSetMapGraph. + * + * @see pcgen.base.graph.core.DirectionalGraph#getOutwardEdgeList(java.lang.Object) + */ + public List<ET> getOutwardEdgeList(N v) { + Set<ET> adjacentEdgeList = super.getAdjacentEdges(v); + if (adjacentEdgeList == null) { + return null; + } + List<ET> outwardEdgeList = new ArrayList<ET>(); + for (ET edge : adjacentEdgeList) { + if ((edge.getNodeInterfaceType(v) & DirectionalEdge.SOURCE) != 0) { + outwardEdgeList.add(edge); + } + } + return outwardEdgeList; + } + + /** + * Returns true if the given Node is connected to any edges as a sink Node. + * + * @see pcgen.base.graph.core.DirectionalGraph#hasInwardEdge(java.lang.Object) + */ + public boolean hasInwardEdge(N v) { + Set<ET> adjacentEdgeList = super.getAdjacentEdges(v); + if (adjacentEdgeList == null) { + return false; + } + for (ET edge : adjacentEdgeList) { + if ((edge.getNodeInterfaceType(v) & DirectionalEdge.SINK) != 0) { + return true; + } + } + return false; + } + + /** + * Returns true if the given Node is connected to any edges as a source + * Node. + * + * @see pcgen.base.graph.core.DirectionalGraph#hasOutwardEdge(java.lang.Object) + */ + public boolean hasOutwardEdge(N v) { + Set<ET> adjacentEdgeList = super.getAdjacentEdges(v); + if (adjacentEdgeList == null) { + return false; + } + for (ET edge : adjacentEdgeList) { + if ((edge.getNodeInterfaceType(v) & DirectionalEdge.SOURCE) != 0) { + return true; + } + } + return false; + } + +} Modified: branches/cdom/code/src/java/pcgen/cdom/graph/PCGenGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/graph/PCGenGraph.java 2007-03-03 15:37:57 UTC (rev 2356) +++ branches/cdom/code/src/java/pcgen/cdom/graph/PCGenGraph.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -17,10 +17,9 @@ */ package pcgen.cdom.graph; -import pcgen.base.graph.core.DirectionalListMapGraph; +import pcgen.base.graph.core.DirectionalSetMapGraph; import pcgen.cdom.base.PrereqObject; public class PCGenGraph extends - DirectionalListMapGraph<PrereqObject, PCGraphEdge> -{ + DirectionalSetMapGraph<PrereqObject, PCGraphEdge> { } Modified: branches/cdom/code/src/java/pcgen/core/chooser/AbstractComplexChoiceManager.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/chooser/AbstractComplexChoiceManager.java 2007-03-03 15:37:57 UTC (rev 2356) +++ branches/cdom/code/src/java/pcgen/core/chooser/AbstractComplexChoiceManager.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -55,7 +55,8 @@ protected int maxNewSelections = 0; protected int maxSelections = 0; protected boolean remove = false; - private int preChooserChoices = 0; + protected boolean infiniteAvail = false; + protected int preChooserChoices = 0; /** * Creates a new ChoiceManager object. @@ -141,6 +142,15 @@ choices = mainList.subList(i, mainList.size()); + calcPool(aPC); + } + + /** + * Calculate the pool and associated values. + * @param aPC The character the chooser is being displayed for. + */ + protected void calcPool(PlayerCharacter aPC) + { double pool = 0; if (pobject instanceof Ability) { @@ -225,7 +235,7 @@ preChooserChoices = selectedList.size(); int numChoicesThisTime = numberOfChoices; - if (numChoicesThisTime > 0) + if (numChoicesThisTime > 0 && !infiniteAvail) { // Make sure that we don't try to make the user choose more selections // than are available or we'll be in an infinite loop... @@ -243,7 +253,7 @@ } boolean showChooser = true; - if (availableList.size() == 1 && "NOCHOICE".equals(availableList.get(0).toString())) { + if (!infiniteAvail && availableList.size() == 1 && "NOCHOICE".equals(availableList.get(0).toString())) { if (remove) { try @@ -264,14 +274,12 @@ numChoicesThisTime = 0; } - final ChooserInterface chooser = ChooserFactory.getChooserInstance(); + final ChooserInterface chooser = getChooserInstance(); chooser.setPoolFlag(false); // user is not required to make any changes chooser.setAllowsDups(dupsAllowed); // only stackable feats can be duped chooser.setVisible(false); chooser.setPool(requestedSelections); - title = title + " (" + pobject.getDisplayName() + ')'; - chooser.setTitle(title); Globals.sortChooserLists(availableList, selectedList); while (true) @@ -323,6 +331,19 @@ } /** + * Retrieve the appropriate chooser to use and set its title. + * + * @return The chooser to be displayed to the user. + */ + protected ChooserInterface getChooserInstance() + { + final ChooserInterface chooser = ChooserFactory.getChooserInstance(); + title = title + " (" + pobject.getDisplayName() + ')'; + chooser.setTitle(title); + return chooser; + } + + /** * what type of chooser does this handle * * @return type of chooser Modified: branches/cdom/code/src/java/pcgen/core/chooser/ChooserUtilities.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/chooser/ChooserUtilities.java 2007-03-03 15:37:57 UTC (rev 2356) +++ branches/cdom/code/src/java/pcgen/core/chooser/ChooserUtilities.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -342,6 +342,7 @@ classLookup.put("FEAT", SimpleFeatChoiceManager.class.getName()); classLookup.put("SHIELDPROF", SimpleShieldProfChoiceManager.class.getName()); //classLookup.put("SPELLLEVEL", SimpleSpellLevelChoiceManager.class.getName()); + classLookup.put("USERINPUT", UserInputChoiceManager.class.getName()); classLookup.put("WEAPONPROF", SimpleWeaponProfChoiceManager.class.getName()); // The following three choosers can be deprecated in favor of CHOOSE:SKILLSNAMED|CLASS Copied: branches/cdom/code/src/java/pcgen/core/chooser/UserInputChoiceManager.java (from rev 2354, Trunk/pcgen/code/src/java/pcgen/core/chooser/UserInputChoiceManager.java) =================================================================== --- branches/cdom/code/src/java/pcgen/core/chooser/UserInputChoiceManager.java (rev 0) +++ branches/cdom/code/src/java/pcgen/core/chooser/UserInputChoiceManager.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -0,0 +1,197 @@ +/* + * SwingChooserUserInput.java + * Copyright 2007 (C) James Dempsey + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Created on 2 Mar 2007 + * + * $$Id$$ + */ +package pcgen.core.chooser; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +import pcgen.core.Ability; +import pcgen.core.Constants; +import pcgen.core.PObject; +import pcgen.core.PlayerCharacter; +import pcgen.core.SettingsHandler; +import pcgen.util.Logging; +import pcgen.util.chooser.ChooserFactory; +import pcgen.util.chooser.ChooserInterface; + +/** + * Handle the logic necessary to get a free text choice from the user. + * + * Last Editor: $Author$ + * Last Edited: $Date$ + * + * @author James Dempsey <jde...@us...> + * @version $Revision$ + */ +public class UserInputChoiceManager extends AbstractComplexChoiceManager<String> +{ + protected int selectionsPerAbility = 0; + + /** + * Creates a new UserInputChoiceManager object. + * + * @param aPObject The object the chooser is for. + * @param theChoices The LST definition of the choices to be offered. + * @param aPC The character the chooser is for. + */ + public UserInputChoiceManager(PObject aPObject, String theChoices, PlayerCharacter aPC) + { + super(aPObject, aPC); + chooserHandled = "USERINPUT"; + infiniteAvail = true; + parseParams(theChoices, aPC); + } + + /** + * Parse the parameters supplied to the chooser. Expected format + * is CHOOSE:USERINPUT|x|TITLE="y" + * + * @param theChoices The list of parameters, seperated by | + * @param aPC The character the chooser is for. + */ + private void parseParams(String theChoices, PlayerCharacter aPC) + { + final List<String> split = Arrays.asList(theChoices.split("[|]")); + + choices = Collections.emptyList(); + + if (split.size() < 1) + { + return; + } + + for (int i = 0; i < split.size(); i++) + { + String param = split.get(i); + if (i == 0) + { + continue; + } + else if (param.startsWith("TITLE=")) + { + param = param.substring(6); + if (param.startsWith("\"")) + { + param = param.substring(1, param.length()-1); + } + title = param; + } + else if (i == 1) + { + requestedSelections = aPC.getVariableValue(param, "").intValue(); + } + else + { + Logging.errorPrintLocalised("in_uichooser_bad_param", param); + } + } + selectionsPerAbility = requestedSelections; + + double pool = 0; + if (pobject instanceof Ability) + { + pool = + pc.getAvailableAbilityPool( + SettingsHandler.getGame().getAbilityCategory( + ((Ability) pobject).getCategory())).doubleValue(); + } + else + { + pool = aPC.getRawFeats(true); + } + maxSelections = + (int) ((pool* requestedSelections) + pobject.getAssociatedCount()); + + maxNewSelections = (int) (pool * requestedSelections); + + if (cost == 0 && maxNewSelections == 0) + { + maxNewSelections = requestedSelections; + } + + } + + /** + * Construct the choices available from this ChoiceManager in availableList. + * Any Feats that are eligible to be added to availableList that the PC + * already has will also be added to selectedList. + * + * @param aPc The PC the chooser is for. + * @param availableList The list to be populated with available items. + * @param selectedList The list to be populated with already selected items. + */ + public void getChoices( + final PlayerCharacter aPc, + final List<String> availableList, + final List<String> selectedList) + { + if (pobject.getAssociatedCount() != 0) + { + List<String> abilityKeys = new ArrayList<String>(); + pobject.addAssociatedTo( abilityKeys ); + selectedList.addAll(abilityKeys); + } + availableList.clear(); + availableList.add(Constants.EMPTY_STRING); + } + + /** + * Retrieve the appropriate chooser to use and set its title. + * + * @return The chooser to be displayed to the user. + */ + protected ChooserInterface getChooserInstance() + { + final ChooserInterface chooser = ChooserFactory.getUserInputInstance(); + chooser.setTitle(title); + return chooser; + } + + + /** + * Adjust the number of feats the PC has available to take account of this choice + * + * @param aPC The PC the chooser is for + * @param selected The list of selected items. + */ + protected void adjustFeats( + PlayerCharacter aPC, + List<String> selected) + { + double featCount = aPC.getFeats(); + + if (cost > 0) + { + featCount = + (selectionsPerAbility > 0) + ? featCount + - (((selected.size() - preChooserChoices) / selectionsPerAbility) * cost) + : ((maxSelections - selected.size()) * cost); + } + + aPC.adjustFeats(featCount - aPC.getFeats()); + } + +} \ No newline at end of file Modified: branches/cdom/code/src/java/pcgen/gui/pcGenGUI.java =================================================================== --- branches/cdom/code/src/java/pcgen/gui/pcGenGUI.java 2007-03-03 15:37:57 UTC (rev 2356) +++ branches/cdom/code/src/java/pcgen/gui/pcGenGUI.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -75,6 +75,7 @@ import pcgen.gui.utils.ShowMessageGuiObserver; import pcgen.gui.utils.SwingChooser; import pcgen.gui.utils.SwingChooserRadio; +import pcgen.gui.utils.SwingChooserUserInput; import pcgen.gui.utils.Utility; import pcgen.io.ExportHandler; import pcgen.io.PCGFile; @@ -171,6 +172,8 @@ ChooserFactory.setInterfaceClassname(SwingChooser.class.getName()); ChooserFactory.setRadioInterfaceClassname(SwingChooserRadio.class .getName()); + ChooserFactory.setUserInputInterfaceClassname(SwingChooserUserInput.class + .getName()); InputFactory.setInterfaceClassname(DialogInputInterface.class .getName()); } @@ -179,6 +182,8 @@ ChooserFactory.setInterfaceClassname(NonGuiChooser.class.getName()); ChooserFactory.setRadioInterfaceClassname(NonGuiChooserRadio.class .getName()); + ChooserFactory.setUserInputInterfaceClassname(NonGuiChooser.class + .getName()); } // If we are not using the GUI then just load, export and exit Modified: branches/cdom/code/src/java/pcgen/gui/prop/LanguageBundle.properties =================================================================== --- branches/cdom/code/src/java/pcgen/gui/prop/LanguageBundle.properties 2007-03-03 15:37:57 UTC (rev 2356) +++ branches/cdom/code/src/java/pcgen/gui/prop/LanguageBundle.properties 2007-03-03 15:43:47 UTC (rev 2357) @@ -3863,7 +3863,7 @@ # added 2007-01-23 in_iayIsSomehowInState=is somehow in state in_iayWhichIsNotHandeledInIAaddAb=which is not handled in InfoAbility.addAbility() -in_iayAddAbility=Add Ability +in_iayAddAbility=Failed to add Ability due to {0}. See log for further deatils. in_iayFailedToRemoveAbility=Failed to remove ability. in_iayRemoveAbility=Remove Ability in_filter=Filter @@ -3874,3 +3874,7 @@ in_icNextLevel=Next Level in_icFindItem=Find item in_icFailureWhileShowingClassTab=Failure while showing class tab. Class tab may not be properly displayed. + +in_uichooser_value=Enter a value: +in_uichooser_bad_param=Unrecognised parameter "{0}" for CHOOSE:USERINPUT + \ No newline at end of file Modified: branches/cdom/code/src/java/pcgen/gui/tabs/InfoAbility.java =================================================================== --- branches/cdom/code/src/java/pcgen/gui/tabs/InfoAbility.java 2007-03-03 15:37:57 UTC (rev 2356) +++ branches/cdom/code/src/java/pcgen/gui/tabs/InfoAbility.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -662,8 +662,10 @@ } catch (Exception exc) { - ShowMessageDelegate.showMessageDialog(PropertyFactory.getString("in_iayAddAbility") + ": " - + exc.getMessage(), Constants.s_APPNAME, MessageType.ERROR); + Logging.errorPrint("Failed to add ability due to ", exc); + ShowMessageDelegate.showMessageDialog(PropertyFactory + .getFormattedString("in_iayAddAbility", exc.getMessage()), + Constants.s_APPNAME, MessageType.ERROR); } // update the skills tab, as feats could effect totals Copied: branches/cdom/code/src/java/pcgen/gui/utils/SwingChooserUserInput.java (from rev 2354, Trunk/pcgen/code/src/java/pcgen/gui/utils/SwingChooserUserInput.java) =================================================================== --- branches/cdom/code/src/java/pcgen/gui/utils/SwingChooserUserInput.java (rev 0) +++ branches/cdom/code/src/java/pcgen/gui/utils/SwingChooserUserInput.java 2007-03-03 15:43:47 UTC (rev 2357) @@ -0,0 +1,967 @@ + +/* + * SwingChooserUserInput.java + * Copyright 2007 (C) James Dempsey + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Created on 2 Mar 2007 + * + * $$Id$$ + */ +package pcgen.gui.utils; + +import java.awt.BorderLayout; +import java.awt.Container; +import java.awt.Dimension; +import java.awt.GridBagConstraints; +import java.awt.GridBagLayout; +import java.awt.Insets; +import java.awt.Rectangle; +import java.awt.Window; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.StringTokenizer; + +import javax.swing.JButton; +import javax.swing.JDialog; +import javax.swing.JLabel; +import javax.swing.JOptionPane; +import javax.swing.JPanel; +import javax.swing.JScrollPane; +import javax.swing.JTextField; +import javax.swing.ListSelectionModel; +import javax.swing.ScrollPaneConstants; +import javax.swing.WindowConstants; +import javax.swing.event.CaretEvent; +import javax.swing.event.CaretListener; +import javax.swing.event.ListSelectionEvent; +import javax.swing.event.ListSelectionListener; +import javax.swing.table.TableModel; + +import pcgen.core.Constants; +import pcgen.core.Globals; +import pcgen.gui.utils.chooser.ChooserTableModel; +import pcgen.util.PropertyFactory; +import pcgen.util.chooser.ChooserInterface; + +/** + * This dialog type accepts text entry of items, a choice + * limit, and some additional flags and switches. The user can + * enter and remove values until the required number of + * choices have been made. The dialog is always modal, so a + * call to show() will block program execution. + * + * Last Editor: $Author$ + * Last Edited: $Date$ + * + * @author James Dempsey + * @version $Revision$ + */ +public final class SwingChooserUserInput extends JDialog implements ChooserInterface +{ + static final long serialVersionUID = -2148735105737308335L; + private static final String in_uichooser_value; + private static final String in_selected; + private static final String in_completeMess; + private static final String in_chooser; + private static final String in_selRemain; + private static final String in_validItem; + private static final String in_deselectOne; + private static final String in_noRemain; + private static final String in_selectPartA; + private static final String in_selectPartB; + private static final String in_alreadySelected; + private static final String in_closeChooserTip; + private static final String in_pressToAdd; + private static final String in_pressToRemove; + private static final String in_removeOne; + + /** + * Resource bundles + */ + static + { + in_uichooser_value = PropertyFactory.getString("in_uichooser_value"); + in_selected = PropertyFactory.getString("in_selected"); + in_completeMess = PropertyFactory.getString("in_completeMess"); + in_chooser = PropertyFactory.getString("in_chooser"); + in_selRemain = PropertyFactory.getString("in_selRemain"); + in_validItem = PropertyFactory.getString("in_validItem"); + in_deselectOne = PropertyFactory.getString("in_deselectOne"); + in_noRemain = PropertyFactory.getString("in_noRemain"); + in_selectPartA = PropertyFactory.getString("in_selectPartA"); + in_selectPartB = PropertyFactory.getString("in_selectPartB"); + in_alreadySelected = PropertyFactory.getString("in_alreadySelected"); + in_closeChooserTip = PropertyFactory.getString("in_closeChooserTip"); + in_pressToAdd = PropertyFactory.getString("in_pressToAdd"); + in_pressToRemove = PropertyFactory.getString("in_pressToRemove"); + in_removeOne = PropertyFactory.getString("in_removeOne"); + } + + /** The default selected list column array */ + private static final List<String> SELECTED_COLUMN_NAMES = + Arrays.asList(new String[]{in_selected}); + + /** The model table for the selected item table */ + private ChooserTableModel mSelectedModel = new ChooserTableModel(); + + /** The JButton for adding available items to the selected list */ + private JButton mAddButton; + + /** The JButton for closing the dialog */ + private JButton mCloseButton; + + /** The JButton for removing selected items */ + private JButton mRemoveButton; + + /** The JLabel showing the remaining pool */ + private JLabel mPoolText; + + /** The JLabel showing messages */ + private JLabelPane mMessageText; + + /** The label for the available text entry */ + private JLabel mAvailLabel; + + /** The JTextField for the available text entry */ + private JTextField mAvailableText; + + /** The JTableEx holding selected items */ + private JTableEx mSelectedTable; + + /** The selected table column names */ + private List<String> mSelectedColumnNames; + + /** The list of selected items */ + private List mSelectedList = new ArrayList(); + + /** The list of unique items */ + private List mUniqueList = new ArrayList(); + private String mSelectedTerminator = ""; + + /** Will this chooser allow more choices than in the pool? */ + private boolean canGoNegative = false; + + /** Whether or not to allow duplicate choices */ + private boolean mAllowDuplicates = false; + + /** Whether or not to force mPool=0 when closing */ + private boolean mPoolFlag = true; + + /** The choices remaining */ + private int mPool; + + /** + * Chooser constructor. + */ + public SwingChooserUserInput() + { + super(Globals.getCurrentFrame()); + initComponents(); + } + + /** + * Sets the AllowsDups attribute of the Chooser object + * + * @param aBool The new AllowsDups value + */ + public void setAllowsDups(boolean aBool) + { + mAllowDuplicates = aBool; + } + + /** + * Sets the CostColumn attribute of the Chooser object + * + * @param costColumnNumber The new CostColumnNumber value + */ + public void setCostColumnNumber(final int costColumnNumber) + { + // Ignored + } + + /** + * Sets the message text. HTML text is supported. + * + * @param argMessageText The message to be displayed on the chooser. + */ + public void setMessageText(String argMessageText) + { + String messageText; + + if ((argMessageText == null) || (argMessageText.trim().length() == 0)) + { + messageText = "<html> </html>"; + } + else + { + messageText = argMessageText; + } + + mMessageText.setText(messageText); + } + + public void setNegativeAllowed(final boolean argFlag) + { + canGoNegative = argFlag; + } + + /** + * Sets the mPool attribute of the Chooser object. + * + * @param anInt The new mPool value + * author Matt Woodard + */ + public void setPool(final int anInt) + { + mPool = anInt; + mPoolText.setText(Integer.toString(mPool)); + } + + /** + * Returns the mPool attribute of the Chooser object. + * author Dmitry Jemerov + * @return mPool + */ + public int getPool() + { + return mPool; + } + + /** + * Sets the mPoolFlag attribute of the Chooser object + * + * @param poolFlag The new PoolFlag value + * author Matt Woodard + */ + public void setPoolFlag(boolean poolFlag) + { + mPoolFlag = poolFlag; + } + + /** + * Returns the selected item list + * + * @return java.util.ArrayList + * author Matt Woodard + */ + public List getSelectedList() + { + return new ArrayList(mSelectedList); + } + + public void setSelectedListTerminator(String aString) + { + mSelectedTerminator = aString; + } + + /** + * Sets the UniqueList attribute of the Chooser object + * + * @param uniqueList The new UniqueList value + * author Matt Woodard + */ + public void setUniqueList(List uniqueList) + { + mUniqueList = uniqueList; + } + + /** + * Overrides the default setVisible method to ensure controls + * are updated before showing the dialog. Note that the user input + * chooser has no default input as it requires a user to input text. + * + * @param visible true to show the chooser, false to hide it. + */ + public void setVisible(boolean visible) + { + updateSelectedTable(); + updateButtonStates(); + + Window owner = getOwner(); + Rectangle ownerBounds = owner.getBounds(); + Rectangle bounds = getBounds(); + + int width = (int) bounds.getWidth(); + int height = (int) bounds.getHeight(); + + setBounds( + (int) (owner.getX() + ((ownerBounds.getWidth() - width) / 2)), + (int) (owner.getY() + ((ownerBounds.getHeight() - height) / 2)), + width, height); + + super.setVisible(visible); + } + + private int getAdjustment(String textToAdd) + { + int adjustment = 1; + return adjustment; + } + + /** + * Sets the available column name list + * + * @param availableColumnNames The new AvailableColumnNames value + * author Matt Woodard + */ + public void setAvailableColumnNames(List<String> availableColumnNames) + { + // ignored + } + + /** + * Sets the AvailableList attribute of the Chooser object. This is + * ignored for the user input chooser as there is no available list. + * + * @param availableList The new AvailableList value + */ + public void setAvailableList(List availableList) + { + // Ignored as there is no list of available entries + } + + /** + * Sets the selected column name list + * @param selectedColumnNames java.util.List + * author Matt Woodard + */ + public void setSelectedColumnNames(List<String> selectedColumnNames) + { + mSelectedColumnNames = selectedColumnNames; + + mSelectedModel.setColumnsNames(selectedColumnNames == null + ? Globals.EMPTY_STRING_ARRAY : (String[]) selectedColumnNames + .toArray(new String[selectedColumnNames.size()])); + } + + /** + * Sets the SelectedList attribute of the Chooser object + * + * @param selectedList The new SelectedList value + * @param columnNames The new SelectedList value + * author Matt Woodard + */ + public void setSelectedList(List selectedList) + { + mSelectedList = selectedList; + } + + private void windowCloseEvent() + { + if (!mCloseButton.isEnabled()) + { + if (JOptionPane + .showConfirmDialog( + this, + "You still have choices remaining. Are you sure you want to close the dialog?", + Constants.s_APPNAME, JOptionPane.YES_NO_OPTION, + JOptionPane.QUESTION_MESSAGE) == JOptionPane.NO_OPTION) + { + return; + } + } + this.setVisible(false); + } + + /** + * Closes the dialog if the pool is satisfied + * + * author Matt Woodard + * @return true or false + */ + private boolean close() + { + if ((mPool <= 0) || !mPoolFlag) + { + this.setVisible(false); + + return true; + } + + setMessageText(in_completeMess); + + return false; + } + + /** + * Initializes the components of the dialog + * + * author Matt Woodard + */ + private void initComponents() + { + // WindowConstants.DO_NOTHING_ON_CLOSE is equivalent to + // JDialog.DO_NOTHING_ON_CLOSE but more 'correct' in a + // Java coding context (it is a static reference) + setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE); + addWindowListener(new java.awt.event.WindowAdapter() + { + public void windowClosing(java.awt.event.WindowEvent we) + { + windowCloseEvent(); + } + }); + + // Initialize basic dialog settings + setModal(true); + setSize(new Dimension(640, 300)); + setTitle(in_chooser); + + final Container contentPane = getContentPane(); + contentPane.setLayout(new GridBagLayout()); + + // Create tables + TableSorter sorter = new TableSorter(mSelectedModel = new ChooserTableModel()); + + final JScrollPane selectedScrollPane = + new JScrollPane(mSelectedTable = new JTableEx(sorter)); + selectedScrollPane + .setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED); + selectedScrollPane + .setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED); + sorter.addMouseListenerToHeaderInTable(mSelectedTable); + + // Initialize user input entry fields + JPanel availPanel = new JPanel(); + //availPanel.setLayout(new BorderLayout()); + mAvailLabel = new JLabel(in_uichooser_value); + availPanel.add(mAvailLabel, BorderLayout.WEST); + mAvailableText = new JTextField(20); + availPanel.add(mAvailableText, BorderLayout.EAST); + + // Initialize selection types & events + final CaretListener caretListener = new CaretListener() + { + public void caretUpdate(CaretEvent e) + { + updateButtonStates(); + } + }; + mAvailableText.addCaretListener(caretListener); + final ActionListener actionListener = new ActionListener() + { + public void actionPerformed(ActionEvent e) + { + selectAvailable(); + } + }; + mAvailableText.addActionListener(actionListener); + + final ListSelectionModel selectedSelectionModel = + mSelectedTable.getSelectionModel(); + + selectedSelectionModel + .setSelectionMode(ListSelectionModel.SINGLE_SELECTION); + + final ListSelectionListener listSelectionListener = + new ListSelectionListener() + { + /** + * Description of the Method + * + * @param evt Description of Parameter + * author mwoodard + */ + public void valueChanged(ListSelectionEvent evt) + { + if (!evt.getValueIsAdjusting()) + { + updateButtonStates(); + } + } + }; + + selectedSelectionModel.addListSelectionListener(listSelectionListener); + + // Initialize the mouse events + mSelectedTable.addMouseListener(new MouseAdapter() + { + public void mouseClicked(MouseEvent evt) + { + if (evt.getClickCount() == 2) + { + removeSelected(); + } + } + }); + + // Create labels + final JLabel selectionRemainingLabel = new JLabel(in_selRemain + ": "); + + // Create these labels with " " to force them to layout correctly + mMessageText = new JLabelPane(); + mMessageText.setBackground(contentPane.getBackground()); + setMessageText(null); + + mPoolText = new JLabel(" "); + + // Create buttons + mAddButton = new JButton(PropertyFactory.getString("in_add")); + mAddButton.setMnemonic(PropertyFactory.getMnemonic("in_mn_add")); + mCloseButton = new JButton(PropertyFactory.getString("in_close")); + mCloseButton.setMnemonic(PropertyFactory.getMnemonic("in_mn_close")); + mRemoveButton = new JButton(PropertyFactory.getString("in_remove")); + mRemoveButton.setMnemonic(PropertyFactory.getMnemonic("in_mn_remove")); + + final ActionListener eventListener = new ActionListener() + { + /** + * Description of the Method + * + * @param evt Description of Parameter + * author Matt Woodard + */ + public void actionPerformed(ActionEvent evt) + { + if (evt.getSource() == mAddButton) + { + selectAvailable(); + } + else if (evt.getSource() == mRemoveButton) + { + removeSelected(); + } + else if (evt.getSource() == mCloseButton) + { + close(); + } + } + }; + + mAddButton.addActionListener(eventListener); + mRemoveButton.addActionListener(eventListener); + mCloseButton.addActionListener(eventListener); + + // Add controls to content pane + GridBagConstraints constraints; + + // Add available list + constraints = new GridBagConstraints(); + constraints.gridx = 0; + constraints.gridy = 0; + constraints.gridwidth = 3; + constraints.fill = GridBagConstraints.HORIZONTAL; + constraints.anchor = GridBagConstraints.WEST; + constraints.weightx = 1.0; + constraints.weighty = 1.0; + constraints.insets = new Insets(4, 4, 4, 4); + contentPane.add(availPanel, constraints); + + // Add 'add' button + constraints = new GridBagConstraints(); + constraints.gridx = 0; + constraints.gridy = 1; + constraints.gridwidth = 3; + constraints.weighty = 0.01; + constraints.insets = new Insets(0, 4, 4, 4); + contentPane.add(mAddButton, constraints); + + // Add selected list + constraints = new GridBagConstraints(); + constraints.gridx = 0; + constraints.gridy = 2; + constraints.gridwidth = 3; + constraints.fill = GridBagConstraints.BOTH; + constraints.anchor = GridBagConstraints.WEST; + constraints.weighty = 1.0; + constraints.insets = new Insets(0, 4, 4, 4); + contentPane.add(selectedScrollPane, constraints); + + // Add 'remove' button + constraints = new GridBagConstraints(); + constraints.gridx = 0; + constraints.gridy = 3; + constraints.gridwidth = 3; + constraints.weighty = 0.01; + constraints.insets = new Insets(0, 4, 4, 4); + contentPane.add(mRemoveButton, constraints); + + // Add message text + constraints = new GridBagConstraints(); + constraints.gridx = 0; + constraints.gridy = 4; + constraints.gridwidth = 2; + constraints.fill = GridBagConstraints.BOTH; + constraints.anchor = GridBagConstraints.WEST; + constraints.weighty = 0.01; + constraints.insets = new Insets(0, 4, 4, 4); + contentPane.add(mMessageText, constraints); + + // Add selection remaining label + constraints = new GridBagConstraints(); + constraints.gridx = 0; + constraints.gridy = 5; + constraints.fill = GridBagConstraints.BOTH; + constraints.anchor = GridBagConstraints.WEST; + constraints.weighty = 0.01; + constraints.insets = new Insets(0, 4, 4, 0); + contentPane.add(selectionRemainingLabel, constraints); + + // Add selection remaining field + constraints = new GridBagConstraints(); + constraints.gridx = 1; + constraints.gridy = 5; + constraints.fill = GridBagConstraints.BOTH; + constraints.anchor = GridBagConstraints.WEST; + constraints.weightx = 1.0; + constraints.weighty = 0.01; + constraints.insets = new Insets(0, 4, 4, 0); + contentPane.add(mPoolText, constraints); + + // Add 'close' button + constraints = new GridBagConstraints(); + constraints.gridx = 2; + constraints.gridy = 5; + constraints.anchor = GridBagConstraints.EAST; + constraints.weighty = 0.01; + constraints.insets = new Insets(0, 4, 4, 4); + contentPane.add(mCloseButton, constraints); + this.getRootPane().setDefaultButton(mCloseButton); + } + + /** + * Removes a selected item - invoked when the remove button is pressed + * + * author Matt Woodard + */ + private void removeSelected() + { + setMessageText(null); + + if (mSelectedTable.getSelectedRowCount() == 0) + { + setMessageText(in_validItem); + + return; + } + + if (mSelectedTable.getSelectedRowCount() > 1) + { + setMessageText(in_deselectOne); + + return; + } + + final int selectedRow = mSelectedTable.getSelectedRow(); + final String selectedText = + mSelectedModel.getValueAt(selectedRow, 0).toString(); + + setPool(getPool() + getAdjustment(selectedText)); + + mSelectedList.remove(selectedRow); + + updateSelectedTable(); + updateButtonStates(); + } + + /** + * Selects an available item - invoked when the add button is pressed + * + * author Matt Woodard + */ + private void selectAvailable() + { + setMessageText(null); + + if (getPool() <= 0) + { + setMessageText(in_noRemain); + + return; + } + + final String availText = mAvailableText.getText(); + + if (mUniqueList.contains(availText)) + { + // TODO Don't compose messages by concat I18N + setMessageText(in_selectPartA + " " + availText.toString() + " " + + in_selectPartB); + + return; + } + + final TableModel selectedModel = mSelectedTable.getModel(); + + for (int i = 0, count = selectedModel.getRowCount(); i < count; i++) + { + Object obj = selectedModel.getValueAt(i, 0); + + if (availText.equals(obj) && !mAllowDuplicates) + { + // TODO Don't compose messages by concat I18N + setMessageText(availText + " " + in_alreadySelected); + + return; + } + } + + // + // Make sure there are enough points remaining... + // + final int adjustment = getAdjustment(availText); + + if ((getPool() - adjustment) < 0) + { + if (!canGoNegative) + { + setMessageText(in_noRemain); + + return; + } + } + + mSelectedList.add(availText); + updateSelectedTable(); + mAvailableText.setText(Constants.EMPTY_STRING); + setPool(getPool() - adjustment); + + updateButtonStates(); + } + + /** + * Makes a number of checks to determine when to enable buttons + */ + private void updateButtonStates() + { + boolean addEnabled = false; + boolean removeEnabled = false; + boolean closeEnabled = false; + + String addToolTip; + String removeToolTip; + String closeToolTip; + + if (mPool > 0) + { + if (!mPoolFlag) + { + closeEnabled = true; + closeToolTip = in_closeChooserTip; + } + else + { + closeToolTip = in_completeMess; + } + + if (mAvailableText.getText().length() > 0) + { + final String availText = mAvailableText.getText(); + if (!mUniqueList.contains(availText)) + { + addEnabled = true; + // TODO Don't compose messages by concat I18N + addToolTip = in_pressToAdd + " " + availText; + + for (int i = 0, length = mSelectedTable.getRowCount(); i < length; i++) + { + final Object selectedObj = + mSelectedModel.getValueAt(i, 0); + + if (availText.equals(selectedObj) && !mAllowDuplicates) + { + addEnabled = false; + // TODO Don't compose messages by concat I18N + addToolTip = availText + " " + in_alreadySelected; + } + } + } + else + { + // TODO Don't compose messages by concat I18N + addToolTip = + in_selectPartA + " " + availText + " " + + in_selectPartB; + } + } + else + { + addToolTip = in_noRemain; + closeToolTip = in_closeChooserTip; + closeEnabled = true; + } + } ... [truncated message content] |
From: <th...@us...> - 2007-03-03 21:09:49
|
Revision: 2371 http://svn.sourceforge.net/pcgen/?rev=2371&view=rev Author: thpr Date: 2007-03-03 13:09:46 -0800 (Sat, 03 Mar 2007) Log Message: ----------- CDOM: Additional tests and some cleanup Modified Paths: -------------- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java branches/cdom/code/src/java/pcgen/base/util/TypeSafeMap.java branches/cdom/code/src/test/plugin/lsttokens/skill/ClassesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/HDTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LevelTokenTest.java Added Paths: ----------- branches/cdom/code/src/test/pcgen/base/util/ branches/cdom/code/src/test/pcgen/base/util/DefaultMapTest.java branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapTest.java branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapToInstanceListTest.java branches/cdom/code/src/test/pcgen/base/util/HashMapToInstanceListTest.java branches/cdom/code/src/test/pcgen/base/util/HashMapToListTest.java branches/cdom/code/src/test/pcgen/base/util/ListSetTest.java branches/cdom/code/src/test/pcgen/base/util/MapCollectionTest.java branches/cdom/code/src/test/pcgen/base/util/TripleKeyMapTest.java branches/cdom/code/src/test/pcgen/base/util/TypeSafeMapTest.java branches/cdom/code/src/test/pcgen/base/util/WeightedCollectionTest.java Modified: branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-03-03 20:45:59 UTC (rev 2370) +++ branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -300,7 +300,11 @@ List<N> graphNodes = ge.getAdjacentNodes(); for (N node : graphNodes) { - nodeEdgeMap.get(node).remove(ge); + Set<ET> thing = nodeEdgeMap.get(node); + // Could be null due to side effects + if (thing != null) { + thing.remove(ge); + } } gcs.fireGraphEdgeChangeEvent(ge, EdgeChangeEvent.EDGE_REMOVED); return true; Modified: branches/cdom/code/src/java/pcgen/base/util/TypeSafeMap.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/util/TypeSafeMap.java 2007-03-03 20:45:59 UTC (rev 2370) +++ branches/cdom/code/src/java/pcgen/base/util/TypeSafeMap.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -244,6 +244,10 @@ System.arraycopy(array, 0, newKeyArray, 0, array.length); array = newKeyArray; } + else if (!keyClass.isInstance(arg0)) + { + throw new IllegalArgumentException(arg0 + " is not a " + keyClass); + } Object returnValue = array[loc + 1]; array[loc] = arg0; array[loc + 1] = arg1 == null ? nullValue : arg1; Added: branches/cdom/code/src/test/pcgen/base/util/DefaultMapTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/DefaultMapTest.java (rev 0) +++ branches/cdom/code/src/test/pcgen/base/util/DefaultMapTest.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -0,0 +1,51 @@ +package pcgen.base.util; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +public class DefaultMapTest extends TestCase { + + DefaultMap dm; + + @Before + public void setUp() { + dm = new DefaultMap(); + } + + public void populate() { + dm.put(Integer.valueOf(0), Double.valueOf(0)); + dm.put(Integer.valueOf(1), Double.valueOf(1)); + dm.put(Integer.valueOf(2), Double.valueOf(0)); + dm.put(Integer.valueOf(3), Double.valueOf(1)); + dm.put(Integer.valueOf(-1), null); + dm.put(null, Double.valueOf(-1)); + } + + @Test + public void testPutGet() { + populate(); + assertEquals(Double.valueOf(0), dm.get(Integer.valueOf(0))); + assertEquals(Double.valueOf(1), dm.get(Integer.valueOf(1))); + assertEquals(Double.valueOf(0), dm.get(Integer.valueOf(2))); + assertEquals(Double.valueOf(1), dm.get(Integer.valueOf(3))); + assertNull(dm.get(Integer.valueOf(-1))); + assertEquals(Double.valueOf(-1), dm.get(null)); + } + + @Test + public void testDefaultValue() { + populate(); + //Start as null + assertNull(dm.get(Integer.valueOf(-2))); + assertNull(dm.getDefaultValue()); + dm.setDefaultValue(Double.valueOf(5)); + assertEquals(Double.valueOf(5), dm.get(Integer.valueOf(-2))); + assertEquals(Double.valueOf(5), dm.getDefaultValue()); + //Null is allowed + dm.setDefaultValue(null); + assertNull(dm.getDefaultValue()); + assertNull(dm.get(Integer.valueOf(-2))); + } +} Added: branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapTest.java (rev 0) +++ branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapTest.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -0,0 +1,258 @@ +package pcgen.base.util; + +import java.util.Set; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +public class DoubleKeyMapTest extends TestCase +{ + + private static final char CONST_G = 'G'; + private static final char CONST_F = 'F'; + private static final char CONST_D = 'D'; + private static final char CONST_B = 'B'; + private static final char CONST_A = 'A'; + DoubleKeyMap<Integer, Double, Character> dkm; + + @Before + public void setUp() + { + dkm = new DoubleKeyMap<Integer, Double, Character>(); + } + + public void populate() + { + dkm.put(Integer.valueOf(1), Double.valueOf(1), CONST_A); + dkm.put(Integer.valueOf(1), Double.valueOf(2), CONST_B); + dkm.put(Integer.valueOf(1), Double.valueOf(3), 'C'); + dkm.put(Integer.valueOf(2), Double.valueOf(1), CONST_D); + dkm.put(Integer.valueOf(2), Double.valueOf(2), 'E'); + dkm.put(null, Double.valueOf(3), CONST_F); + dkm.put(Integer.valueOf(3), null, CONST_G); + dkm.put(Integer.valueOf(5), Double.valueOf(6), null); + } + + @Test + public void testPutGet() + { + assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(0))); + populate(); + assertEquals(Character.valueOf('A'), dkm.get(Integer.valueOf(1), Double.valueOf(1))); + assertEquals(Character.valueOf('B'), dkm.get(Integer.valueOf(1), Double.valueOf(2))); + assertEquals(Character.valueOf('C'), dkm.get(Integer.valueOf(1), Double.valueOf(3))); + assertNull(dkm.get(Integer.valueOf(1), Double.valueOf(0))); + assertEquals(Character.valueOf('D'), dkm.get(Integer.valueOf(2), Double.valueOf(1))); + assertEquals(Character.valueOf('E'), dkm.get(Integer.valueOf(2), Double.valueOf(2))); + assertEquals(Character.valueOf('F'), dkm.get(null, Double.valueOf(3))); + assertEquals(Character.valueOf('G'), dkm.get(Integer.valueOf(3), null)); + assertNull(dkm.get(Integer.valueOf(2), Double.valueOf(3))); + assertNull(dkm.get(Integer.valueOf(4), Double.valueOf(0))); + assertNull(dkm.get(Integer.valueOf(1), null)); + assertNull(dkm.get(null, Double.valueOf(1))); + } + + @Test + public void testContainsKey() + { + assertFalse(dkm.containsKey(Integer.valueOf(4))); + populate(); + assertTrue(dkm.containsKey(Integer.valueOf(1))); + assertTrue(dkm.containsKey(Integer.valueOf(2))); + assertTrue(dkm.containsKey(Integer.valueOf(3))); + assertFalse(dkm.containsKey(Integer.valueOf(4))); + assertTrue(dkm.containsKey(Integer.valueOf(1), Double.valueOf(1))); + assertTrue(dkm.containsKey(Integer.valueOf(1), Double.valueOf(2))); + assertTrue(dkm.containsKey(Integer.valueOf(1), Double.valueOf(3))); + assertTrue(dkm.containsKey(Integer.valueOf(2), Double.valueOf(1))); + assertTrue(dkm.containsKey(Integer.valueOf(2), Double.valueOf(2))); + assertFalse(dkm.containsKey(Integer.valueOf(2), Double.valueOf(3))); + assertFalse(dkm.containsKey(Integer.valueOf(3), Double.valueOf(0))); + assertFalse(dkm.containsKey(Integer.valueOf(1), null)); + assertFalse(dkm.containsKey(null, Double.valueOf(1))); + assertTrue(dkm.containsKey(null, Double.valueOf(3))); + assertTrue(dkm.containsKey(Integer.valueOf(3), null)); + } + + @Test + public void testRemove() + { + assertNull(dkm.remove(Integer.valueOf(1), Double.valueOf(1))); + populate(); + assertEquals(Character.valueOf('A'), dkm.remove(Integer.valueOf(1), Double.valueOf(1))); + assertFalse(dkm.containsKey(Integer.valueOf(1), Double.valueOf(1))); + assertNull(dkm.remove(Integer.valueOf(1), Double.valueOf(1))); + assertEquals(Character.valueOf('F'), dkm.remove(null, Double.valueOf(3))); + assertFalse(dkm.containsKey(null, Double.valueOf(3))); + assertNull(dkm.remove(null, Double.valueOf(3))); + assertEquals(Character.valueOf('G'), dkm.remove(Integer.valueOf(3), null)); + assertFalse(dkm.containsKey(Integer.valueOf(3), null)); + assertNull(dkm.remove(Integer.valueOf(3), null)); + assertEquals(Character.valueOf('B'), dkm.remove(Integer.valueOf(1), Double.valueOf(2))); + assertTrue(dkm.containsKey(Integer.valueOf(1))); + assertEquals(Character.valueOf('C'), dkm.remove(Integer.valueOf(1), Double.valueOf(3))); + assertFalse(dkm.containsKey(Integer.valueOf(1))); + } + + @Test + public void testGetKeySet() + { + Set<Integer> s = dkm.getKeySet(); + assertEquals(0, s.size()); + s.add(Integer.valueOf(-5)); + // Ensure not saved in DoubleKeyMap + Set<Integer> s2 = dkm.getKeySet(); + assertEquals(0, s2.size()); + assertEquals(1, s.size()); + // And ensure references are not kept the other direction to be altered + // by changes in the underlying DoubleKeyMap + populate(); + assertEquals(1, s.size()); + assertEquals(0, s2.size()); + Set<Integer> s3 = dkm.getKeySet(); + assertEquals(5, s3.size()); + assertTrue(s3.contains(Integer.valueOf(1))); + assertTrue(s3.contains(Integer.valueOf(2))); + assertTrue(s3.contains(Integer.valueOf(3))); + assertTrue(s3.contains(Integer.valueOf(5))); + assertTrue(s3.contains(null)); + } + + @Test + public void testGetSecondaryKeySet() + { + Set<Double> s = dkm.getSecondaryKeySet(Integer.valueOf(4)); + assertEquals(0, s.size()); + int sSize = 1; + try + { + s.add(Double.valueOf(-5)); + } + catch (UnsupportedOperationException uoe) + { + // This is OK, just account for it + sSize = 0; + } + // Ensure not saved in DoubleKeyMap + Set<Double> s2 = dkm.getSecondaryKeySet(Integer.valueOf(4)); + assertEquals(0, s2.size()); + assertEquals(sSize, s.size()); + // And ensure references are not kept the other direction to be altered + // by changes in the underlying DoubleKeyMap + populate(); + assertEquals(sSize, s.size()); + assertEquals(0, s2.size()); + Set<Double> s3 = dkm.getSecondaryKeySet(Integer.valueOf(1)); + assertEquals(3, s3.size()); + assertTrue(s3.contains(Double.valueOf(1))); + assertTrue(s3.contains(Double.valueOf(2))); + assertTrue(s3.contains(Double.valueOf(3))); + Set<Double> s4 = dkm.getSecondaryKeySet(Integer.valueOf(3)); + assertEquals(1, s4.size()); + assertTrue(s4.contains(null)); + Set<Double> s5 = dkm.getSecondaryKeySet(null); + assertEquals(1, s5.size()); + assertTrue(s5.contains(Double.valueOf(3))); + } + + @Test + public void testClearIsEmpty() + { + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + populate(); + assertFalse(dkm.isEmpty()); + assertEquals(5, dkm.firstKeyCount()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + dkm.put(null, Double.valueOf(3), 'F'); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.firstKeyCount()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + dkm.put(Integer.valueOf(3), null, 'G'); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.firstKeyCount()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + dkm.put(Integer.valueOf(5), Double.valueOf(6), null); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.firstKeyCount()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + } + + @Test + public void testValues() + { + Set<Character> s = dkm.values(Integer.valueOf(4)); + assertEquals(0, s.size()); + int sSize = 1; + try + { + s.add('Q'); + } + catch (UnsupportedOperationException uoe) + { + // This is OK, just account for it + sSize = 0; + } + // Ensure not saved in DoubleKeyMap + Set<Character> s2 = dkm.values(Integer.valueOf(4)); + assertEquals(0, s2.size()); + assertEquals(sSize, s.size()); + // And ensure references are not kept the other direction to be altered + // by changes in the underlying DoubleKeyMap + populate(); + assertEquals(sSize, s.size()); + assertEquals(0, s2.size()); + Set<Character> s3 = dkm.values(Integer.valueOf(1)); + assertEquals(3, s3.size()); + assertTrue(s3.contains('A')); + assertTrue(s3.contains('B')); + assertTrue(s3.contains('C')); + Set<Character> s4 = dkm.values(Integer.valueOf(3)); + assertEquals(1, s4.size()); + assertTrue(s4.contains('G')); + Set<Character> s5 = dkm.values(null); + assertEquals(1, s5.size()); + assertTrue(s5.contains('F')); + Set<Character> s6 = dkm.values(Integer.valueOf(5)); + assertEquals(1, s6.size()); + assertTrue(s6.contains(null)); + } + + @Test + public void testRemoveValue() + { + assertFalse(dkm.removeValue(Integer.valueOf(1), 'A')); + assertFalse(dkm.containsKey(Integer.valueOf(1), Double.valueOf(1))); + populate(); + assertTrue(dkm.containsKey(Integer.valueOf(1), Double.valueOf(1))); + assertTrue(dkm.removeValue(Integer.valueOf(1), 'A')); + assertFalse(dkm.containsKey(Integer.valueOf(1), Double.valueOf(1))); + assertFalse(dkm.removeValue(Integer.valueOf(1), 'A')); + assertFalse(dkm.containsKey(Integer.valueOf(1), Double.valueOf(1))); + assertTrue(dkm.containsKey(null, Double.valueOf(3))); + assertTrue(dkm.removeValue(null, 'F')); + assertFalse(dkm.containsKey(null, Double.valueOf(3))); + assertFalse(dkm.removeValue(null, 'F')); + assertFalse(dkm.containsKey(null, Double.valueOf(3))); + assertTrue(dkm.containsKey(Integer.valueOf(3), null)); + assertTrue(dkm.removeValue(Integer.valueOf(3), 'G')); + assertFalse(dkm.containsKey(Integer.valueOf(3), null)); + assertFalse(dkm.removeValue(Integer.valueOf(3), 'G')); + assertFalse(dkm.containsKey(Integer.valueOf(3), null)); + assertTrue(dkm.containsKey(Integer.valueOf(5), Double.valueOf(6))); + assertTrue(dkm.removeValue(Integer.valueOf(5), null)); + assertFalse(dkm.containsKey(Integer.valueOf(5), Double.valueOf(6))); + assertFalse(dkm.removeValue(Integer.valueOf(5), null)); + assertFalse(dkm.containsKey(Integer.valueOf(5), Double.valueOf(6))); + } +} Added: branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapToInstanceListTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapToInstanceListTest.java (rev 0) +++ branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapToInstanceListTest.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -0,0 +1,314 @@ +package pcgen.base.util; + +import java.util.List; +import java.util.Set; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + + +public class DoubleKeyMapToInstanceListTest extends TestCase { + + private static final char CONST_E = 'E'; + private static final char CONST_C = 'C'; + private static final char CONST_G = 'G'; + private static final char CONST_F = 'F'; + private static final char CONST_D = 'D'; + private static final char CONST_B = 'B'; + private static final char CONST_A = 'A'; + DoubleKeyMapToInstanceList<Integer, Double, Character> dkm; + + @Before + public void setUp() { + dkm = new DoubleKeyMapToInstanceList<Integer, Double, Character>(); + } + + public void populate() { + dkm.addToListFor(Integer.valueOf(1), Double.valueOf(1), CONST_A); + dkm.addToListFor(Integer.valueOf(1), Double.valueOf(1), CONST_B); + dkm.addToListFor(Integer.valueOf(1), Double.valueOf(2), CONST_C); + dkm.addToListFor(Integer.valueOf(2), Double.valueOf(1), CONST_D); + dkm.addToListFor(Integer.valueOf(2), Double.valueOf(2), CONST_E); + dkm.addToListFor(Integer.valueOf(2), Double.valueOf(2), null); + dkm.addToListFor(null, Double.valueOf(3), CONST_F); + dkm.addToListFor(Integer.valueOf(3), null, CONST_G); + dkm.addToListFor(Integer.valueOf(5), Double.valueOf(6), null); + } + + @Test + public void testPutGet() { + assertNull(dkm.getListFor(Integer.valueOf(1), Double.valueOf(0))); + populate(); + List l = dkm.getListFor(Integer.valueOf(1), Double.valueOf(1)); + assertEquals(2, l.size()); + assertTrue(l.contains(CONST_A)); + assertTrue(l.contains(CONST_B)); + l = dkm.getListFor(Integer.valueOf(1), Double.valueOf(2)); + assertEquals(1, l.size()); + assertTrue(l.contains(CONST_C)); + dkm.addToListFor(Integer.valueOf(1), Double.valueOf(2), CONST_C); + l = dkm.getListFor(Integer.valueOf(1), Double.valueOf(2)); + assertEquals(2, l.size()); + assertTrue(l.contains(CONST_C)); + //two of them + l.remove(Character.valueOf(CONST_C)); + assertTrue(l.contains(CONST_C)); + l = dkm.getListFor(Integer.valueOf(2), Double.valueOf(2)); + assertEquals(2, l.size()); + assertTrue(l.contains(CONST_E)); + assertTrue(l.contains(null)); + l.remove(Character.valueOf(CONST_E)); + List l2 = dkm.getListFor(Integer.valueOf(2), Double.valueOf(2)); + assertEquals(2, l2.size()); + assertTrue(l2.contains(CONST_E)); + assertTrue(l2.contains(null)); + assertEquals(1, l.size()); + assertTrue(l.contains(null)); + dkm.addToListFor(Integer.valueOf(2), Double.valueOf(2), null); + l = dkm.getListFor(Integer.valueOf(2), Double.valueOf(2)); + assertEquals(3, l.size()); + assertTrue(l.contains(CONST_E)); + assertTrue(l.contains(null)); + //Two of them. + l.remove(null); + assertTrue(l.contains(null)); + assertNull(dkm.getListFor(Integer.valueOf(1), Double.valueOf(0))); + assertNull(dkm.getListFor(Integer.valueOf(2), Double.valueOf(3))); + assertNull(dkm.getListFor(Integer.valueOf(4), Double.valueOf(0))); + assertNull(dkm.getListFor(Integer.valueOf(1), null)); + assertNull(dkm.getListFor(null, Double.valueOf(1))); + dkm.clear(); + assertEquals(2, l2.size()); + assertTrue(l2.contains(CONST_E)); + assertTrue(l2.contains(null)); + } + + @Test + public void testContainsKey() { + populate(); + assertTrue(dkm.containsListFor(Integer.valueOf(1), Double.valueOf(1))); + assertTrue(dkm.containsListFor(Integer.valueOf(1), Double.valueOf(2))); + assertTrue(dkm.containsListFor(Integer.valueOf(2), Double.valueOf(1))); + assertTrue(dkm.containsListFor(Integer.valueOf(2), Double.valueOf(2))); + assertFalse(dkm.containsListFor(Integer.valueOf(2), Double.valueOf(3))); + assertFalse(dkm.containsListFor(Integer.valueOf(-4), Double.valueOf(0))); + assertFalse(dkm.containsListFor(Integer.valueOf(1), null)); + assertFalse(dkm.containsListFor(null, Double.valueOf(1))); + assertTrue(dkm.containsListFor(null, Double.valueOf(3))); + assertTrue(dkm.containsListFor(Integer.valueOf(3), null)); + } + + @Test + public void testRemoveListFor() { + assertNull(dkm.removeListFor(Integer.valueOf(1), Double.valueOf(1))); + populate(); + List l = dkm.removeListFor(Integer.valueOf(1), Double.valueOf(1)); + assertEquals(2, l.size()); + assertTrue(l.contains(CONST_A)); + assertTrue(l.contains(CONST_B)); + assertFalse(dkm.containsListFor(Integer.valueOf(1), Double.valueOf(1))); + assertNull(dkm.getListFor(Integer.valueOf(1), Double.valueOf(1))); + l = dkm.removeListFor(Integer.valueOf(1), Double.valueOf(2)); + assertEquals(1, l.size()); + assertTrue(l.contains(CONST_C)); + dkm.addToListFor(Integer.valueOf(1), Double.valueOf(2), CONST_C); + l = dkm.removeListFor(Integer.valueOf(1), Double.valueOf(2)); + assertEquals(1, l.size()); + assertTrue(l.contains(CONST_C)); + l = dkm.removeListFor(Integer.valueOf(2), Double.valueOf(2)); + assertEquals(2, l.size()); + assertTrue(l.contains(CONST_E)); + assertTrue(l.contains(null)); + assertNull(dkm.removeListFor(Integer.valueOf(2), Double.valueOf(2))); + assertNull(dkm.getListFor(Integer.valueOf(1), Double.valueOf(0))); + assertNull(dkm.getListFor(Integer.valueOf(2), Double.valueOf(3))); + assertNull(dkm.getListFor(Integer.valueOf(4), Double.valueOf(0))); + assertNull(dkm.getListFor(Integer.valueOf(1), null)); + assertNull(dkm.getListFor(null, Double.valueOf(1))); + } + + @Test + public void testRemoveFromListFor() { + assertFalse(dkm.removeFromListFor(Integer.valueOf(1), Double.valueOf(1), CONST_D)); + populate(); + assertTrue(dkm.removeFromListFor(Integer.valueOf(1), Double.valueOf(1), CONST_A)); + assertTrue(dkm.containsListFor(Integer.valueOf(1), Double.valueOf(1))); + assertEquals(1, dkm.sizeOfListFor(Integer.valueOf(1), Double.valueOf(1))); + assertFalse(dkm.removeFromListFor(Integer.valueOf(1), Double.valueOf(1), CONST_A)); + assertTrue(dkm.removeFromListFor(Integer.valueOf(1), Double.valueOf(1), CONST_B)); + assertEquals(0, dkm.sizeOfListFor(Integer.valueOf(1), Double.valueOf(1))); + assertFalse(dkm.containsListFor(Integer.valueOf(1), Double.valueOf(1))); + + //add a second :) + dkm.addToListFor(Integer.valueOf(1), Double.valueOf(2), CONST_C); + assertFalse(dkm.removeFromListFor(Integer.valueOf(1), Double.valueOf(2), CONST_A)); + assertTrue(dkm.containsListFor(Integer.valueOf(1), Double.valueOf(2))); + assertEquals(2, dkm.sizeOfListFor(Integer.valueOf(1), Double.valueOf(2))); + assertFalse(dkm.removeFromListFor(Integer.valueOf(1), Double.valueOf(2), CONST_A)); + assertTrue(dkm.removeFromListFor(Integer.valueOf(1), Double.valueOf(2), CONST_C)); + assertEquals(1, dkm.sizeOfListFor(Integer.valueOf(1), Double.valueOf(2))); + assertTrue(dkm.containsListFor(Integer.valueOf(1), Double.valueOf(2))); + assertTrue(dkm.removeFromListFor(Integer.valueOf(1), Double.valueOf(2), CONST_C)); + assertEquals(0, dkm.sizeOfListFor(Integer.valueOf(1), Double.valueOf(2))); + assertFalse(dkm.containsListFor(Integer.valueOf(1), Double.valueOf(2))); + + //Test null stuff :) + assertFalse(dkm.removeFromListFor(null, Double.valueOf(3), CONST_A)); + assertTrue(dkm.containsListFor(null, Double.valueOf(3))); + assertEquals(1, dkm.sizeOfListFor(null, Double.valueOf(3))); + assertFalse(dkm.removeFromListFor(null, Double.valueOf(3), CONST_A)); + assertTrue(dkm.removeFromListFor(null, Double.valueOf(3), CONST_F)); + assertEquals(0, dkm.sizeOfListFor(null, Double.valueOf(3))); + assertFalse(dkm.containsListFor(null, Double.valueOf(3))); + + assertFalse(dkm.removeFromListFor(Integer.valueOf(3), null, CONST_A)); + assertTrue(dkm.containsListFor(Integer.valueOf(3), null)); + assertEquals(1, dkm.sizeOfListFor(Integer.valueOf(3), null)); + assertFalse(dkm.removeFromListFor(Integer.valueOf(3), null, CONST_A)); + assertTrue(dkm.removeFromListFor(Integer.valueOf(3), null, CONST_G)); + assertEquals(0, dkm.sizeOfListFor(Integer.valueOf(3), null)); + assertFalse(dkm.containsListFor(Integer.valueOf(3), null)); + } + + @Test + public void testContainsInList() { + assertFalse(dkm.containsInList(Integer.valueOf(1), Double.valueOf(1), CONST_D)); + populate(); + assertFalse(dkm.containsInList(Integer.valueOf(1), Double.valueOf(16), CONST_D)); + assertTrue(dkm.containsInList(Integer.valueOf(1), Double.valueOf(1), CONST_A)); + assertTrue(dkm.containsInList(Integer.valueOf(1), Double.valueOf(1), CONST_B)); + + //add a second :) + dkm.addToListFor(Integer.valueOf(1), Double.valueOf(2), CONST_C); + assertFalse(dkm.containsInList(Integer.valueOf(1), Double.valueOf(2), CONST_A)); + assertTrue(dkm.containsInList(Integer.valueOf(1), Double.valueOf(2), CONST_C)); + + //Test null stuff :) + assertTrue(dkm.containsInList(Integer.valueOf(2), Double.valueOf(2), null)); + + assertFalse(dkm.containsInList(null, Double.valueOf(3), CONST_A)); + assertTrue(dkm.containsInList(null, Double.valueOf(3), CONST_F)); + + assertFalse(dkm.containsInList(Integer.valueOf(3), null, CONST_A)); + assertTrue(dkm.containsInList(Integer.valueOf(3), null, CONST_G)); + } + + @Test + public void testGetKeySet() { + Set<Integer> s = dkm.getKeySet(); + assertEquals(0, s.size()); + s.add(Integer.valueOf(-5)); + // Ensure not saved in DoubleKeyMap + Set<Integer> s2 = dkm.getKeySet(); + assertEquals(0, s2.size()); + assertEquals(1, s.size()); + // And ensure references are not kept the other direction to be altered + // by changes in the underlying DoubleKeyMap + populate(); + assertEquals(1, s.size()); + assertEquals(0, s2.size()); + Set<Integer> s3 = dkm.getKeySet(); + assertEquals(5, s3.size()); + assertTrue(s3.contains(Integer.valueOf(1))); + assertTrue(s3.contains(Integer.valueOf(2))); + assertTrue(s3.contains(Integer.valueOf(3))); + assertTrue(s3.contains(Integer.valueOf(5))); + assertTrue(s3.contains(null)); + } + + @Test + public void testGetSecondaryKeySet() { + Set<Double> s = dkm.getSecondaryKeySet(Integer.valueOf(4)); + assertEquals(0, s.size()); + int sSize = 1; + try { + s.add(Double.valueOf(-5)); + } catch (UnsupportedOperationException uoe) { + // This is OK, just account for it + sSize = 0; + } + // Ensure not saved in DoubleKeyMap + Set<Double> s2 = dkm.getSecondaryKeySet(Integer.valueOf(4)); + assertEquals(0, s2.size()); + assertEquals(sSize, s.size()); + // And ensure references are not kept the other direction to be altered + // by changes in the underlying DoubleKeyMap + populate(); + assertEquals(sSize, s.size()); + assertEquals(0, s2.size()); + Set<Double> s3 = dkm.getSecondaryKeySet(Integer.valueOf(1)); + assertEquals(2, s3.size()); + assertTrue(s3.contains(Double.valueOf(1))); + assertTrue(s3.contains(Double.valueOf(2))); + Set<Double> s4 = dkm.getSecondaryKeySet(Integer.valueOf(3)); + assertEquals(1, s4.size()); + assertTrue(s4.contains(null)); + Set<Double> s5 = dkm.getSecondaryKeySet(null); + assertEquals(1, s5.size()); + assertTrue(s5.contains(Double.valueOf(3))); + } + + @Test + public void testClearIsEmpty() { + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + populate(); + assertFalse(dkm.isEmpty()); + assertEquals(5, dkm.firstKeyCount()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + dkm.addToListFor(null, Double.valueOf(3), 'F'); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.firstKeyCount()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + dkm.addToListFor(Integer.valueOf(3), null, 'G'); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.firstKeyCount()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + dkm.addToListFor(Integer.valueOf(5), Double.valueOf(6), null); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.firstKeyCount()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.firstKeyCount()); + } + + @Test + public void testInstanceBehavior() { + Character ca = Character.valueOf('a'); + Character cb = Character.valueOf('b'); + Character cc = Character.valueOf('c'); + Character ca1 = new Character('a'); + Integer i1 = Integer.valueOf(1); + Double d1 = Double.valueOf(1); + dkm.addToListFor(i1, d1, ca); + dkm.addToListFor(i1, d1, cb); + Double d2 = Double.valueOf(2); + dkm.addToListFor(i1, d2, cc); + Integer i2 = Integer.valueOf(2); + dkm.addToListFor(i2, d1, ca); + dkm.addToListFor(i2, d1, ca); + Integer i3 = Integer.valueOf(3); + dkm.addToListFor(i3, d2, cb); + dkm.addToListFor(i3, d2, cc); + assertTrue(dkm.containsInList(i1, d1, ca)); + assertFalse(dkm.containsInList(i1, d1, ca1)); + assertFalse(dkm.removeFromListFor(i1, d1, ca1)); + assertTrue(dkm.containsInList(i1, d1, ca)); + + assertTrue(dkm.containsInList(i2, d1, ca)); + assertFalse(dkm.containsInList(i2, d1, ca1)); + assertFalse(dkm.removeFromListFor(i2, d1, ca1)); + assertTrue(dkm.containsInList(i2, d1, ca)); + assertTrue(dkm.removeFromListFor(i2, d1, ca)); + //There were two + assertTrue(dkm.containsInList(i2, d1, ca)); + } +} Added: branches/cdom/code/src/test/pcgen/base/util/HashMapToInstanceListTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/HashMapToInstanceListTest.java (rev 0) +++ branches/cdom/code/src/test/pcgen/base/util/HashMapToInstanceListTest.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -0,0 +1,44 @@ +package pcgen.base.util; + +import org.junit.Before; +import org.junit.Test; + + +public class HashMapToInstanceListTest extends HashMapToListTest { + + @Before + public void setUp() { + dkm = new HashMapToInstanceList<Integer, Character>(); + } + + @Test + public void testInstanceBehavior() { + Character ca = Character.valueOf('a'); + Character cb = Character.valueOf('b'); + Character cc = Character.valueOf('c'); + Character ca1 = new Character('a'); + Integer i1 = Integer.valueOf(1); + dkm.addToListFor(i1, ca); + dkm.addToListFor(i1, cb); + dkm.addToListFor(i1, cc); + Integer i2 = Integer.valueOf(2); + dkm.addToListFor(i2, ca); + dkm.addToListFor(i2, ca); + Integer i3 = Integer.valueOf(3); + dkm.addToListFor(i3, cb); + dkm.addToListFor(i3, cc); + assertTrue(dkm.containsInList(i1, ca)); + assertFalse(dkm.containsInList(i1, ca1)); + assertFalse(dkm.removeFromListFor(i1, ca1)); + assertTrue(dkm.containsInList(i1, ca)); + + assertTrue(dkm.containsInList(i2, ca)); + assertFalse(dkm.containsInList(i2, ca1)); + assertFalse(dkm.removeFromListFor(i2, ca1)); + assertTrue(dkm.containsInList(i2, ca)); + assertTrue(dkm.removeFromListFor(i2, ca)); + // There were two + assertTrue(dkm.containsInList(i2, ca)); + } + +} Added: branches/cdom/code/src/test/pcgen/base/util/HashMapToListTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/HashMapToListTest.java (rev 0) +++ branches/cdom/code/src/test/pcgen/base/util/HashMapToListTest.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -0,0 +1,321 @@ +package pcgen.base.util; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +public class HashMapToListTest extends TestCase { + + private static final Character CONST_E = 'E'; + + private static final Character CONST_C = 'C'; + + private static final Character CONST_G = 'G'; + + private static final Character CONST_F = 'F'; + + private static final Character CONST_D = 'D'; + + private static final Character CONST_B = 'B'; + + private static final Character CONST_A = 'A'; + + HashMapToList<Integer, Character> dkm; + + @Before + public void setUp() { + dkm = new HashMapToList<Integer, Character>(); + } + + public void populate() { + dkm.addToListFor(Integer.valueOf(1), CONST_A); + dkm.addToListFor(Integer.valueOf(1), CONST_B); + dkm.addToListFor(Integer.valueOf(1), CONST_C); + dkm.addToListFor(Integer.valueOf(2), CONST_D); + dkm.addToListFor(Integer.valueOf(2), CONST_E); + dkm.addToListFor(Integer.valueOf(2), null); + dkm.addToListFor(null, CONST_F); + dkm.addToListFor(Integer.valueOf(5), null); + } + + @Test + public void testPutGet() { + assertNull(dkm.getListFor(null)); + assertNull(dkm.getListFor(Integer.valueOf(1))); + populate(); + List l = dkm.getListFor(Integer.valueOf(1)); + assertEquals(3, l.size()); + assertTrue(l.contains(CONST_A)); + assertTrue(l.contains(CONST_B)); + assertTrue(l.contains(CONST_C)); + dkm.addToListFor(Integer.valueOf(1), CONST_C); + l = dkm.getListFor(Integer.valueOf(1)); + assertEquals(4, l.size()); + assertTrue(l.contains(CONST_A)); + assertTrue(l.contains(CONST_B)); + assertTrue(l.contains(CONST_C)); + // two of them + l.remove(Character.valueOf(CONST_C)); + assertTrue(l.contains(CONST_C)); + l = dkm.getListFor(Integer.valueOf(2)); + assertEquals(3, l.size()); + assertTrue(l.contains(CONST_D)); + assertTrue(l.contains(CONST_E)); + assertTrue(l.contains(null)); + dkm.addToListFor(Integer.valueOf(2), null); + l = dkm.getListFor(Integer.valueOf(2)); + assertEquals(4, l.size()); + assertTrue(l.contains(CONST_D)); + assertTrue(l.contains(CONST_E)); + assertTrue(l.contains(null)); + // Two of them. + l.remove(null); + assertTrue(l.contains(null)); + assertNull(dkm.getListFor(Integer.valueOf(4))); + l = dkm.getListFor(null); + assertEquals(1, l.size()); + assertTrue(l.contains(CONST_F)); + l.add(CONST_A); + List l2 = dkm.getListFor(null); + assertEquals(1, l2.size()); + assertTrue(l2.contains(CONST_F)); + assertEquals(2, l.size()); + assertTrue(l.contains(CONST_F)); + assertTrue(l.contains(CONST_A)); + dkm.clear(); + assertEquals(1, l2.size()); + assertTrue(l2.contains(CONST_F)); + assertEquals(2, l.size()); + assertTrue(l.contains(CONST_F)); + assertTrue(l.contains(CONST_A)); + l2.clear(); + assertEquals(0, l2.size()); + assertEquals(2, l.size()); + assertTrue(l.contains(CONST_F)); + assertTrue(l.contains(CONST_A)); + } + + @Test + public void testContainsKey() { + assertFalse(dkm.containsListFor(Integer.valueOf(1))); + assertFalse(dkm.containsListFor(null)); + populate(); + assertTrue(dkm.containsListFor(Integer.valueOf(1))); + // Keys are .equals items, not instance + assertTrue(dkm.containsListFor(new Integer(1))); + assertTrue(dkm.containsListFor(Integer.valueOf(2))); + assertTrue(dkm.containsListFor(Integer.valueOf(5))); + assertFalse(dkm.containsListFor(Integer.valueOf(-4))); + assertTrue(dkm.containsListFor(null)); + } + + @Test + public void testRemoveListFor() { + assertNull(dkm.removeListFor(Integer.valueOf(1))); + assertNull(dkm.removeListFor(null)); + populate(); + List l = dkm.removeListFor(Integer.valueOf(1)); + assertEquals(3, l.size()); + assertTrue(l.contains(CONST_A)); + assertTrue(l.contains(CONST_B)); + assertTrue(l.contains(CONST_C)); + assertFalse(dkm.containsListFor(Integer.valueOf(1))); + assertNull(dkm.getListFor(Integer.valueOf(1))); + l = dkm.removeListFor(Integer.valueOf(2)); + assertEquals(3, l.size()); + assertTrue(l.contains(CONST_D)); + assertTrue(l.contains(CONST_E)); + assertTrue(l.contains(null)); + l = dkm.removeListFor(null); + assertEquals(1, l.size()); + assertTrue(l.contains(CONST_F)); + } + + @Test + public void testRemoveFromListFor() { + assertFalse(dkm.removeFromListFor(Integer.valueOf(1), CONST_D)); + populate(); + assertTrue(dkm.removeFromListFor(Integer.valueOf(1), CONST_A)); + assertTrue(dkm.containsListFor(Integer.valueOf(1))); + // Keys are .equals items, not instance + assertTrue(dkm.containsListFor(new Integer(1))); + assertEquals(2, dkm.sizeOfListFor(Integer.valueOf(1))); + assertFalse(dkm.removeFromListFor(Integer.valueOf(1), CONST_A)); + assertTrue(dkm.removeFromListFor(Integer.valueOf(1), CONST_B)); + assertEquals(1, dkm.sizeOfListFor(Integer.valueOf(1))); + assertTrue(dkm.containsListFor(Integer.valueOf(1))); + assertFalse(dkm.removeFromListFor(Integer.valueOf(1), CONST_A)); + assertTrue(dkm.removeFromListFor(Integer.valueOf(1), CONST_C)); + assertEquals(0, dkm.sizeOfListFor(Integer.valueOf(1))); + assertFalse(dkm.containsListFor(Integer.valueOf(1))); + + // add a second :) + dkm.addToListFor(Integer.valueOf(2), CONST_D); + assertFalse(dkm.removeFromListFor(Integer.valueOf(2), CONST_A)); + assertTrue(dkm.containsListFor(Integer.valueOf(2))); + assertEquals(4, dkm.sizeOfListFor(Integer.valueOf(2))); + assertFalse(dkm.removeFromListFor(Integer.valueOf(2), CONST_A)); + assertTrue(dkm.removeFromListFor(Integer.valueOf(2), CONST_D)); + assertEquals(3, dkm.sizeOfListFor(Integer.valueOf(2))); + assertTrue(dkm.containsListFor(Integer.valueOf(2))); + assertTrue(dkm.removeFromListFor(Integer.valueOf(2), CONST_E)); + assertEquals(2, dkm.sizeOfListFor(Integer.valueOf(2))); + assertTrue(dkm.containsListFor(Integer.valueOf(2))); + assertTrue(dkm.removeFromListFor(Integer.valueOf(2), null)); + assertEquals(1, dkm.sizeOfListFor(Integer.valueOf(2))); + assertTrue(dkm.containsListFor(Integer.valueOf(2))); + assertTrue(dkm.removeFromListFor(Integer.valueOf(2), CONST_D)); + assertEquals(0, dkm.sizeOfListFor(Integer.valueOf(2))); + assertFalse(dkm.containsListFor(Integer.valueOf(2))); + + // Test null stuff :) + assertFalse(dkm.removeFromListFor(null, CONST_A)); + assertTrue(dkm.containsListFor(null)); + assertEquals(1, dkm.sizeOfListFor(null)); + assertFalse(dkm.removeFromListFor(null, CONST_A)); + assertTrue(dkm.removeFromListFor(null, CONST_F)); + assertEquals(0, dkm.sizeOfListFor(null)); + assertFalse(dkm.containsListFor(null)); + } + + @Test + public void testContainsInList() { + assertFalse(dkm.containsInList(Integer.valueOf(1), CONST_D)); + populate(); + assertTrue(dkm.containsInList(Integer.valueOf(1), CONST_A)); + // Keys are .equals items, not instance + assertTrue(dkm.containsInList(new Integer(1), CONST_A)); + assertTrue(dkm.containsInList(Integer.valueOf(1), CONST_B)); + assertTrue(dkm.containsInList(Integer.valueOf(1), CONST_C)); + assertFalse(dkm.containsInList(Integer.valueOf(1), CONST_D)); + + // add a second :) + dkm.addToListFor(Integer.valueOf(1), CONST_C); + assertTrue(dkm.containsInList(Integer.valueOf(1), CONST_C)); + + // Test null stuff :) + assertTrue(dkm.containsInList(Integer.valueOf(2), null)); + + assertFalse(dkm.containsInList(null, CONST_A)); + assertTrue(dkm.containsInList(null, CONST_F)); + } + + @Test + public void testGetKeySet() { + Set<Integer> s = dkm.getKeySet(); + assertEquals(0, s.size()); + s.add(Integer.valueOf(-5)); + // Ensure not saved in DoubleKeyMap + Set<Integer> s2 = dkm.getKeySet(); + assertEquals(0, s2.size()); + assertEquals(1, s.size()); + // And ensure references are not kept the other direction to be altered + // by changes in the underlying DoubleKeyMap + populate(); + assertEquals(1, s.size()); + assertEquals(0, s2.size()); + Set<Integer> s3 = dkm.getKeySet(); + assertEquals(4, s3.size()); + assertTrue(s3.contains(Integer.valueOf(1))); + assertTrue(s3.contains(Integer.valueOf(2))); + assertTrue(s3.contains(Integer.valueOf(5))); + assertTrue(s3.contains(null)); + } + + @Test + public void testClearIsEmpty() { + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.size()); + populate(); + assertFalse(dkm.isEmpty()); + assertEquals(4, dkm.size()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.size()); + dkm.addToListFor(null, 'F'); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.size()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.size()); + dkm.addToListFor(Integer.valueOf(3), 'G'); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.size()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.size()); + dkm.addToListFor(Integer.valueOf(5), null); + assertFalse(dkm.isEmpty()); + assertEquals(1, dkm.size()); + dkm.clear(); + assertTrue(dkm.isEmpty()); + assertEquals(0, dkm.size()); + } + + @Test + public void testEmptyAddAll() { + dkm.addAllToListFor(Integer.valueOf(1), null); + assertFalse(dkm.containsListFor(Integer.valueOf(1))); + dkm.addAllToListFor(Integer.valueOf(1), new ArrayList()); + assertFalse(dkm.containsListFor(Integer.valueOf(1))); + } + + @Test + public void testAddAll() { + List l = new ArrayList(); + l.add(CONST_A); + l.add(null); + l.add(CONST_A); + l.add(CONST_B); + dkm.addAllToListFor(Integer.valueOf(1), l); + assertTrue(dkm.containsListFor(Integer.valueOf(1))); + assertEquals(4, dkm.sizeOfListFor(Integer.valueOf(1))); + dkm.addToListFor(Integer.valueOf(1), CONST_D); + assertEquals(4, l.size()); + //Check reference semantics! + l.add(CONST_C); + l.add(CONST_E); + assertTrue(dkm.containsListFor(Integer.valueOf(1))); + assertEquals(5, dkm.sizeOfListFor(Integer.valueOf(1))); + l.clear(); + assertTrue(dkm.containsListFor(Integer.valueOf(1))); + assertEquals(5, dkm.sizeOfListFor(Integer.valueOf(1))); + } + + @Test + public void testInstanceBehavior() { + Character ca = Character.valueOf('a'); + Character cb = Character.valueOf('b'); + Character cc = Character.valueOf('c'); + Character ca1 = new Character('a'); + Integer i1 = Integer.valueOf(1); + dkm.addToListFor(i1, ca); + dkm.addToListFor(i1, cb); + dkm.addToListFor(i1, cc); + Integer i2 = Integer.valueOf(2); + dkm.addToListFor(i2, ca); + dkm.addToListFor(i2, ca); + Integer i3 = Integer.valueOf(3); + dkm.addToListFor(i3, cb); + dkm.addToListFor(i3, cc); + assertTrue(dkm.containsInList(i1, ca)); + assertTrue(dkm.containsInList(i1, ca1)); + assertTrue(dkm.removeFromListFor(i1, ca1)); + assertFalse(dkm.containsInList(i1, ca)); + + assertTrue(dkm.containsInList(i2, ca)); + assertTrue(dkm.containsInList(i2, ca1)); + assertTrue(dkm.removeFromListFor(i2, ca1)); + // There were two + assertTrue(dkm.containsInList(i2, ca)); + assertTrue(dkm.removeFromListFor(i2, ca)); + // There were two + assertFalse(dkm.containsInList(i2, ca)); + } + +} Added: branches/cdom/code/src/test/pcgen/base/util/ListSetTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/ListSetTest.java (rev 0) +++ branches/cdom/code/src/test/pcgen/base/util/ListSetTest.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -0,0 +1,320 @@ +package pcgen.base.util; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +public class ListSetTest extends TestCase { + + ListSet ls, ls2, ls3, ls4; + + Comparator<Integer> c = new Comparator<Integer>() { + + public int compare(Integer arg0, Integer arg1) { + if (arg0 == arg1) { + return 0; + } + int comp = arg0.compareTo(arg1); + if (comp != 0) { + return comp; + } + if (System.identityHashCode(arg0) < System.identityHashCode(arg1)) { + return -1; + } + return 1; + } + + }; + + @Before + public void setUp() { + ls = new ListSet(); + ls2 = new ListSet(15); + ls3 = new ListSet(c); + ls4 = new ListSet(14, c); + } + + @Test + public void testSize() { + testSetSize(ls); + testSetSize(ls2); + testSetSize(ls3); + testSetSize(ls4); + } + + public void testSetSize(ListSet set) { + assertTrue(set.isEmpty()); + assertEquals(0, set.size()); + set.add(Integer.valueOf(1)); + assertFalse(set.isEmpty()); + assertEquals(1, set.size()); + set.add(Integer.valueOf(2)); + assertEquals(2, set.size()); + set.ensureCapacity(16); + assertEquals(2, set.size()); + assertFalse(set.isEmpty()); + set.clear(); + assertTrue(set.isEmpty()); + set.ensureCapacity(34); + assertTrue(set.isEmpty()); + assertEquals(0, set.size()); + set.add(Integer.valueOf(1)); + assertEquals(1, set.size()); + set.trimToSize(); + assertFalse(set.isEmpty()); + assertEquals(1, set.size()); + } + + @Test + public void testAddRemove() { + testBasicSet(ls); + testBasicSet(ls2); + testIdentitySet(ls3); + testIdentitySet(ls4); + } + + public void testBasicSet(ListSet set) { + assertTrue(set.isEmpty()); + assertFalse(set.remove(Integer.valueOf(1))); + assertFalse(set.contains(new Integer(1))); + assertFalse(set.contains(Integer.valueOf(1))); + assertEquals(0, set.size()); + assertEquals(0, set.size()); + assertFalse(set.contains(Integer.valueOf(1))); + assertTrue(set.isEmpty()); + set.add(Integer.valueOf(1)); + assertEquals(1, set.size()); + assertTrue(set.contains(Integer.valueOf(1))); + assertTrue(set.contains(new Integer(1))); + assertFalse(set.contains(Integer.valueOf(2))); + assertFalse(set.isEmpty()); + assertTrue(set.remove(Integer.valueOf(1))); + assertFalse(set.contains(Integer.valueOf(1))); + assertEquals(0, set.size()); + assertTrue(set.isEmpty()); + assertFalse(set.remove(Integer.valueOf(1))); + assertFalse(set.contains(Integer.valueOf(1))); + assertEquals(0, set.size()); + assertTrue(set.isEmpty()); + set.add(Integer.valueOf(1)); + assertEquals(1, set.size()); + assertTrue(set.contains(Integer.valueOf(1))); + assertTrue(set.contains(new Integer(1))); + assertFalse(set.isEmpty()); + set.add(Integer.valueOf(1)); + assertEquals(1, set.size()); + set.add(new Integer(1)); // Keep NEW (instance identity part of + // test!) + assertEquals(1, set.size()); + set.add(Integer.valueOf(2)); + assertEquals(2, set.size()); + assertTrue(set.contains(Integer.valueOf(2))); + set.add(new Integer(1)); // Keep NEW (instance identity part of + // test!) + assertEquals(2, set.size()); + set.add(new Integer(2)); // Keep NEW (instance identity part of + // test!) + assertEquals(2, set.size()); + set.ensureCapacity(16); + set.add(new Integer(2)); // Keep NEW (instance identity part of + // test!) + assertEquals(2, set.size()); + assertTrue(set.contains(Integer.valueOf(1))); + assertTrue(set.contains(new Integer(1))); + assertTrue(set.remove(Integer.valueOf(1))); + assertEquals(1, set.size()); + set.add(Integer.valueOf(3)); + assertEquals(2, set.size()); + set.add(Integer.valueOf(4)); + assertEquals(3, set.size()); + set.add(Integer.valueOf(5)); + assertEquals(4, set.size()); + assertFalse(set.isEmpty()); + assertTrue(set.remove(new Integer(2))); // Keep NEW (instance identity + // part of test!) + assertEquals(3, set.size()); + assertTrue(set.remove(new Integer(4))); // Keep NEW (instance identity + // part of test!) + assertEquals(2, set.size()); + assertTrue(set.contains(Integer.valueOf(5))); + assertTrue(set.contains(new Integer(5))); + } + + public void testIdentitySet(ListSet set) { + assertTrue(set.isEmpty()); + assertFalse(set.remove(Integer.valueOf(1))); + assertFalse(set.contains(Integer.valueOf(1))); + assertFalse(set.contains(new Integer(1))); + assertEquals(0, set.size()); + assertEquals(0, set.size()); + set.add(Integer.valueOf(1)); + assertEquals(1, set.size()); + assertTrue(set.contains(Integer.valueOf(1))); + assertFalse(set.contains(new Integer(1))); + assertFalse(set.isEmpty()); + assertTrue(set.remove(Integer.valueOf(1))); + assertEquals(0, set.size()); + assertTrue(set.isEmpty()); + assertFalse(set.contains(Integer.valueOf(1))); + assertFalse(set.contains(new Integer(1))); + assertFalse(set.remove(Integer.valueOf(1))); + assertEquals(0, set.size()); + assertTrue(set.isEmpty()); + set.add(Integer.valueOf(1)); + assertEquals(1, set.size()); + set.add(Integer.valueOf(1)); + assertEquals(1, set.size()); + set.add(new Integer(1)); // Keep NEW (instance identity part of + // test!) + assertTrue(set.contains(Integer.valueOf(1))); + assertFalse(set.contains(new Integer(1))); + assertEquals(2, set.size()); + set.add(Integer.valueOf(2)); + assertEquals(3, set.size()); + set.add(new Integer(1)); // Keep NEW (instance identity part of + // test!) + assertEquals(4, set.size()); + set.add(new Integer(2)); // Keep NEW (instance identity part of + // test!) + assertEquals(5, set.size()); + set.ensureCapacity(16); + set.add(new Integer(2)); // Keep NEW (instance identity part of + // test!) + assertEquals(6, set.size()); + assertTrue(set.remove(Integer.valueOf(1))); + assertFalse(set.contains(Integer.valueOf(1))); + assertFalse(set.contains(new Integer(1))); + assertEquals(5, set.size()); + set.add(Integer.valueOf(3)); + assertEquals(6, set.size()); + set.add(Integer.valueOf(4)); + assertEquals(7, set.size()); + set.add(Integer.valueOf(5)); + assertEquals(8, set.size()); + assertFalse(set.remove(new Integer(2))); // Keep NEW (instance + // identity part of + // test!) + assertEquals(8, set.size()); + assertFalse(set.remove(new Integer(4))); // Keep NEW (instance + // identity part of + // test!) + assertEquals(8, set.size()); + assertTrue(set.contains(Integer.valueOf(5))); + assertFalse(set.contains(new Integer(1))); + Integer nine = Integer.valueOf(9); + set.add(nine); + assertEquals(9, set.size()); + assertTrue(set.remove(nine)); + assertEquals(8, set.size()); + assertFalse(set.remove(nine)); + assertEquals(8, set.size()); + assertFalse(set.isEmpty()); + } + + @Test + public void testIterator() { + testIterator(ls); + testIterator(ls2); + testIterator(ls3); + testIterator(ls4); + } + + public void testIterator(ListSet set) { + Iterator it = set.iterator(); + assertNotNull(it); + assertFalse(it.hasNext()); + try { + it.next(); + fail(); + } catch (NoSuchElementException ise) { + // Yes! + } + Integer five = Integer.valueOf(5); + set.add(five); + Integer three = Integer.valueOf(3); + set.add(three); + Integer one = Integer.valueOf(1); + set.add(one); + List total = new ArrayList(); + total.add(one); + total.add(three); + total.add(five); + Iterator iter = set.iterator(); + assertNotNull(iter); + assertTrue(iter.hasNext()); + Object o1 = iter.next(); + assertTrue(o1 == one || o1 == three || o1 == five); + assertTrue(total.remove(o1)); + assertTrue(iter.hasNext()); + Object o2 = iter.next(); + assertTrue(o2 == one || o2 == three || o2 == five); + assertTrue(total.remove(o2)); + assertTrue(iter.hasNext()); + Object o3 = iter.next(); + assertTrue(o3 == one || o3 == three || o3 == five); + assertTrue(total.remove(o3)); + assertTrue(total.isEmpty()); + assertFalse(iter.hasNext()); + try { + iter.next(); + fail(); + } catch (NoSuchElementException ise) { + // Yes! + } + } + + @Test + public void testIteratorRemove() { + testIteratorRemove(ls); + testIteratorRemove(ls2); + testIteratorRemove(ls3); + testIteratorRemove(ls4); + } + + public void testIteratorRemove(ListSet set) { + Iterator it = set.iterator(); + assertNotNull(it); + assertFalse(it.hasNext()); + try { + it.next(); + fail(); + } catch (NoSuchElementException ise) { + // Yes! + } + Integer five = Integer.valueOf(5); + set.add(five); + Integer three = Integer.valueOf(3); + set.add(three); + Integer one = Integer.valueOf(1); + set.add(one); + List total = new ArrayList(); + total.add(one); + total.add(three); + total.add(five); + Iterator iter = set.iterator(); + assertNotNull(iter); + assertTrue(iter.hasNext()); + Object o1 = iter.next(); + assertTrue(o1 == one || o1 == three || o1 == five); + assertTrue(total.remove(o1)); + assertTrue(iter.hasNext()); + Object o2 = iter.next(); + assertTrue(o2 == one || o2 == three || o2 == five); + assertTrue(total.remove(o2)); + iter.remove(); + assertFalse(set.contains(o2)); + assertTrue(iter.hasNext()); + Object o3 = iter.next(); + assertTrue(o3 == one || o3 == three || o3 == five); + assertTrue(total.remove(o3)); + assertTrue(total.isEmpty()); + assertFalse(iter.hasNext()); + } +} Added: branches/cdom/code/src/test/pcgen/base/util/MapCollectionTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/MapCollectionTest.java (rev 0) +++ branches/cdom/code/src/test/pcgen/base/util/MapCollectionTest.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -0,0 +1,193 @@ +package pcgen.base.util; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +public class MapCollectionTest extends TestCase { + + public MapCollection mc; + + public Map m; + + @Before + public void setUp() { + m = new HashMap(); + m.put(Integer.valueOf(1), Double.valueOf(1)); + m.put(Integer.valueOf(2), Double.valueOf(2)); + m.put(Integer.valueOf(3), null); + m.put(null, Double.valueOf(4)); + m.put(Integer.valueOf(5), Double.valueOf(-1)); + mc = new MapCollection(m); + } + + @Test + public void testBadConstructor() { + try { + new MapCollection(null); + fail(); + } catch (IllegalArgumentException iae) { + // OK + } + } + + @Test + public void testClear() { + try { + mc.clear(); + fail(); + } catch (UnsupportedOperationException uoe) { + // OK + } + } + + @Test + public void testIsEmpty() { + assertTrue(new MapCollection(new HashMap()).isEmpty()); + assertFalse(mc.isEmpty()); + assertFalse(m.isEmpty()); + assertTrue(mc.contains(Integer.valueOf(1))); + assertTrue(mc.contains(Integer.valueOf(2))); + assertTrue(mc.contains(Integer.valueOf(3))); + assertTrue(mc.contains(Double.valueOf(1))); + assertTrue(mc.contains(Double.valueOf(2))); + assertTrue(mc.contains(Double.valueOf(4))); + assertTrue(mc.contains(null)); + assertFalse(mc.contains(Double.valueOf(5))); + // Should NOT impact the MapCollection (since it is NOT a facade) + m.clear(); + assertTrue(mc.contains(Integer.valueOf(1))); + assertTrue(mc.contains(Integer.valueOf(2))); + assertTrue(mc.contains(Integer.valueOf(3))); + assertTrue(mc.contains(Double.valueOf(1))); + assertTrue(mc.contains(Double.valueOf(2))); + assertTrue(mc.contains(Double.valueOf(4))); + assertTrue(mc.contains(null)); + assertFalse(mc.contains(Double.valueOf(5))); + assertFalse(mc.isEmpty()); + } + + @Test + public void testSize() { + assertEquals(0, new MapCollection(new HashMap()).size()); + assertEquals(10, mc.size()); + } + + @Test + public void testRemove() { + try { + mc.remove(Integer.valueOf(1)); + fail(); + } catch (UnsupportedOperationException uoe) { + // OK + } + } + + @Test + public void testAdd() { + try { + mc.add(Integer.valueOf(1)); + fail(); + } catch (UnsupportedOperationException uoe) { + // OK + } + } + + @Test + public void testAddAll() { + try { + mc.addAll(Arrays.asList(Integer.valueOf(1))); + fail(); + } catch (UnsupportedOperationException uoe) { + // OK + } + } + + @Test + public void testEmptyIterator() { + Iterator it = new MapCollection(new HashMap()).iterator(); + assertNotNull(it); + assertFalse(it.hasNext()); + try { + it.next(); + fail(); + } catch (NoSuchElementException nsee) { + // OK + } + } + + @Test + public void testIteratorRemove() { + Iterator it = mc.iterator(); + try { + it.remove(); + fail(); + } catch (UnsupportedOperationException uoe) { + // OK because it might just not be legal + } catch (IllegalStateException ise) { + // OK because if it is made legal, it still requires .next() first! + } + } + + @Test + public void testHasNextIterator() { + Iterator it = mc.iterator(); + for (int i = 0; i < mc.size() / 2; i++) { + assertTrue(it.hasNext()); + assertTrue(it.hasNext()); + assertTrue(it.hasNext()); + Object o = it.next(); + //Multiple times should be innocent + assertTrue(it.hasNext()); + assertTrue(it.hasNext()); + assertTrue(it.hasNext()); + assertTrue(it.hasNext()); + Object sub = it.next(); + if (o == null) { + assertTrue(sub.equals(Double.valueOf(4))); + } else if (o.equals(1)) { + assertTrue(sub.equals(Double.valueOf(1))); + } else if (o.equals(2)) { + assertTrue(sub.equals(Double.valueOf(2))); + } else if (o.equals(3)) { + assertTrue(sub == null); + } else if (o.equals(5)) { + assertTrue(sub.equals(Double.valueOf(-1))); + } + } + assertFalse(it.hasNext()); + } + + @Test + public void testIterator() { + Iterator it = mc.iterator(); + for (int i = 0; i < mc.size() / 2; i++) { + Object o = it.next(); + Object sub = it.next(); + if (o == null) { + assertTrue(sub.equals(Double.valueOf(4))); + } else if (o.equals(1)) { + assertTrue(sub.equals(Double.valueOf(1))); + } else if (o.equals(2)) { + assertTrue(sub.equals(Double.valueOf(2))); + } else if (o.equals(3)) { + assertTrue(sub == null); + } else if (o.equals(5)) { + assertTrue(sub.equals(Double.valueOf(-1))); + } + } + try { + it.next(); + fail(); + } catch (NoSuchElementException nsee) { + // OK + } + } +} Added: branches/cdom/code/src/test/pcgen/base/util/TripleKeyMapTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/TripleKeyMapTest.java (rev 0) +++ branches/cdom/code/src/test/pcgen/base/util/TripleKeyMapTest.java 2007-03-03 21:09:46 UTC (rev 2371) @@ -0,0 +1,227 @@ +package pcgen.base.util; + +import java.util.Set; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +public class TripleKeyMapTest extends TestCase { + + private static final Character CA = 'A'; + + private static final Character CB = 'B'; + + private static final Character CC = 'C'; + + private static final Character CD = 'D'; + + private static final Integer I1 = 1; + + private static final Integer I2 = 2; + + private static final Integer I3 = 3; + + private static final Integer I4 = 4; + + private static final Double D1 = 1.0; + + private static final Double D2 = 2.0; + + private static final Double D3 = 3.0; + + private static final Double D4 = 4.0; + + private static final String S1 = "S1"; + + private static final String S2 = "S2"; + + private static final String S3 = "S3"; + + private static final String S4 = "S4"; + + private static final String S5 = "S5"; + + private static final String S6 = "S6"; + + private static final String S7 = "S7"; + + private static final String S8 = "S8"; + + private static final String S9 = "S9"; + + TripleKeyMap<Integer, Double, Character, String> tkm; + + @Before + public void setUp() { + tkm = new TripleKeyMap<Integer, Double, Character, String>(); + } + + public void populate() { + tkm.put(I1, D1, CA, S1); + tkm.put(I1, D1, CB, S2); + tkm.put(I1, D2, CA, S2); + tkm.put(I1, D2, CB, S3); + tkm.put(I2, D1, CC, S4); + tkm.put(I2, D3, CD, S5); + tkm.put(I3, D4, CD, S6); + tkm.put(null, D3, CD, S7); + tkm.put(I4, null, CD, S8); + tkm.put(I4, D1, null, S9); + tkm.put(I4, D2, CA, null); + } + + @Test + public void testPutGet() { + assertNull(tkm.get(I1, D2, CA)); + populate(); + assertNull(tkm.get(I1, D1, CC)); + assertNull(tkm.get(I1, D4, CA)); + assertNull(tkm.get(Integer.valueOf(5), D1, CA)); + assertEquals(S1, tkm.get(I1, D1, CA)); + assertEquals(S2, tkm.get(I1, D1, CB)); + assertEquals(S2, tkm.get(I1, D2, CA)); + assertEquals(S3, tkm.get(I1, D2, CB)); + assertEquals(S4, tkm.get(I2, D1, CC)); + assertEquals(S5, tkm.get(I2, D3, CD)); + assertEquals(S6, tkm.get(I3, D4, CD)); + assertEquals(S7, tkm.get(null, D3, CD)); + assertEquals(S8, tkm.get(I4, null, CD)); + assertEquals(S9, tkm.get(I4, D1, null)); + assertNull(tkm.get(I4, D2, CA)); + } + + @Test + public void testContainsKey() { + assertFalse(tkm.containsKey(I1, D2, CA)); + populate(); + assertFalse(tkm.containsKey(I1, D1, CC)); + assertFalse(tkm.containsKey(I1, D4, CA)); + assertFalse(tkm.containsKey(Integer.valueOf(5), D1, CA)); + assertTrue(tkm.containsKey(I1, D1, CA)); + assertTrue(tkm.containsKey(I1, D1, CB)); + assertTrue(tkm.containsKey(I1, D2, CA)); + assertTrue(tkm.containsKey(I1, D2, CB)); + assertTrue(tkm.containsKey(I2, D1, CC)); + assertTrue(tkm.containsKey(I2, D3, CD)); + assertTrue(tkm.containsKey(I3, D4, CD)); + assertTrue(tkm.containsKey(null, D3, CD)); + assertTrue(tkm.containsKey(I4, null, CD)); + assertTrue(tkm.containsKey(I4, D1, null)); + assertTrue(tkm.containsKey(I4, D2, CA)); + } + + @Test + public void testRemove() { + assertNull(tkm.remove(I1, D2, CA)); + populate(); + assertTrue(tkm.containsKey(I1, D1, CA)); + assertEquals(S1, tkm.remove(I1, D1, CA)); + assertFalse(tkm.containsKey(I1, D1, CA)); + assertNull(tkm.remove(I1, D1, CA)); + assertTrue(tkm.containsKey(null, D3, CD)); + assertEquals(S7, tkm.remove(null, D3, CD)); + assertFalse(tkm.containsKey(null, D3, CD)); + assertNull(tkm.remove(null, D3, CD)); + assertTrue(tkm.containsKey(I4, null, CD)); + assertEquals(S8, tkm.remove(I4, null, CD)); + assertFalse(tkm.containsKey(I4, null, CD)); + assertNull(tkm.remove(I4, null, CD)); + assertTrue(tkm.containsKey(I4, D1, null)); + assertEquals(S9, tkm.remove(I4, D1, null)); + assertFalse(tkm.containsKey(I4, D1, null)); + assertNull(tkm.remove(I4, D1, null)); + assertTrue(tkm.containsKey(I4, D2, CA)); + assertNull(tkm.remove(I4, D2, CA)); + assertFalse(tkm.containsKey(I4, D2, CA)); + assertNull(tkm.remove(I4, D2, CA)); + } + + @Test + public void testGetKeySet() { + Set<Integer> s = tkm.getKeySet(); + assertEquals(0, s.size()); + s.add(Integer.valueOf(-5)); + // Ensure not saved in DoubleKeyMap + Set<Integer> s2 = tkm.getKeySet(); + assertEquals(0, s2.size()); + assertEquals(1, s.size()); + // And ensure references are not kept the other direction to be altered + // by changes in the underlying DoubleKeyMap + populate(); + assertEquals(1, s.size()); + assertEquals(0, s2.size()); + Set<Integer> s3 = tkm.getKeySet(); + assertEquals(5, s3.size()); + assertTrue(s3.contains(I1)); + assertTrue(s3.contains(I2)); + assertTrue(s3.contains(I3)); + ... [truncated message content] |
From: <th...@us...> - 2007-03-04 22:12:16
|
Revision: 2381 http://svn.sourceforge.net/pcgen/?rev=2381&view=rev Author: thpr Date: 2007-03-04 14:12:16 -0800 (Sun, 04 Mar 2007) Log Message: ----------- CDOM: Bug Fixes and more Unit Test Cases for Tokens Modified Paths: -------------- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java branches/cdom/code/src/java/pcgen/cdom/content/ChallengeRating.java branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java branches/cdom/code/src/java/pcgen/core/PObject.java branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/CostToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/DescriptorToken.java branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java branches/cdom/code/src/test/pcgen/base/graph/core/AbstractGraphTestCase.java branches/cdom/code/src/test/pcgen/base/util/DefaultMapTest.java branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapTest.java branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapToInstanceListTest.java branches/cdom/code/src/test/pcgen/base/util/HashMapToInstanceListTest.java branches/cdom/code/src/test/pcgen/base/util/HashMapToListTest.java branches/cdom/code/src/test/pcgen/base/util/ListSetTest.java branches/cdom/code/src/test/pcgen/base/util/MapCollectionTest.java branches/cdom/code/src/test/pcgen/base/util/TripleKeyMapTest.java branches/cdom/code/src/test/pcgen/base/util/TypeSafeMapTest.java branches/cdom/code/src/test/pcgen/base/util/WeightedCollectionTest.java branches/cdom/code/src/test/plugin/lsttokens/AbstractBigDecimalTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractListTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractStringTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeListTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/TokenRegistration.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/AssignToAllTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/CostdoubleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/FormatcatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/FumblerangeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/ItypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/PlusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/VisibleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/FaceTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/HandsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/HitDieTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/LangNumTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/LangbonusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/LegsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/MFeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/RaceSubtypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/RaceTypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/ReachTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/SkillMultTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/WeaponbonusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/ACheckTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/ClassesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/ExclusiveTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/UseuntrainedTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/VisibleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/CastTimeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/ClassesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/CompsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/CtTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/DomainsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/DurationTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/PPCostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/RangeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/SaveInfoTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/SchoolTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/SpellResTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/SubschoolTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/TargetAreaTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/VariantsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/XPCostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/AddLevelTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/BonusFeatsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/BonusSkillPointsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/FaceTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/GenderLockTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/HDTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/HandsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/HitDieTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LangbonusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LegsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LevelTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LevelsPerFeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/NonPPTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RaceSubtypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RaceTypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/ReachTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RegionTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RemovableTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/SubraceTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/SubregionTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/TemplateTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/VisibleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/WeaponbonusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/weaponprof/HandsTokenTest.java Added Paths: ----------- branches/cdom/code/src/test/plugin/lsttokens/AbstractFormulaTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/race/MonCCSkillTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/MonCSkillTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/XtraSkillPointsPerLevelTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/CostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/DescriptorTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/CRTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LevelAdjustmentTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RepeatLevelTokenTest.java Modified: branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -302,7 +302,8 @@ { Set<ET> thing = nodeEdgeMap.get(node); // Could be null due to side effects - if (thing != null) { + if (thing != null) + { thing.remove(ge); } } @@ -400,6 +401,20 @@ System.err.println("Not equal node list"); System.err.println(nodeMap.keySet()); System.err.println(otherNodeList); + ArrayList al = new ArrayList(nodeMap.keySet()); + al.removeAll(otherNodeList); + for (Object o : al) + { + System.err.println("1- " + o.hashCode()); + } + System.err.println("?!?"); + ArrayList al2 = new ArrayList(otherGraph.getNodeList()); + al2.removeAll(otherNodeList); + for (Object o : al2) + { + System.err.println("2- " + o.hashCode()); + } + System.err.println(al.equals(al2)); return false; } // Here, the node lists are identical... Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -284,4 +284,44 @@ this.put(StringKey.NAME, name); } + public boolean isCDOMEqual(CDOMObject cdo) + { + if (cdo == this) + { + return true; + } + if (namePI != cdo.namePI || descPI != cdo.descPI) + { + return false; + } + /* + * FIXME Test source here + * + * private final SourceEntry source = new SourceEntry(); + */ + if (!integerChar.equals(cdo.integerChar)) + { + return false; + } + if (!stringChar.equals(cdo.stringChar)) + { + return false; + } + if (!formulaChar.equals(cdo.formulaChar)) + { + return false; + } + if (!objectChar.equals(cdo.objectChar)) + { + return false; + } + /* + * FIXME Test these items + * + * private final ListKeyMapToList listChar = new ListKeyMapToList(); + * + * private final MapKeyMapToList mapChar = new MapKeyMapToList(); + */ + return true; + } } Modified: branches/cdom/code/src/java/pcgen/cdom/content/ChallengeRating.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/ChallengeRating.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/pcgen/cdom/content/ChallengeRating.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -30,10 +30,29 @@ { super(); String crValue = string; + String testString; if (crValue.startsWith("1/")) { - crValue = "-" + crValue.substring(2); + testString = crValue.substring(2); + crValue = "-" + testString; } + else + { + testString = crValue; + } + try + { + int i = Integer.parseInt(testString); + if (i <= 0) + { + throw new IllegalArgumentException( + "Challenge Rating cannot be negative"); + } + } + catch (NumberFormatException e) + { + // OK, formulae are allowed + } rating = FormulaFactory.getFormulaFor(crValue); } Modified: branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -52,6 +52,7 @@ } Aggregator other = (Aggregator) o; return other.aggSourceToken.equals(aggSourceToken) - && other.aggregatorSource.equals(aggregatorSource); + && other.aggregatorSource.equals(aggregatorSource) + && this.isCDOMEqual(other); } } Modified: branches/cdom/code/src/java/pcgen/core/PObject.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/PObject.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/pcgen/core/PObject.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1366,6 +1366,12 @@ return 1; } + @Override + public int hashCode() + { + return getKeyName().hashCode(); + } + /** * @see java.lang.Object#equals(java.lang.Object) */ Modified: branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -41,21 +41,10 @@ public int compare(CDOMReference<?> arg0, CDOMReference<?> arg1) { - if (arg0 instanceof CDOMSingleRef) - { - if (!(arg1 instanceof CDOMSingleRef)) - { - return -1; - } - return arg0.getName().compareTo(arg1.getName()); - } - if (arg1 instanceof CDOMSingleRef) - { - return 1; - } - return arg0.getName().compareTo(arg1.getName()); + return compareRefs(arg0, arg1); } }; + public static final Comparator<CategorizedCDOMReference<?>> CAT_REFERENCE_SORTER = new Comparator<CategorizedCDOMReference<?>>() { @@ -167,4 +156,20 @@ } } + public static int compareRefs(CDOMReference<?> arg0, CDOMReference<?> arg1) + { + if (arg0 instanceof CDOMSingleRef) + { + if (!(arg1 instanceof CDOMSingleRef)) + { + return -1; + } + return arg0.getName().compareTo(arg1.getName()); + } + if (arg1 instanceof CDOMSingleRef) + { + return 1; + } + return arg0.getName().compareTo(arg1.getName()); + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -22,9 +22,12 @@ package plugin.lsttokens.race; import java.util.Set; +import java.util.SortedSet; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.CDOMGroupRef; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.PrereqObject; import pcgen.cdom.enumeration.AssociationKey; @@ -60,10 +63,24 @@ public boolean parse(LoadContext context, Race race, String value) { - /* - * TODO FIXME Need to check if another MONCSKILL aggregator already - * exists... and add to it? - */ + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } Aggregator agg = new Aggregator(race, getTokenName()); /* * This is intentionally Holds, as the context for traversal must only @@ -102,11 +119,14 @@ Logging.errorPrint("Internal Error: " + "Expected only one MONCSKILL structure in Graph"); } - PCGraphEdge edge = edgeList.iterator().next(); - Aggregator a = (Aggregator) edge.getNodeAt(1); + /* + * Note this can actually use agg and doesn't have to do a + * search from the edge in edgeList, due to the .equals property + * and how it will work in the Graph :) - Tom Parker Mar/1/07 + */ Set<PCGraphEdge> edgeToSkillList = - context.graph.getChildLinksFromToken(getTokenName(), a, - SKILL_CLASS); + context.graph.getChildLinksFromToken(getTokenName(), + agg, SKILL_CLASS); for (PCGraphEdge se : edgeToSkillList) { if (se.getNodeAt(1).equals(skill)) @@ -116,7 +136,8 @@ * created the aggregator, it needs to delete it as * well... */ - context.graph.unlinkChildNode(getTokenName(), race, a); + context.graph.unlinkChildNode(getTokenName(), agg, + skill); continue PIPEWHILE; } } @@ -124,10 +145,12 @@ else { /* - * Note this HAS to be done one-by-one, because the - * .clearChildNodeOfClass method above does NOT recognize the - * C/CC Skill object and therefore doesn't know how to search - * the sublists + * Note this is done one-by-one, because .CLEAR. token type + * needs to be able to perform the unlink. That could be + * changed, but the increase in complexity isn't worth it. + * (Changing it to a grouping object that didn't place links in + * the graph would also make it harder to trace the source of + * class skills, etc.) */ PrereqObject skill = TokenUtilities.getObjectReference(context, SKILL_CLASS, @@ -151,10 +174,15 @@ Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), race, Aggregator.class); + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } if (edgeList.size() != 1) { - context - .addWriteMessage("Expected only one MONCSKILL structure in Graph"); + context.addWriteMessage("Expected only one " + getTokenName() + + " structure in Graph"); + return null; } PCGraphEdge edge = edgeList.iterator().next(); StringBuilder sb = new StringBuilder(); @@ -163,26 +191,29 @@ context.graph.getChildLinksFromToken(getTokenName(), a, SKILL_CLASS); sb.append(getTokenName()).append(':'); - boolean needsPipe = false; + SortedSet<CDOMReference<Skill>> set = + new TreeSet<CDOMReference<Skill>>( + TokenUtilities.REFERENCE_SORTER); for (PCGraphEdge se : edgeToSkillList) { if (!SkillCost.CROSS_CLASS.equals(se .getAssociation(AssociationKey.SKILL_COST))) { context - .addWriteMessage("Skill Cost must be CROSS_CLASS for Token " + .addWriteMessage("Skill Cost must be CROSS CLASS for Token " + getTokenName()); return null; } + set.add((CDOMReference<Skill>) se.getNodeAt(1)); + } + boolean needsPipe = false; + for (CDOMReference<Skill> ref : set) + { if (needsPipe) { sb.append(Constants.PIPE); } - /* - * TODO FIXME This breaks for types... :( - */ - Skill sk = (Skill) se.getNodeAt(1); - sb.append(sk.getKeyName()); + sb.append(ref.getLSTformat()); needsPipe = true; } return sb.toString(); Modified: branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -22,9 +22,12 @@ package plugin.lsttokens.race; import java.util.Set; +import java.util.SortedSet; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.CDOMGroupRef; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.PrereqObject; import pcgen.cdom.enumeration.AssociationKey; @@ -60,10 +63,25 @@ public boolean parse(LoadContext context, Race race, String value) { - /* - * TODO FIXME Need to check if another MONCSKILL aggregator already - * exists... and add to it? - */ + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } + Aggregator agg = new Aggregator(race, getTokenName()); /* * This is intentionally Holds, as the context for traversal must only @@ -102,21 +120,25 @@ Logging.errorPrint("Internal Error: " + "Expected only one MONCSKILL structure in Graph"); } - PCGraphEdge edge = edgeList.iterator().next(); - Aggregator a = (Aggregator) edge.getNodeAt(1); + /* + * Note this can actually use agg and doesn't have to do a + * search from the edge in edgeList, due to the .equals property + * and how it will work in the Graph :) - Tom Parker Mar/1/07 + */ Set<PCGraphEdge> edgeToSkillList = - context.graph.getChildLinksFromToken(getTokenName(), a, - SKILL_CLASS); + context.graph.getChildLinksFromToken(getTokenName(), + agg, SKILL_CLASS); for (PCGraphEdge se : edgeToSkillList) { if (se.getNodeAt(1).equals(skill)) { + context.graph.unlinkChildNode(getTokenName(), agg, + skill); /* - * TODO FIXME Unlink isn't enough here, since this Token - * created the aggregator, it needs to delete it as - * well... + * TODO FIXME Unlink may not be enough here, since this + * Token created the aggregator, it needs to delete it + * as well if all the connections are destroyed... */ - context.graph.unlinkChildNode(getTokenName(), race, a); continue PIPEWHILE; } } @@ -124,10 +146,12 @@ else { /* - * Note this HAS to be done one-by-one, because the - * .clearChildNodeOfClass method above does NOT recognize the - * C/CC Skill object and therefore doesn't know how to search - * the sublists + * Note this is done one-by-one, because .CLEAR. token type + * needs to be able to perform the unlink. That could be + * changed, but the increase in complexity isn't worth it. + * (Changing it to a grouping object that didn't place links in + * the graph would also make it harder to trace the source of + * class skills, etc.) */ PrereqObject skill = TokenUtilities.getObjectReference(context, SKILL_CLASS, @@ -150,10 +174,15 @@ Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), race, Aggregator.class); + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } if (edgeList.size() != 1) { - context - .addWriteMessage("Expected only one MONCSKILL structure in Graph"); + context.addWriteMessage("Expected only one " + getTokenName() + + " structure in Graph"); + return null; } PCGraphEdge edge = edgeList.iterator().next(); StringBuilder sb = new StringBuilder(); @@ -162,7 +191,9 @@ context.graph.getChildLinksFromToken(getTokenName(), a, SKILL_CLASS); sb.append(getTokenName()).append(':'); - boolean needsPipe = false; + SortedSet<CDOMReference<Skill>> set = + new TreeSet<CDOMReference<Skill>>( + TokenUtilities.REFERENCE_SORTER); for (PCGraphEdge se : edgeToSkillList) { if (!SkillCost.CLASS.equals(se @@ -172,15 +203,16 @@ + getTokenName()); return null; } + set.add((CDOMReference<Skill>) se.getNodeAt(1)); + } + boolean needsPipe = false; + for (CDOMReference<Skill> ref : set) + { if (needsPipe) { sb.append(Constants.PIPE); } - /* - * TODO FIXME This breaks for types... :( - */ - Skill sk = (Skill) se.getNodeAt(1); - sb.append(sk.getKeyName()); + sb.append(ref.getLSTformat()); needsPipe = true; } return sb.toString(); Modified: branches/cdom/code/src/java/plugin/lsttokens/spell/CostToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/spell/CostToken.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/plugin/lsttokens/spell/CostToken.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -22,7 +22,7 @@ package plugin.lsttokens.spell; import java.util.StringTokenizer; -import java.util.Map.Entry; +import java.util.TreeSet; import pcgen.base.util.DefaultMap; import pcgen.cdom.base.CDOMSimpleSingleRef; @@ -32,6 +32,7 @@ import pcgen.core.spell.Spell; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.SpellLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; /** @@ -55,16 +56,47 @@ public boolean parse(LoadContext context, Spell spell, String value) { - StringTokenizer pipeTok = new StringTokenizer(value, Constants.PIPE); - if (!pipeTok.hasMoreTokens()) + if (value.length() == 0) { Logging.errorPrint(getTokenName() + " requires the default value to exist"); return false; } + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " requires default value; may not start with | : " + value); + return false; + } + + StringTokenizer pipeTok = new StringTokenizer(value, Constants.PIPE); DefaultMap<CDOMSimpleSingleRef<PCClass>, Integer> dm = new DefaultMap<CDOMSimpleSingleRef<PCClass>, Integer>(); String defaultCost = pipeTok.nextToken(); + + int startRest = value.indexOf(Constants.PIPE); + if (startRest != -1) + { + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.charAt(startRest + 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } + } + try { Integer i = Integer.valueOf(defaultCost); @@ -114,7 +146,14 @@ + "non-negative cost."); return false; } - dm.put(pcc, i); + if (dm.put(pcc, i) != null) + { + Logging + .errorPrint("Class " + classString + + " was referenced multiple times in " + + getTokenName()); + return false; + } } catch (NumberFormatException nfe) { @@ -131,6 +170,10 @@ { DefaultMap<CDOMSimpleSingleRef<PCClass>, Integer> dm = spell.get(ObjectKey.COMPONENT_COST); + if (dm == null) + { + return null; + } StringBuilder sb = new StringBuilder(); sb.append(getTokenName()).append(':'); Integer defaultValue = dm.getDefaultValue(); @@ -150,10 +193,14 @@ return null; } sb.append(defaultValue); - for (Entry<CDOMSimpleSingleRef<PCClass>, Integer> me : dm.entrySet()) + TreeSet<CDOMSimpleSingleRef<PCClass>> set = + new TreeSet<CDOMSimpleSingleRef<PCClass>>( + TokenUtilities.REFERENCE_SORTER); + set.addAll(dm.keySet()); + for (CDOMSimpleSingleRef<PCClass> key : set) { - String className = me.getKey().getName(); - Integer cost = me.getValue(); + String className = key.getName(); + Integer cost = dm.get(key); if (cost.intValue() < 0) { context.addWriteMessage("Cost for PCClass " + className Modified: branches/cdom/code/src/java/plugin/lsttokens/spell/DescriptorToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/spell/DescriptorToken.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/plugin/lsttokens/spell/DescriptorToken.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -32,6 +32,7 @@ import pcgen.core.spell.Spell; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.SpellLstToken; +import pcgen.util.Logging; /** * Class deals with DESCRIPTOR Token @@ -59,6 +60,30 @@ public boolean parse(LoadContext context, Spell spell, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } + StringTokenizer aTok = new StringTokenizer(value, Constants.PIPE); while (aTok.hasMoreTokens()) Modified: branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -21,9 +21,11 @@ */ package plugin.lsttokens.template; +import java.util.Comparator; import java.util.List; import java.util.Set; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.Constants; import pcgen.cdom.base.FormulaFactory; @@ -51,6 +53,38 @@ PCTemplateLstToken { + private static final Comparator<Aggregator> AGG_COMPARATOR = + new Comparator<Aggregator>() + { + + public int compare(Aggregator arg0, Aggregator arg1) + { + int compSL = + arg0.get(IntegerKey.START_LEVEL).compareTo( + arg1.get(IntegerKey.START_LEVEL)); + if (compSL != 0) + { + return compSL; + } + int compLI = + arg0.get(IntegerKey.LEVEL_INCREMENT).compareTo( + arg1.get(IntegerKey.LEVEL_INCREMENT)); + if (compLI != 0) + { + return compLI; + } + int compC = + arg0.get(IntegerKey.CONSECUTIVE).compareTo( + arg1.get(IntegerKey.CONSECUTIVE)); + if (compC != 0) + { + return compC; + } + return arg0.get(IntegerKey.MAX_LEVEL).compareTo( + arg1.get(IntegerKey.MAX_LEVEL)); + } + }; + @Override public String getTokenName() { @@ -200,7 +234,7 @@ Logging.errorPrint(" Line was: " + value); return false; } - if (consecutive <= 0) + if (consecutive < 0) { Logging.errorPrint("Malformed " + getTokenName() + " Token (Consecutive String was <= 0): " + consecutive); @@ -250,8 +284,41 @@ return false; } + if (iLevel > maxLevel) + { + Logging.errorPrint("Malformed " + getTokenName() + + " Token (Starting Level was > Maximum Level)"); + Logging.errorPrint(" Line was: " + value); + return false; + } + if (iLevel + lvlIncrement > maxLevel) + { + Logging + .errorPrint("Malformed " + + getTokenName() + + " Token (Does not repeat, Staring Level + Increment > Maximum Level)"); + Logging.errorPrint(" Line was: " + value); + return false; + } + if (consecutive != 0 + && ((maxLevel - iLevel) / lvlIncrement) < consecutive) + { + Logging.errorPrint("Malformed " + getTokenName() + + " Token (Does not use Skip Interval value): " + consecutive); + Logging.errorPrint(" You should set the interval to zero"); + Logging.errorPrint(" Line was: " + value); + return false; + } + String typeStr = value.substring(endLevel + 1, endAssignType); String contentStr = value.substring(endAssignType + 1); + if (contentStr.length() == 0) + { + Logging.errorPrint("Malformed " + getTokenName() + + " Token (No Content to SubToken)"); + Logging.errorPrint(" Line was: " + value); + return false; + } PrereqObject pro; if ("DR".equals(typeStr)) { @@ -314,15 +381,24 @@ Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), pct, Aggregator.class); + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } StringBuilder sb = new StringBuilder(); boolean needsTab = false; + TreeSet<Aggregator> aggSet = new TreeSet<Aggregator>(AGG_COMPARATOR); for (PCGraphEdge edge : edgeList) { + aggSet.add((Aggregator) edge.getSinkNodes().get(0)); + } + for (Aggregator agg : aggSet) + { if (needsTab) { sb.append('\t'); } - Aggregator agg = (Aggregator) edge.getSinkNodes().get(0); + sb.append(getTokenName()).append(':'); Integer consecutive = agg.get(IntegerKey.CONSECUTIVE); Integer maxLevel = agg.get(IntegerKey.MAX_LEVEL); Integer lvlIncrement = agg.get(IntegerKey.LEVEL_INCREMENT); @@ -332,7 +408,13 @@ sb.append(maxLevel).append(Constants.COLON); sb.append(iLevel).append(Constants.COLON); Set<PCGraphEdge> subEdgeList = - context.graph.getChildLinksFromToken(getTokenName(), pct); + context.graph.getChildLinksFromToken(getTokenName(), agg); + if (subEdgeList == null || subEdgeList.isEmpty()) + { + context.addWriteMessage("Aggregator for " + getTokenName() + + " had no children"); + return null; + } boolean wroteContent = false; for (PCGraphEdge subEdge : subEdgeList) @@ -374,20 +456,20 @@ { if (sink instanceof DamageReduction) { - sb.append("DR").append(sink); + sb.append("DR:").append(sink); } else if (sink instanceof SpellResistance) { - sb.append("SR").append(sink); + sb.append("SR:").append(sink); } else if (sink instanceof SpecialAbility) { - sb.append("SA").append( + sb.append("SA:").append( ((SpecialAbility) sink).toLSTform()); } else if (sink instanceof ChallengeRating) { - sb.append("CR").append( + sb.append("CR:").append( ((ChallengeRating) sink).toLSTform()); } else Modified: branches/cdom/code/src/test/pcgen/base/graph/core/AbstractGraphTestCase.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/graph/core/AbstractGraphTestCase.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/graph/core/AbstractGraphTestCase.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -55,6 +55,7 @@ getStrategy().addGraphChangeListener(listener); Integer node = new Integer(1); Integer node2 = new Integer(2); + Integer node3 = new Integer(3); assertFalse(getStrategy().containsNode(node)); assertFalse(getStrategy().containsNode(node2)); assertNull(listener.lastAddNode); @@ -80,6 +81,11 @@ assertFalse(getStrategy().containsNode(null)); assertEquals(2, getStrategy().getNodeList().size()); assertEquals(node2, listener.lastAddNode); + // + assertTrue(getStrategy().addNode(node3)); + assertTrue(getStrategy().containsNode(node3)); + assertEquals(3, getStrategy().getNodeList().size()); + assertEquals(node3, listener.lastAddNode); } public void testAddEdge() @@ -426,43 +432,60 @@ assertFalse(testGraph.equals(node1)); assertTrue(testGraph.equals(master)); assertEquals(testGraph.hashCode(), master.hashCode()); - master.addNode(node1); + assertTrue(master.addNode(node1)); + assertEquals(1, master.getNodeList().size()); assertFalse(testGraph.equals(master)); master.removeNode(node1); assertTrue(master.getNodeList().isEmpty()); + assertEquals(0, master.getNodeList().size()); assertTrue(testGraph.equals(master)); assertEquals(testGraph.hashCode(), master.hashCode()); - testGraph.addNode(node1); + assertTrue(testGraph.addNode(node1)); + assertEquals(1, testGraph.getNodeList().size()); assertFalse(testGraph.equals(master)); - master.addNode(node4); + assertTrue(master.addNode(node4)); + assertEquals(1, master.getNodeList().size()); + assertEquals(1, testGraph.getNodeList().size()); + System.err.println("!"); assertFalse(testGraph.equals(master)); - testGraph.addNode(node4); + assertTrue(testGraph.addNode(node4)); + assertEquals(2, testGraph.getNodeList().size()); + System.err.println("!!"); assertFalse(testGraph.equals(master)); - master.addNode(node3); + assertTrue(master.addNode(node3)); + assertEquals(2, master.getNodeList().size()); + assertEquals(2, testGraph.getNodeList().size()); + System.err.println("!!!"); assertFalse(testGraph.equals(master)); - testGraph.addNode(node3); + assertTrue(testGraph.addNode(node3)); + assertEquals(2, master.getNodeList().size()); + assertEquals(3, testGraph.getNodeList().size()); + System.err.println("!!!!"); assertFalse(testGraph.equals(master)); - master.addNode(node1); + assertTrue(master.addNode(node1)); + assertEquals(3, master.getNodeList().size()); + assertEquals(3, testGraph.getNodeList().size()); + System.err.println("!!!!!"); assertTrue(testGraph.equals(master)); assertEquals(testGraph.hashCode(), master.hashCode()); - master.addEdge(edge1); + assertTrue(master.addEdge(edge1)); assertFalse(testGraph.equals(master)); master.removeEdge(edge1); assertTrue(testGraph.equals(master)); assertEquals(testGraph.hashCode(), master.hashCode()); - testGraph.addEdge(edge2); + assertTrue(testGraph.addEdge(edge2)); assertFalse(testGraph.equals(master)); - master.addEdge(edge1); + assertTrue(master.addEdge(edge1)); assertFalse(testGraph.equals(master)); - testGraph.addEdge(edge1); + assertTrue(testGraph.addEdge(edge1)); assertFalse(testGraph.equals(master)); - master.addEdge(edge2); + assertTrue(master.addEdge(edge2)); assertTrue(testGraph.equals(master)); assertEquals(testGraph.hashCode(), master.hashCode()); - testGraph.addNode(node2); + assertTrue(testGraph.addNode(node2)); assertFalse(testGraph.equals(master)); //Yes, NEW, not valueOf - master.addNode(new Integer(2)); + assertTrue(master.addNode(new Integer(2))); //Test for .equals of the nodes assertTrue(testGraph.equals(master)); assertEquals(testGraph.hashCode(), master.hashCode()); Modified: branches/cdom/code/src/test/pcgen/base/util/DefaultMapTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/DefaultMapTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/DefaultMapTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import junit.framework.TestCase; Modified: branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import java.util.Set; Modified: branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapToInstanceListTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapToInstanceListTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/DoubleKeyMapToInstanceListTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import java.util.List; Modified: branches/cdom/code/src/test/pcgen/base/util/HashMapToInstanceListTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/HashMapToInstanceListTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/HashMapToInstanceListTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import org.junit.Before; Modified: branches/cdom/code/src/test/pcgen/base/util/HashMapToListTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/HashMapToListTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/HashMapToListTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import java.util.ArrayList; Modified: branches/cdom/code/src/test/pcgen/base/util/ListSetTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/ListSetTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/ListSetTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import java.util.ArrayList; Modified: branches/cdom/code/src/test/pcgen/base/util/MapCollectionTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/MapCollectionTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/MapCollectionTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import java.util.Arrays; Modified: branches/cdom/code/src/test/pcgen/base/util/TripleKeyMapTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/TripleKeyMapTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/TripleKeyMapTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import java.util.Set; Modified: branches/cdom/code/src/test/pcgen/base/util/TypeSafeMapTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/TypeSafeMapTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/TypeSafeMapTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,6 +1,22 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; -import java.net.URISyntaxException; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; @@ -17,9 +33,6 @@ import org.junit.Test; import pcgen.base.enumeration.TypeSafeConstant; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.TokenRegistration; -import plugin.pretokens.parser.PreHDParser; public class TypeSafeMapTest extends TestCase { Modified: branches/cdom/code/src/test/pcgen/base/util/WeightedCollectionTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/base/util/WeightedCollectionTest.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/pcgen/base/util/WeightedCollectionTest.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.base.util; import java.util.ArrayList; Modified: branches/cdom/code/src/test/plugin/lsttokens/AbstractBigDecimalTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractBigDecimalTokenTestCase.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractBigDecimalTokenTestCase.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens; import java.math.BigDecimal; Added: branches/cdom/code/src/test/plugin/lsttokens/AbstractFormulaTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractFormulaTokenTestCase.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractFormulaTokenTestCase.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens; + +import org.junit.Test; + +import pcgen.cdom.enumeration.FormulaKey; +import pcgen.core.PObject; +import pcgen.persistence.PersistenceLayerException; +import plugin.lsttokens.AbstractTokenTestCase; + +public abstract class AbstractFormulaTokenTestCase<T extends PObject> extends + AbstractTokenTestCase<T> +{ + + @Test + public void testValidInputs() throws PersistenceLayerException + { + assertTrue(getToken().parse(primaryContext, primaryProf, "Variable1")); + assertEquals("Variable1", primaryProf.get(getFormulaKey()).toString()); + assertTrue(getToken().parse(primaryContext, primaryProf, "3")); + assertEquals("3", primaryProf.get(getFormulaKey()).toString()); + assertTrue(getToken().parse(primaryContext, primaryProf, + "3+CL(\"Fighter\"")); + assertEquals("3+CL(\"Fighter\"", primaryProf.get(getFormulaKey()) + .toString()); + } + + public abstract FormulaKey getFormulaKey(); + + @Test + public void testRoundRobinBase() throws PersistenceLayerException + { + runRoundRobin("Variable1"); + } + + @Test + public void testRoundRobinNumber() throws PersistenceLayerException + { + runRoundRobin("3"); + } + + @Test + public void testRoundRobinFormula() throws PersistenceLayerException + { + runRoundRobin("3+CL(\"Fighter\""); + } +} Modified: branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens; import org.junit.Test; Modified: branches/cdom/code/src/test/plugin/lsttokens/AbstractListTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractListTokenTestCase.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractListTokenTestCase.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens; import org.junit.Test; Modified: branches/cdom/code/src/test/plugin/lsttokens/AbstractStringTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractStringTokenTestCase.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractStringTokenTestCase.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens; import org.junit.Test; Modified: branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens; import java.net.URI; Modified: branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeListTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeListTestCase.java 2007-03-04 22:04:39 UTC (rev 2380) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeListTestCase.java 2007-03-04 22:12:16 UTC (rev 2381) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...... [truncated message content] |
From: <th...@us...> - 2007-03-13 03:59:32
|
Revision: 2494 http://svn.sourceforge.net/pcgen/?rev=2494&view=rev Author: thpr Date: 2007-03-12 20:59:32 -0700 (Mon, 12 Mar 2007) Log Message: ----------- CDOM: Convert unparse to return String[] rather than String Eliminates bad behavior in the token (shouldn't know the global separator) Fixes the problem of AUTO: needing to magically detect how many subtokens fired (now just prepends the subtoken to each item in the String[]) Modified Paths: -------------- branches/cdom/code/src/java/pcgen/base/lang/StringUtil.java branches/cdom/code/src/java/pcgen/persistence/lst/AbilityLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/AutoLoader.java branches/cdom/code/src/java/pcgen/persistence/lst/CDOMToken.java branches/cdom/code/src/java/pcgen/persistence/lst/DeityLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/DomainLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/EquipmentLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/EquipmentModifierLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/GlobalLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/LanguageLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/PCTemplateLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/RaceLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/SkillLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/SpellLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/WeaponProfLstToken.java branches/cdom/code/src/java/plugin/lsttokens/AbilityLst.java branches/cdom/code/src/java/plugin/lsttokens/AddLst.java branches/cdom/code/src/java/plugin/lsttokens/AutoLst.java branches/cdom/code/src/java/plugin/lsttokens/BonusLst.java branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java branches/cdom/code/src/java/plugin/lsttokens/ChangeprofLst.java branches/cdom/code/src/java/plugin/lsttokens/ChooseLst.java branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java branches/cdom/code/src/java/plugin/lsttokens/DefineLst.java branches/cdom/code/src/java/plugin/lsttokens/DescLst.java branches/cdom/code/src/java/plugin/lsttokens/DescispiLst.java branches/cdom/code/src/java/plugin/lsttokens/DrLst.java branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java branches/cdom/code/src/java/plugin/lsttokens/KeyLst.java branches/cdom/code/src/java/plugin/lsttokens/KitLst.java branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java branches/cdom/code/src/java/plugin/lsttokens/MoveLst.java branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java branches/cdom/code/src/java/plugin/lsttokens/MovecloneLst.java branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java branches/cdom/code/src/java/plugin/lsttokens/NaturalattacksLst.java branches/cdom/code/src/java/plugin/lsttokens/OutputnameLst.java branches/cdom/code/src/java/plugin/lsttokens/QualifyToken.java branches/cdom/code/src/java/plugin/lsttokens/RegionLst.java branches/cdom/code/src/java/plugin/lsttokens/RemoveLst.java branches/cdom/code/src/java/plugin/lsttokens/SaLst.java branches/cdom/code/src/java/plugin/lsttokens/SourcedateLst.java branches/cdom/code/src/java/plugin/lsttokens/SourcelongLst.java branches/cdom/code/src/java/plugin/lsttokens/SourcepageLst.java branches/cdom/code/src/java/plugin/lsttokens/SourceshortLst.java branches/cdom/code/src/java/plugin/lsttokens/SourcewebLst.java branches/cdom/code/src/java/plugin/lsttokens/SpelllevelLst.java branches/cdom/code/src/java/plugin/lsttokens/SpellsLst.java branches/cdom/code/src/java/plugin/lsttokens/SrLst.java branches/cdom/code/src/java/plugin/lsttokens/TempdescLst.java branches/cdom/code/src/java/plugin/lsttokens/TemplateLst.java branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java branches/cdom/code/src/java/plugin/lsttokens/UdamLst.java branches/cdom/code/src/java/plugin/lsttokens/UmultLst.java branches/cdom/code/src/java/plugin/lsttokens/UnencumberedmoveLst.java branches/cdom/code/src/java/plugin/lsttokens/VisionLst.java branches/cdom/code/src/java/plugin/lsttokens/ability/AddspelllevelToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/BenefitToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/CategoryToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/CostToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/ModifyabilitychoiceToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/ModifyfeatchoiceToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/MultToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/StackToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/VisibleToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/EquipToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/AlignToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/AppearanceToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/DeityweapToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/DomainsToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/FolloweralignToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/PantheonToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/RaceToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/SymbolToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/TitleToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/WorshippersToken.java branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AccheckToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AltcritmultToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AltcritrangeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AltdamageToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AlttypeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/BaseitemToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/BaseqtyToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/ContainsToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/CostToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/CritmultToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/CritrangeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/DamageToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/EdrToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/EqmodToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/FumblerangeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/HandsToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/MaxdexToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/ModsToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/NumPagesToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/PageUsageToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/ProficiencyToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/QualityToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/RangeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/RateoffireToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/ReachMultToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/ReachToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/SizeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/SlotsToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/SpellfailureToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/SpropToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/WieldToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/WtToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/AddprofToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/ArmortypeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/AssigntoallToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/BonusToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/ChargesToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/CostToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/CostdoubleToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/CostpreToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/FormatcatToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/FumblerangeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/ItypeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/NameoptToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/PlusToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/ReplacesToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/SpropToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/VisibleToken.java branches/cdom/code/src/java/plugin/lsttokens/race/CrToken.java branches/cdom/code/src/java/plugin/lsttokens/race/FaceToken.java branches/cdom/code/src/java/plugin/lsttokens/race/FavclassToken.java branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/race/HandsToken.java branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceToken.java branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceadvancementToken.java branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java branches/cdom/code/src/java/plugin/lsttokens/race/InitToken.java branches/cdom/code/src/java/plugin/lsttokens/race/LangbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/race/LangnumToken.java branches/cdom/code/src/java/plugin/lsttokens/race/LegsToken.java branches/cdom/code/src/java/plugin/lsttokens/race/LeveladjustmentToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MfeatToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MonsterclassToken.java branches/cdom/code/src/java/plugin/lsttokens/race/RacesubtypeToken.java branches/cdom/code/src/java/plugin/lsttokens/race/RacetypeToken.java branches/cdom/code/src/java/plugin/lsttokens/race/ReachToken.java branches/cdom/code/src/java/plugin/lsttokens/race/SizeToken.java branches/cdom/code/src/java/plugin/lsttokens/race/SkillmultToken.java branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java branches/cdom/code/src/java/plugin/lsttokens/race/WeaponbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/race/XtraskillptsperlvlToken.java branches/cdom/code/src/java/plugin/lsttokens/skill/AcheckToken.java branches/cdom/code/src/java/plugin/lsttokens/skill/ClassesToken.java branches/cdom/code/src/java/plugin/lsttokens/skill/ExclusiveToken.java branches/cdom/code/src/java/plugin/lsttokens/skill/KeystatToken.java branches/cdom/code/src/java/plugin/lsttokens/skill/UseuntrainedToken.java branches/cdom/code/src/java/plugin/lsttokens/skill/VisibleToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/CasttimeToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/ClassesToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/CompsToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/CostToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/CtToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/DescriptorToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/DomainsToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/DurationToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/ItemToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/PpcostToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/RangeToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/SaveinfoToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/SchoolToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/SpellresToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/StatToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/SubschoolToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/TargetareaToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/VariantsToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/XpcostToken.java branches/cdom/code/src/java/plugin/lsttokens/template/AddLevelToken.java branches/cdom/code/src/java/plugin/lsttokens/template/BonusfeatsToken.java branches/cdom/code/src/java/plugin/lsttokens/template/BonusskillpointsToken.java branches/cdom/code/src/java/plugin/lsttokens/template/CrToken.java branches/cdom/code/src/java/plugin/lsttokens/template/FaceToken.java branches/cdom/code/src/java/plugin/lsttokens/template/FavoredclassToken.java branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/template/GenderlockToken.java branches/cdom/code/src/java/plugin/lsttokens/template/HandsToken.java branches/cdom/code/src/java/plugin/lsttokens/template/HdToken.java branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java branches/cdom/code/src/java/plugin/lsttokens/template/LangbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/template/LegsToken.java branches/cdom/code/src/java/plugin/lsttokens/template/LevelToken.java branches/cdom/code/src/java/plugin/lsttokens/template/LeveladjustmentToken.java branches/cdom/code/src/java/plugin/lsttokens/template/LevelsperfeatToken.java branches/cdom/code/src/java/plugin/lsttokens/template/NonppToken.java branches/cdom/code/src/java/plugin/lsttokens/template/RacesubtypeToken.java branches/cdom/code/src/java/plugin/lsttokens/template/RacetypeToken.java branches/cdom/code/src/java/plugin/lsttokens/template/ReachToken.java branches/cdom/code/src/java/plugin/lsttokens/template/RegionToken.java branches/cdom/code/src/java/plugin/lsttokens/template/RemovableToken.java branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java branches/cdom/code/src/java/plugin/lsttokens/template/SizeToken.java branches/cdom/code/src/java/plugin/lsttokens/template/SubraceToken.java branches/cdom/code/src/java/plugin/lsttokens/template/SubregionToken.java branches/cdom/code/src/java/plugin/lsttokens/template/TemplateToken.java branches/cdom/code/src/java/plugin/lsttokens/template/VisibleToken.java branches/cdom/code/src/java/plugin/lsttokens/template/WeaponbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/weaponprof/HandsToken.java branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/GlobalTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/spell/CostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/HDTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LevelTokenTest.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/cdom/util/ReferenceUtilities.java Removed Paths: ------------- branches/cdom/code/src/java/plugin/lsttokens/template/CostToken.java Modified: branches/cdom/code/src/java/pcgen/base/lang/StringUtil.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/lang/StringUtil.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/base/lang/StringUtil.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -21,6 +21,7 @@ import java.util.Collection; + public final class StringUtil { Added: branches/cdom/code/src/java/pcgen/cdom/util/ReferenceUtilities.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/util/ReferenceUtilities.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/util/ReferenceUtilities.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -0,0 +1,52 @@ +/* + * Copyright 2007 (C) Tom Parker <th...@us...> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +package pcgen.cdom.util; + +import java.util.Collection; + +import pcgen.cdom.base.CDOMReference; + +public class ReferenceUtilities +{ + + public static <T extends CDOMReference<?>> String joinLstFormat( + Collection<T> set, String separator) + { + if (set == null) + { + return ""; + } + + final StringBuilder result = new StringBuilder(set.size() * 10); + + boolean needjoin = false; + + for (CDOMReference<?> obj : set) + { + if (needjoin) + { + result.append(separator); + } + needjoin = true; + result.append(obj.getLSTformat()); + } + + return result.toString(); + } + +} Modified: branches/cdom/code/src/java/pcgen/persistence/lst/AbilityLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/AbilityLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/AbilityLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,5 +47,5 @@ public boolean parse(LoadContext context, Ability ability, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, Ability ability); + public String[] unparse(LoadContext context, Ability ability); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/AutoLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/AutoLoader.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/AutoLoader.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -22,6 +22,8 @@ */ package pcgen.persistence.lst; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import pcgen.cdom.base.CDOMObject; @@ -55,7 +57,7 @@ LstUtils.deprecationCheck(token, target, value); if (!token.parse(target, value)) { - Logging.errorPrint("Error parsing AUTO: " + key + ":" + value); + Logging.errorPrint("Error parsing AUTO: " + key + "|" + value); return false; } return true; @@ -78,7 +80,7 @@ LstUtils.deprecationCheck(token, obj, value); if (!token.parse(context, obj, value)) { - Logging.errorPrint("Error parsing AUTO:" + key + ":" + value); + Logging.errorPrint("Error parsing AUTO:" + key + "|" + value); return false; } return true; @@ -90,30 +92,21 @@ } } - public static String unparse(LoadContext context, CDOMObject obj) + public static String[] unparse(LoadContext context, CDOMObject obj) { - StringBuilder sb = new StringBuilder(); - boolean needTab = false; + List<String> list = new ArrayList<String>(); for (LstToken token : TokenStore.inst().getTokenMap(AutoLstToken.class) .values()) { - String s = ((AutoLstToken) token).unparse(context, (PObject) obj); + String[] s = ((AutoLstToken) token).unparse(context, (PObject) obj); if (s != null) { - if (needTab) + for (String aString : s) { - sb.append('\t'); + list.add(token.getTokenName() + "|" + aString); } - needTab = true; - /* - * TODO FIXME This introduces a BUG, in that this assumes the s - * is only one token, and there is no parent involved... therefore - * the unparse methods in AUTO either need to return String[] - * or something else needs to be done... - */ - sb.append("AUTO:").append(s); } } - return sb.length() == 0 ? null : sb.toString(); + return list.size() == 0 ? null : list.toArray(new String[list.size()]); } } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/CDOMToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/CDOMToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/CDOMToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -26,5 +26,5 @@ public boolean parse(LoadContext context, T obj, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, T obj); + public String[] unparse(LoadContext context, T obj); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/DeityLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/DeityLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/DeityLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,5 +47,5 @@ public boolean parse(LoadContext context, Deity deit, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, Deity deity); + public String[] unparse(LoadContext context, Deity deity); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/DomainLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/DomainLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/DomainLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,5 +47,5 @@ public boolean parse(LoadContext context, Domain domain, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, Domain domain); + public String[] unparse(LoadContext context, Domain domain); } \ No newline at end of file Modified: branches/cdom/code/src/java/pcgen/persistence/lst/EquipmentLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/EquipmentLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/EquipmentLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,5 +47,5 @@ public boolean parse(LoadContext context, Equipment eq, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, Equipment eq); + public String[] unparse(LoadContext context, Equipment eq); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/EquipmentModifierLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/EquipmentModifierLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/EquipmentModifierLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,5 +47,5 @@ public boolean parse(LoadContext context, EquipmentModifier mod, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, EquipmentModifier mod); + public String[] unparse(LoadContext context, EquipmentModifier mod); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/GlobalLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/GlobalLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/GlobalLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -33,5 +33,5 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, CDOMObject obj); + public String[] unparse(LoadContext context, CDOMObject obj); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/LanguageLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/LanguageLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/LanguageLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,5 +47,5 @@ public boolean parse(LoadContext context, Language lang, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, Language lang); + public String[] unparse(LoadContext context, Language lang); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/PCTemplateLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/PCTemplateLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/PCTemplateLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,5 +47,5 @@ public boolean parse(LoadContext context, PCTemplate pct, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, PCTemplate pct); + public String[] unparse(LoadContext context, PCTemplate pct); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/RaceLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/RaceLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/RaceLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,5 +47,5 @@ public boolean parse(LoadContext context, Race race, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, Race race); + public String[] unparse(LoadContext context, Race race); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/SkillLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/SkillLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/SkillLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,6 +47,6 @@ public boolean parse(LoadContext context, Skill skill, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, Skill skill); + public String[] unparse(LoadContext context, Skill skill); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/SpellLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/SpellLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/SpellLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,6 +47,6 @@ public boolean parse(LoadContext context, Spell spell, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, Spell spell); + public String[] unparse(LoadContext context, Spell spell); } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/WeaponProfLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/WeaponProfLstToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/pcgen/persistence/lst/WeaponProfLstToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -47,6 +47,6 @@ public boolean parse(LoadContext context, WeaponProf prof, String value) throws PersistenceLayerException; - public String unparse(LoadContext context, WeaponProf prof); + public String[] unparse(LoadContext context, WeaponProf prof); } Modified: branches/cdom/code/src/java/plugin/lsttokens/AbilityLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/AbilityLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/AbilityLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -246,8 +246,7 @@ while (true) { CDOMCategorizedSingleRef<Ability> ability = - context.ref.getCDOMReference(ABILITY_CLASS, - abCat, token); + context.ref.getCDOMReference(ABILITY_CLASS, abCat, token); PCGraphGrantsEdge edge = context.graph.linkObjectIntoGraph(getTokenName(), obj, ability); @@ -289,7 +288,7 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeSet = context.graph.getChildLinksFromToken(getTokenName(), obj, @@ -310,9 +309,8 @@ edge.getPrerequisiteList()), ab); } - StringBuilder sb = new StringBuilder(); PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); - boolean needTab = false; + List<String> list = new ArrayList<String>(); for (AbilityNature nature : m.getKeySet()) { for (String category : m.getSecondaryKeySet(nature)) @@ -320,12 +318,7 @@ for (Set<Prerequisite> prereqs : m.getTertiaryKeySet(nature, category)) { - if (needTab) - { - sb.append('\t'); - } - needTab = true; - sb.append(getTokenName()).append(':'); + StringBuilder sb = new StringBuilder(); sb.append(category).append(Constants.PIPE); sb.append(nature); for (Ability a : m.getListFor(nature, category, prereqs)) @@ -352,10 +345,11 @@ .append(swriter.toString()); } } + list.add(sb.toString()); } } } - return sb.toString(); + return list.toArray(new String[list.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/AddLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/AddLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/AddLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -172,7 +172,7 @@ //return AddLoader.parseLine(context, obj, value); } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { // TODO Auto-generated method stub return null; Modified: branches/cdom/code/src/java/plugin/lsttokens/AutoLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/AutoLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/AutoLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -67,7 +67,7 @@ return AutoLoader.parseLine(context, (PObject) obj, subKey, value.substring(barLoc + 1)); } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { return AutoLoader.unparse(context, obj); } Modified: branches/cdom/code/src/java/plugin/lsttokens/BonusLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/BonusLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/BonusLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -76,7 +76,7 @@ return ((PObject) obj).addBonusList(value); } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { // TODO Auto-generated method stub return null; Modified: branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -109,13 +109,12 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, SKILL_CLASS); StringBuilder sb = new StringBuilder(); - sb.append(getTokenName()).append(':'); boolean needsPipe = false; for (PCGraphEdge edge : edgeList) { @@ -138,6 +137,6 @@ sb.append(sk.getKeyName()); needsPipe = true; } - return sb.toString(); + return new String[]{sb.toString()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/ChangeprofLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/ChangeprofLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/ChangeprofLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -143,7 +143,7 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, @@ -163,7 +163,6 @@ } StringBuilder sb = new StringBuilder(); - sb.append(getTokenName()).append(Constants.COLON); boolean needPipe = true; for (CDOMGroupRef<WeaponProf> result : m.getKeySet()) { @@ -184,6 +183,6 @@ } sb.append(Constants.EQUALS).append(result); } - return sb.toString(); + return new String[]{sb.toString()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/ChooseLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/ChooseLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/ChooseLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -56,7 +56,7 @@ return ChooseLoader.parseLine(context, obj, value); } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { // TODO Auto-generated method stub return null; Modified: branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -304,7 +304,7 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, @@ -313,20 +313,14 @@ { return null; } - StringBuilder sb = new StringBuilder(); PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); - boolean needTab = false; + List<String> list = new ArrayList<String>(); for (PCGraphEdge edge : edgeList) { List<Prerequisite> prereqs = edge.getPrerequisiteList(); CompanionList cl = (CompanionList) edge.getNodeAt(1); int followerAdjustment = cl.getAdjustment(); - if (needTab) - { - sb.append('\t'); - } - needTab = true; - sb.append(getTokenName()).append(Constants.COLON); + StringBuilder sb = new StringBuilder(); sb.append(cl.getFollowerType()); for (CDOMReference<Race> race : cl.getCompanionSet()) { @@ -356,7 +350,8 @@ sb.append(Constants.PIPE).append(swriter.toString()); } } + list.add(sb.toString()); } - return sb.toString(); + return list.toArray(new String[list.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -40,7 +40,7 @@ /** * @author djones4 - * + * */ public class CskillLst implements GlobalLstToken { @@ -108,13 +108,12 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, SKILL_CLASS); StringBuilder sb = new StringBuilder(); - sb.append(getTokenName()).append(':'); boolean needsPipe = false; for (PCGraphEdge edge : edgeList) { @@ -136,6 +135,6 @@ sb.append(sk.getKeyName()); needsPipe = true; } - return sb.toString(); + return new String[]{sb.toString()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/DefineLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/DefineLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/DefineLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -78,7 +78,7 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { // TODO Auto-generated method stub return null; Modified: branches/cdom/code/src/java/plugin/lsttokens/DescLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/DescLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/DescLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -22,6 +22,8 @@ */ package plugin.lsttokens; +import java.util.ArrayList; +import java.util.List; import java.util.Set; import java.util.StringTokenizer; @@ -171,7 +173,7 @@ return desc; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edges = context.graph.getChildLinksFromToken(getTokenName(), obj, @@ -180,18 +182,11 @@ { return null; } - StringBuilder sb = new StringBuilder(); - boolean needsTab = false; + List<String> list = new ArrayList<String>(edges.size()); for (PCGraphEdge edge : edges) { - if (needsTab) - { - sb.append('\t'); - } - needsTab = true; - sb.append(getTokenName()).append(':'); - sb.append(((Description) edge.getSinkNodes().get(0)).getPCCText()); + list.add(((Description) edge.getSinkNodes().get(0)).getPCCText()); } - return sb.toString(); + return list.toArray(new String[list.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/DescispiLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/DescispiLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/DescispiLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -75,10 +75,9 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { boolean namePI = obj.isDescPI(); - return new StringBuilder().append(getTokenName()).append(':').append( - namePI ? "YES" : "NO").toString(); + return new String[]{namePI ? "YES" : "NO"}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/DrLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/DrLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/DrLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -38,10 +38,11 @@ import java.util.ArrayList; import java.util.Set; import java.util.StringTokenizer; +import java.util.TreeSet; /** * @author djones4 - * + * */ public class DrLst extends AbstractToken implements GlobalLstToken @@ -126,11 +127,11 @@ } StringTokenizer tok = new StringTokenizer(value, "|"); - //String drString = tok.nextToken(); + // String drString = tok.nextToken(); DamageReduction dr; try { - //dr = DamageReduction.getDamageReduction(drString); + // dr = DamageReduction.getDamageReduction(drString); String[] values = tok.nextToken().split("/"); if (values.length != 2) { @@ -162,22 +163,17 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, DamageReduction.class); - StringBuilder sb = new StringBuilder(); - boolean needsTab = false; + Set<String> set = new TreeSet<String>(); for (PCGraphEdge edge : edgeList) { - if (needsTab) - { - sb.append('\t'); - } DamageReduction dr = (DamageReduction) edge.getSinkNodes().get(0); - sb.append("DR").append(dr); + set.add(dr.toString()); } - return sb.toString(); + return set.toArray(new String[set.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -40,6 +40,7 @@ import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.GlobalLstToken; +import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.StringTokenizer; @@ -139,17 +140,15 @@ String followerNumber = tok.nextToken(); Formula num = FormulaFactory.getFormulaFor(followerNumber); /* - * BUG FIXME This is a problem, because it is possible that the + * BUG FIXME This is a problem, because it is possible that the * CompanionList is NOT YET PRESENT in the Graph... :P * - * So I think I need to fetch a Reference, and then - * officially build the CompanionList through the Context - * later on? That seems like a PAIN... + * So I think I need to fetch a Reference, and then officially build the + * CompanionList through the Context later on? That seems like a PAIN... * - * Actually, even that doesn't work, because there could - * be more than one... so a reference doesn't do any good - * Therefore, this is a deferred search of a Graph? I'm - * not a huge fan of that either. + * Actually, even that doesn't work, because there could be more than + * one... so a reference doesn't do any good Therefore, this is a + * deferred search of a Graph? I'm not a huge fan of that either. */ Set<PCGraphEdge> linkSet = context.graph.getChildLinks(obj, CompanionList.class); @@ -185,7 +184,7 @@ return found; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, @@ -194,15 +193,10 @@ { return null; } - StringBuilder sb = new StringBuilder(); - boolean needsTab = false; + List<String> list = new ArrayList<String>(edgeList.size()); for (PCGraphEdge edge : edgeList) { - if (needsTab) - { - sb.append('\t'); - } - sb.append(getTokenName()).append(':'); + StringBuilder sb = new StringBuilder(); Slot<Follower> s = (Slot<Follower>) edge.getSinkNodes().get(0); sb.append(s.toLSTform()).append(Constants.PIPE); List<Restriction<?>> resList = s.getSinkRestrictions(); @@ -224,7 +218,8 @@ // { // } } + list.add(sb.toString()); } - return sb.toString(); + return list.toArray(new String[list.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/KeyLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/KeyLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/KeyLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -30,7 +30,7 @@ /** * @author djones4 - * + * */ public class KeyLst implements GlobalLstToken { @@ -48,19 +48,19 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { - //THIS IS ORDER DEPENDENT, MUST BE DONE BEFORE resetting the key + // THIS IS ORDER DEPENDENT, MUST BE DONE BEFORE resetting the key context.ref.reassociateReference(value, ((PObject) obj)); - //Hacking for duplicate protection + // Hacking for duplicate protection ((PObject) obj).setKeyName(value); /* - * TODO This actually needs to be special - since the Key is the lookup method - * FUTURE isn't this redundant with the set above?! + * TODO This actually needs to be special - since the Key is the lookup + * method FUTURE isn't this redundant with the set above?! */ obj.put(StringKey.KEY_NAME, value); return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { String key = obj.getKeyName(); String display = obj.getDisplayName(); @@ -68,7 +68,6 @@ { return null; } - return new StringBuilder().append(getTokenName()).append(':').append( - key).toString(); + return new String[]{key}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/KitLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/KitLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/KitLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -22,6 +22,8 @@ */ package plugin.lsttokens; +import java.util.ArrayList; +import java.util.List; import java.util.Set; import java.util.StringTokenizer; @@ -38,7 +40,7 @@ /** * @author djones4 - * + * */ public class KitLst implements GlobalLstToken { @@ -71,7 +73,9 @@ try { int count = Integer.parseInt(tok.nextToken()); - cl = new ChoiceSet<CDOMSimpleSingleRef<Kit>>(count, tok.countTokens()); + cl = + new ChoiceSet<CDOMSimpleSingleRef<Kit>>(count, tok + .countTokens()); } catch (NumberFormatException nfe) { @@ -99,27 +103,29 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, ChoiceSet.class); - StringBuilder sb = new StringBuilder(); - boolean needsTab = false; + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } + List<String> list = new ArrayList<String>(edgeList.size()); for (PCGraphEdge edge : edgeList) { - if (needsTab) - { - sb.append('\t'); - } + StringBuilder sb = new StringBuilder(); ChoiceSet<CDOMSimpleSingleRef<Kit>> cl = - (ChoiceSet<CDOMSimpleSingleRef<Kit>>) edge.getSinkNodes().get(0); + (ChoiceSet<CDOMSimpleSingleRef<Kit>>) edge.getSinkNodes() + .get(0); sb.append(cl.getCount()); for (CDOMSimpleSingleRef<Kit> ref : cl.getSet()) { sb.append(Constants.PIPE).append(ref.getLSTformat()); } + list.add(sb.toString()); } - return sb.toString(); + return list.toArray(new String[list.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -24,19 +24,24 @@ import java.util.Set; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.PrereqObject; +import pcgen.cdom.content.ChoiceSet; import pcgen.cdom.graph.PCGraphEdge; +import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.Language; import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.GlobalLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; /** * @author djones4 - * + * */ public class LangautoLst implements GlobalLstToken { @@ -93,7 +98,7 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edges = context.graph.getChildLinksFromToken(getTokenName(), obj, @@ -102,21 +107,14 @@ { return null; } - StringBuilder sb = - new StringBuilder().append(getTokenName()).append(':'); - boolean needComma = false; - /* - * BUG Doesn't handle references correctly :( - */ + Set<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); for (PCGraphEdge edge : edges) { - if (needComma) - { - sb.append(Constants.COMMA); - } - sb.append(((Language) edge.getSinkNodes().get(0)).getKeyName()); - needComma = true; + set.addAll(((ChoiceSet<CDOMReference<?>>) edge.getSinkNodes() + .get(0)).getSet()); } - return sb.toString(); + return new String[]{ReferenceUtilities.joinLstFormat(set, + Constants.PIPE)}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/MoveLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/MoveLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/MoveLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -23,6 +23,7 @@ package plugin.lsttokens; import java.util.Set; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; import pcgen.cdom.graph.PCGraphEdge; @@ -34,7 +35,7 @@ /** * @author djones4 - * + * */ public class MoveLst implements GlobalLstToken { @@ -64,22 +65,17 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, Movement.class); - StringBuilder sb = new StringBuilder(); - boolean needsTab = false; + Set<String> set = new TreeSet<String>(); for (PCGraphEdge edge : edgeList) { - if (needsTab) - { - sb.append('\t'); - } Movement m = (Movement) edge.getSinkNodes().get(0); - sb.append(m.toLSTString()); + set.add(m.toLSTString()); } - return sb.toString(); + return set.toArray(new String[set.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -23,6 +23,7 @@ package plugin.lsttokens; import java.util.Set; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; import pcgen.cdom.graph.PCGraphEdge; @@ -33,7 +34,7 @@ /** * @author djones4 - * + * */ public class MoveaLst implements GlobalLstToken { @@ -59,22 +60,17 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, Movement.class); - StringBuilder sb = new StringBuilder(); - boolean needsTab = false; + Set<String> set = new TreeSet<String>(); for (PCGraphEdge edge : edgeList) { - if (needsTab) - { - sb.append('\t'); - } Movement m = (Movement) edge.getSinkNodes().get(0); - sb.append(m.toLSTString()); + set.add(m.toLSTString()); } - return sb.toString(); + return set.toArray(new String[set.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/MovecloneLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/MovecloneLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/MovecloneLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -23,6 +23,7 @@ package plugin.lsttokens; import java.util.Set; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; import pcgen.cdom.graph.PCGraphEdge; @@ -33,7 +34,7 @@ /** * @author djones4 - * + * */ public class MovecloneLst implements GlobalLstToken { @@ -59,22 +60,17 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, Movement.class); - StringBuilder sb = new StringBuilder(); - boolean needsTab = false; + Set<String> set = new TreeSet<String>(); for (PCGraphEdge edge : edgeList) { - if (needsTab) - { - sb.append('\t'); - } Movement m = (Movement) edge.getSinkNodes().get(0); - sb.append(m.toLSTString()); + set.add(m.toLSTString()); } - return sb.toString(); + return set.toArray(new String[set.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -75,10 +75,9 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { boolean namePI = obj.isNamePI(); - return new StringBuilder().append(getTokenName()).append(':').append( - namePI ? "YES" : "NO").toString(); + return new String[]{namePI ? "YES" : "NO"}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/NaturalattacksLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/NaturalattacksLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/NaturalattacksLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -492,7 +492,7 @@ return anEquip; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { // TODO Auto-generated method stub return null; Modified: branches/cdom/code/src/java/plugin/lsttokens/OutputnameLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/OutputnameLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/OutputnameLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -30,7 +30,7 @@ /** * @author djones4 - * + * */ public class OutputnameLst implements GlobalLstToken { @@ -52,15 +52,14 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { String oname = obj.get(StringKey.OUTPUT_NAME); if (oname == null) { return null; } - return new StringBuilder().append(getTokenName()).append(':').append( - oname).toString(); + return new String[]{oname}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/QualifyToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/QualifyToken.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/QualifyToken.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -94,7 +94,7 @@ return false; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { // TODO Auto-generated method stub return null; Modified: branches/cdom/code/src/java/plugin/lsttokens/RegionLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/RegionLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/RegionLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -30,7 +30,7 @@ /** * @author djones4 - * + * */ public class RegionLst implements GlobalLstToken { @@ -59,15 +59,14 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { String region = obj.get(StringKey.REGION); if (region == null) { return null; } - return new StringBuilder().append(getTokenName()).append(':').append( - region).toString(); + return new String[]{region}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/RemoveLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/RemoveLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/RemoveLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -117,7 +117,7 @@ return true; } - public String unparse(LoadContext context, CDOMObject obj) + public String[] unparse(LoadContext context, CDOMObject obj) { // TODO Auto-generated method stub return null; Modified: branches/cdom/code/src/java/plugin/lsttokens/SaLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/SaLst.java 2007-03-12 22:39:51 UTC (rev 2493) +++ branches/cdom/code/src/java/plugin/lsttokens/SaLst.java 2007-03-13 03:59:32 UTC (rev 2494) @@ -39,13 +39,14 @@ import pcgen.util.Logging; import java.io.StringWriter; +import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.StringTokenizer; /** * @author djones4 - * + * */ public class SaLst extends AbstractToken implements GlobalLstToken { @@ -65,13 +66,13 @@ /** * This method sets the special abilities granted by this [object]. For * efficiency, avoid calling this method except from I/O routines. - * + * * @param obj - * the PObject that is to receive the new SpecialAbility + * the PObject that is to receive the new SpecialAbility * @param aString - * String of special abilities delimited by pipes + * String of special abilities delimited by pipes * @param level - * int level at which the ability is gained + * int level at which the ability is gained */ public static void parseSpecialAbility(PObject obj, String aString, int level) @@ -210,7 +211,7 @@ else { saName.append(token); - //sa.addVariable(FormulaFactory.getFormulaFor(token)); + // sa.addVariable(FormulaFactory.getFormulaFor(token)); } if (!tok.hasMoreTokens()) @@ -225,7 +226,7 @@ } saName.append(Constants.PIPE); } - //CONSIDER This is a HACK and not the long term strategy of SA: + // CONSIDER This is a HACK and not the long term strategy of SA: sa.setName(saName.toString()); while (true) @@ -238,10 +239,10 @@ return false; }... [truncated message content] |
From: <th...@us...> - 2007-03-13 22:29:52
|
Revision: 2498 http://svn.sourceforge.net/pcgen/?rev=2498&view=rev Author: thpr Date: 2007-03-13 15:29:50 -0700 (Tue, 13 Mar 2007) Log Message: ----------- CDOM: Two new unit tests and moved generic test case classes for clarity Modified Paths: -------------- branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java branches/cdom/code/src/java/plugin/lsttokens/skill/KeystatToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/StatToken.java branches/cdom/code/src/test/plugin/lsttokens/auto/AbstractProfTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/deity/AlignTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/AppearanceTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/DeityWeapTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/DomainsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/FollowerAlignTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/PantheonTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/RaceTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/SymbolTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/TitleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/deity/WorshippersTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/domain/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/AbstractCritMultTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/equipment/AbstractCritRangeTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/equipment/AbstractDamageTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/equipment/AbstractEqModTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/equipment/AcCheckTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/AltTypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/BaseItemTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/BaseqtyTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/CostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/EdrTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/FumbleRangeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/HandsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/MaxDexTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/ModsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/NumPagesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/PageUsageTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/ProficiencyTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/QualityTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/RangeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/RateOfFireTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/ReachMultTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/ReachTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/SPropTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/SlotsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/SpellfailureTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/WeildTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/WtTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/AssignToAllTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/ChargesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/CostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/CostdoubleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/CostpreTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/FormatcatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/FumblerangeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/ItypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/NameoptTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/PlusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/ReplacesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/SPropTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipmentmodifier/VisibleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/CRTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/FaceTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/HandsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/HitDieTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/LangNumTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/LangbonusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/LegsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/LevelAdjustmentTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/MFeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/MonCCSkillTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/MonCSkillTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/MonsterClassTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/RaceSubtypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/RaceTypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/ReachTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/SkillMultTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/WeaponbonusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/race/XtraSkillPointsPerLevelTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/ACheckTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/ClassesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/ExclusiveTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/UseuntrainedTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/VisibleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/CastTimeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/ClassesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/CompsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/CostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/CtTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/DescriptorTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/DomainsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/DurationTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/PPCostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/RangeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/SaveInfoTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/SchoolTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/SpellResTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/SubschoolTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/TargetAreaTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/VariantsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/XPCostTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/AddLevelTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/BonusFeatsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/BonusSkillPointsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/CRTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/FaceTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/GenderLockTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/HDTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/HandsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/HitDieTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LangbonusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LegsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LevelAdjustmentTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LevelTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/LevelsPerFeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/NonPPTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RaceSubtypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RaceTypeTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/ReachTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RegionTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RemovableTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/RepeatLevelTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/SubraceTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/SubregionTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/TemplateTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/VisibleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/WeaponbonusTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/weaponprof/HandsTokenTest.java Added Paths: ----------- branches/cdom/code/src/test/plugin/lsttokens/skill/KeystatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/StatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/ branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractBigDecimalTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractFormulaTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractIntegerTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractItemTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractListTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractStringTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractTextPropertyTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractTypeSafeListTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractTypeSafeTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/GlobalTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/TokenRegistration.java Removed Paths: ------------- branches/cdom/code/src/test/plugin/lsttokens/AbstractBigDecimalTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractFormulaTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractItemTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractListTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractStringTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractTextPropertyTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeListTestCase.java branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/GlobalTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/TokenRegistration.java Modified: branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -23,8 +23,12 @@ import java.util.Set; +import pcgen.cdom.base.CDOMGroupRef; +import pcgen.cdom.base.FormulaFactory; import pcgen.cdom.base.Slot; +import pcgen.cdom.enumeration.AbilityCategory; import pcgen.cdom.graph.PCGraphEdge; +import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Ability; import pcgen.core.Race; import pcgen.core.bonus.Bonus; @@ -97,14 +101,17 @@ * PREMULT fail in? */ // buf.append("PREMULT:1,[PRELEVEL:1],[PREHD:1]"); - for (int i = 0; i < featCount; i++) - { - /* - * TODO FIXME Does this slot need to have a CATEGORY associated with - * it? - */ - context.graph.addSlotIntoGraph(getTokenName(), race, ABILITY_CLASS); - } + Slot<Ability> slot = + context.graph.addSlotIntoGraph(getTokenName(), race, + ABILITY_CLASS, FormulaFactory.getFormulaFor(featCount)); + CDOMGroupRef<Ability> ref = + context.ref.getCategorizedCDOMAllReference(ABILITY_CLASS, + AbilityCategory.FEAT); + + slot.addSinkRestriction(new GroupRestriction<Ability>(ABILITY_CLASS, + ref)); + // FIXME Slot needs to know AbilityNature.???? ?? + return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/skill/KeystatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/skill/KeystatToken.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/java/plugin/lsttokens/skill/KeystatToken.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -67,6 +67,6 @@ { return null; } - return new String[]{pcs.getKey()}; + return new String[]{pcs.getKeyName()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/spell/StatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/spell/StatToken.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/java/plugin/lsttokens/spell/StatToken.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -65,6 +65,6 @@ { return null; } - return new String[]{pcs.getKey()}; + return new String[]{pcs.getKeyName()}; } } Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractBigDecimalTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractBigDecimalTokenTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractBigDecimalTokenTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,168 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import java.math.BigDecimal; - -import org.junit.Test; - -import pcgen.cdom.enumeration.ObjectKey; -import pcgen.core.PObject; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.AbstractTokenTestCase; - -public abstract class AbstractBigDecimalTokenTestCase<T extends PObject> extends - AbstractTokenTestCase<T> -{ - - public abstract ObjectKey<BigDecimal> getObjectKey(); - - public abstract boolean isZeroAllowed(); - - public abstract boolean isNegativeAllowed(); - - public abstract boolean isPositiveAllowed(); - - @Test - public void testInvalidInputUnset() throws PersistenceLayerException - { - testInvalidInputs(null); - } - - @Test - public void testInvalidInputSet() throws PersistenceLayerException - { - BigDecimal con; - if (isPositiveAllowed()) - { - con = new BigDecimal(3); - } - else - { - con = new BigDecimal(-3); - } - assertTrue(getToken() - .parse(primaryContext, primaryProf, con.toString())); - assertEquals(con, primaryProf.get(getObjectKey())); - testInvalidInputs(con); - } - - public void testInvalidInputs(BigDecimal val) - throws PersistenceLayerException - { - //Always ensure get is unchanged - // since no invalid item should set or reset the value - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "TestWP")); - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "String")); - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, - "TYPE=TestType")); - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, - "TYPE.TestType")); - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "ALL")); - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "ANY")); - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "FIVE")); - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "1/2")); - assertEquals(val, primaryProf.get(getObjectKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "1+3")); - assertEquals(val, primaryProf.get(getObjectKey())); - //Require Integer greater than or equal to zero - if (!isNegativeAllowed()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, "-1")); - assertEquals(val, primaryProf.get(getObjectKey())); - } - if (!isPositiveAllowed()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, "1")); - assertEquals(val, primaryProf.get(getObjectKey())); - } - if (!isZeroAllowed()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, "0")); - assertEquals(val, primaryProf.get(getObjectKey())); - } - } - - @Test - public void testValidInputs() throws PersistenceLayerException - { - if (isPositiveAllowed()) - { - assertTrue(getToken().parse(primaryContext, primaryProf, "4.5")); - assertEquals(new BigDecimal(4.5), primaryProf.get(getObjectKey())); - assertTrue(getToken().parse(primaryContext, primaryProf, "5")); - assertEquals(new BigDecimal(5), primaryProf.get(getObjectKey())); - assertTrue(getToken().parse(primaryContext, primaryProf, "1")); - assertEquals(new BigDecimal(1), primaryProf.get(getObjectKey())); - } - if (isZeroAllowed()) - { - assertTrue(getToken().parse(primaryContext, primaryProf, "0")); - assertEquals(new BigDecimal(0), primaryProf.get(getObjectKey())); - } - if (isNegativeAllowed()) - { - assertTrue(getToken().parse(primaryContext, primaryProf, "-2")); - assertEquals(new BigDecimal(-2), primaryProf.get(getObjectKey())); - } - } - - @Test - public void testRoundRobinOne() throws PersistenceLayerException - { - if (isPositiveAllowed()) - { - runRoundRobin("1"); - } - } - - @Test - public void testRoundRobinZero() throws PersistenceLayerException - { - if (isZeroAllowed()) - { - runRoundRobin("0"); - } - } - - @Test - public void testRoundRobinNegative() throws PersistenceLayerException - { - if (isNegativeAllowed()) - { - runRoundRobin("-3"); - } - } - - @Test - public void testRoundRobinThreePointFive() throws PersistenceLayerException - { - if (isPositiveAllowed()) - { - runRoundRobin("3.5"); - } - } -} Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractFormulaTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractFormulaTokenTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractFormulaTokenTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,63 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import org.junit.Test; - -import pcgen.cdom.enumeration.FormulaKey; -import pcgen.core.PObject; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.AbstractTokenTestCase; - -public abstract class AbstractFormulaTokenTestCase<T extends PObject> extends - AbstractTokenTestCase<T> -{ - - @Test - public void testValidInputs() throws PersistenceLayerException - { - assertTrue(getToken().parse(primaryContext, primaryProf, "Variable1")); - assertEquals("Variable1", primaryProf.get(getFormulaKey()).toString()); - assertTrue(getToken().parse(primaryContext, primaryProf, "3")); - assertEquals("3", primaryProf.get(getFormulaKey()).toString()); - assertTrue(getToken().parse(primaryContext, primaryProf, - "3+CL(\"Fighter\"")); - assertEquals("3+CL(\"Fighter\"", primaryProf.get(getFormulaKey()) - .toString()); - } - - public abstract FormulaKey getFormulaKey(); - - @Test - public void testRoundRobinBase() throws PersistenceLayerException - { - runRoundRobin("Variable1"); - } - - @Test - public void testRoundRobinNumber() throws PersistenceLayerException - { - runRoundRobin("3"); - } - - @Test - public void testRoundRobinFormula() throws PersistenceLayerException - { - runRoundRobin("3+CL(\"Fighter\""); - } -} Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractIntegerTokenTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,219 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import org.junit.Test; - -import pcgen.cdom.enumeration.IntegerKey; -import pcgen.core.PObject; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.AbstractTokenTestCase; - -public abstract class AbstractIntegerTokenTestCase<T extends PObject> extends - AbstractTokenTestCase<T> -{ - - public abstract IntegerKey getIntegerKey(); - - public abstract boolean isZeroAllowed(); - - public abstract boolean isNegativeAllowed(); - - public abstract boolean isPositiveAllowed(); - - @Test - public void testInvalidInputUnset() throws PersistenceLayerException - { - testInvalidInputs(null); - } - - @Test - public void testInvalidInputSet() throws PersistenceLayerException - { - Integer con; - if (isPositiveAllowed()) - { - con = Integer.valueOf(3); - } - else - { - con = Integer.valueOf(-3); - } - assertTrue(getToken() - .parse(primaryContext, primaryProf, con.toString())); - assertEquals(con, primaryProf.get(getIntegerKey())); - testInvalidInputs(con); - } - - public void testInvalidInputs(Integer val) throws PersistenceLayerException - { - // Always ensure get is unchanged - // since no invalid item should set or reset the value - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "TestWP")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "String")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, - "TYPE=TestType")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, - "TYPE.TestType")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "ALL")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "ANY")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "FIVE")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "4.5")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "1/2")); - assertEquals(val, primaryProf.get(getIntegerKey())); - assertFalse(getToken().parse(primaryContext, primaryProf, "1+3")); - assertEquals(val, primaryProf.get(getIntegerKey())); - // Require Integer greater than or equal to zero - if (!isNegativeAllowed()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, "-1")); - assertEquals(val, primaryProf.get(getIntegerKey())); - } - if (!isPositiveAllowed()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, "1")); - assertEquals(val, primaryProf.get(getIntegerKey())); - } - if (!isZeroAllowed()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, "0")); - assertEquals(val, primaryProf.get(getIntegerKey())); - } - } - - @Test - public void testValidInputs() throws PersistenceLayerException - { - if (isPositiveAllowed()) - { - assertTrue(getToken().parse(primaryContext, primaryProf, "5")); - assertEquals(Integer.valueOf(5), primaryProf.get(getIntegerKey())); - assertTrue(getToken().parse(primaryContext, primaryProf, "1")); - assertEquals(Integer.valueOf(1), primaryProf.get(getIntegerKey())); - } - if (isZeroAllowed()) - { - assertTrue(getToken().parse(primaryContext, primaryProf, "0")); - assertEquals(Integer.valueOf(0), primaryProf.get(getIntegerKey())); - } - if (isNegativeAllowed()) - { - assertTrue(getToken().parse(primaryContext, primaryProf, "-2")); - assertEquals(Integer.valueOf(-2), primaryProf.get(getIntegerKey())); - } - } - - @Test - public void testOutputOne() throws PersistenceLayerException - { - assertTrue(0 == primaryContext.getWriteMessageCount()); - primaryProf.put(getIntegerKey(), 1); - String[] unparsed = getToken().unparse(primaryContext, primaryProf); - if (isPositiveAllowed()) - { - assertEquals(1, unparsed.length); - assertEquals("1", unparsed[0]); - } - else - { - assertNull(unparsed); - assertTrue(0 != primaryContext.getWriteMessageCount()); - } - } - - @Test - public void testOutputZero() throws PersistenceLayerException - { - assertTrue(0 == primaryContext.getWriteMessageCount()); - primaryProf.put(getIntegerKey(), 0); - String[] unparsed = getToken().unparse(primaryContext, primaryProf); - if (isZeroAllowed()) - { - assertEquals(1, unparsed.length); - assertEquals("0", unparsed[0]); - } - else - { - assertNull(unparsed); - assertTrue(0 != primaryContext.getWriteMessageCount()); - } - } - - @Test - public void testOutputMinusTwo() throws PersistenceLayerException - { - assertTrue(0 == primaryContext.getWriteMessageCount()); - primaryProf.put(getIntegerKey(), -2); - String[] unparsed = getToken().unparse(primaryContext, primaryProf); - if (isNegativeAllowed()) - { - assertEquals(1, unparsed.length); - assertEquals("-2", unparsed[0]); - } - else - { - assertNull(unparsed); - assertTrue(0 != primaryContext.getWriteMessageCount()); - } - } - - @Test - public void testRoundRobinOne() throws PersistenceLayerException - { - if (isPositiveAllowed()) - { - runRoundRobin("1"); - } - } - - @Test - public void testRoundRobinZero() throws PersistenceLayerException - { - if (isZeroAllowed()) - { - runRoundRobin("0"); - } - } - - @Test - public void testRoundRobinNegative() throws PersistenceLayerException - { - if (isNegativeAllowed()) - { - runRoundRobin("-3"); - } - } - - @Test - public void testRoundRobinFive() throws PersistenceLayerException - { - if (isPositiveAllowed()) - { - runRoundRobin("5"); - } - } -} Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractItemTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractItemTokenTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractItemTokenTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,124 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import org.junit.Test; - -import pcgen.core.PObject; -import pcgen.persistence.LoadContext; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.AbstractTokenTestCase; - -public abstract class AbstractItemTokenTestCase<T extends PObject, TC extends PObject> - extends AbstractTokenTestCase<T> -{ - - public abstract Class<TC> getTargetClass(); - - @Test - public void testInvalidInputString() throws PersistenceLayerException - { - assertTrue(getToken().parse(primaryContext, primaryProf, "String")); - assertFalse(primaryContext.ref.validate()); - } - - @Test - public void testInvalidInputType() throws PersistenceLayerException - { - assertTrue(getToken().parse(primaryContext, primaryProf, "TestType")); - assertFalse(primaryContext.ref.validate()); - } - - @Test - public void testInvalidInputJoinedComma() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TestWP1,TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - - @Test - public void testInvalidInputJoinedPipe() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TestWP1|TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - - @Test - public void testInvalidInputJoinedDot() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TestWP1.TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - - // FIXME These are invalid due to RC being overly protective at the moment - // @Test - // public void testInvalidInputAll() - // { - // assertTrue(getToken().parse(primaryContext, primaryProf, "ALL")); - // assertFalse(primaryContext.ref.validate()); - // } - // - // @Test - // public void testInvalidInputAny() - // { - // assertTrue(getToken().parse(primaryContext, primaryProf, "ANY")); - // assertFalse(primaryContext.ref.validate()); - // } - // @Test - // public void testInvalidInputCheckType() - // { - // if (!isTypeLegal()) - // { - // assertTrue(token.parse(primaryContext, primaryProf, "TYPE=TestType")); - // assertFalse(primaryContext.ref.validate()); - // } - // } - // - - @Test - public void testValidInputs() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - assertTrue(getToken().parse(primaryContext, primaryProf, "TestWP1")); - assertTrue(primaryContext.ref.validate()); - } - - @Test - public void testRoundRobinOne() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - construct(secondaryContext, "TestWP1"); - runRoundRobin("TestWP1"); - assertTrue(primaryContext.ref.validate()); - assertTrue(secondaryContext.ref.validate()); - } - - protected void construct(LoadContext loadContext, String one) - { - loadContext.ref.constructCDOMObject(getTargetClass(), one); - } -} Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractListTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractListTokenTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractListTokenTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,340 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import org.junit.Test; - -import pcgen.core.PObject; -import pcgen.persistence.LoadContext; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.AbstractTokenTestCase; - -public abstract class AbstractListTokenTestCase<T extends PObject, TC extends PObject> - extends AbstractTokenTestCase<T> -{ - - public abstract Class<TC> getTargetClass(); - - public abstract boolean isTypeLegal(); - - public abstract char getJoinCharacter(); - - @Test - public void testArchitecture() - { - /* - * This case is not handled well by this generic tester, and - * thus should be prohibited in this level of automation... - * - Tom Parker 2/24/2007 - */ - assertFalse(isTypeLegal() && getJoinCharacter() == '.'); - } - - @Test - public void testInvalidInputString() throws PersistenceLayerException - { - assertTrue(getToken().parse(primaryContext, primaryProf, "String")); - assertFalse(primaryContext.ref.validate()); - } - - @Test - public void testInvalidInputType() throws PersistenceLayerException - { - assertTrue(getToken().parse(primaryContext, primaryProf, "TestType")); - assertFalse(primaryContext.ref.validate()); - } - - @Test - public void testInvalidInputJoinedComma() throws PersistenceLayerException - { - if (getJoinCharacter() != ',') - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TestWP1,TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - } - - @Test - public void testInvalidInputJoinedPipe() throws PersistenceLayerException - { - if (getJoinCharacter() != '|') - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TestWP1|TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - } - - @Test - public void testInvalidInputJoinedDot() throws PersistenceLayerException - { - if (getJoinCharacter() != '.') - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TestWP1.TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - } - - @Test - public void testInvalidInputTypeEmpty() throws PersistenceLayerException - { - if (isTypeLegal()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, "TYPE=")); - } - } - - @Test - public void testInvalidInputTypeUnterminated() - throws PersistenceLayerException - { - if (isTypeLegal()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "TYPE=One.")); - } - } - - @Test - public void testInvalidInputTypeDoubleSeparator() - throws PersistenceLayerException - { - if (isTypeLegal()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "TYPE=One..Two")); - } - } - - @Test - public void testInvalidInputTypeFalseStart() - throws PersistenceLayerException - { - if (isTypeLegal()) - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "TYPE=.One")); - } - } - - //FIXME These are invalid due to RC being overly protective at the moment - // @Test - // public void testInvalidInputAll() - // { - // assertTrue(getToken().parse(primaryContext, primaryProf, "ALL")); - // assertFalse(primaryContext.ref.validate()); - // } - // - // @Test - // public void testInvalidInputAny() - // { - // assertTrue(getToken().parse(primaryContext, primaryProf, "ANY")); - // assertFalse(primaryContext.ref.validate()); - // } - // @Test - // public void testInvalidInputCheckType() - // { - // if (!isTypeLegal()) - // { - // assertTrue(token.parse(primaryContext, primaryProf, "TYPE=TestType")); - // assertFalse(primaryContext.ref.validate()); - // } - // } - // - - @Test - public void testInvalidListEnd() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - assertFalse(getToken().parse(primaryContext, primaryProf, - "TestWP1" + getJoinCharacter())); - } - - @Test - public void testInvalidListStart() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - assertFalse(getToken().parse(primaryContext, primaryProf, - getJoinCharacter() + "TestWP1")); - } - - @Test - public void testInvalidListDoubleJoin() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - assertFalse(getToken().parse(primaryContext, primaryProf, - "TestWP2" + getJoinCharacter() + getJoinCharacter() + "TestWP1")); - } - - @Test - public void testInvalidInputCheckMult() throws PersistenceLayerException - { - //Explicitly do NOT build TestWP2 - construct(primaryContext, "TestWP1"); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TestWP1" + getJoinCharacter() + "TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - - @Test - public void testInvalidInputCheckTypeEqualLength() - throws PersistenceLayerException - { - //Explicitly do NOT build TestWP2 (this checks that the TYPE= doesn't consume the | - if (isTypeLegal()) - { - construct(primaryContext, "TestWP1"); - assertTrue(getToken().parse( - primaryContext, - primaryProf, - "TestWP1" + getJoinCharacter() + "TYPE=TestType" - + getJoinCharacter() + "TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - } - - @Test - public void testInvalidInputCheckTypeDotLength() - throws PersistenceLayerException - { - //Explicitly do NOT build TestWP2 (this checks that the TYPE= doesn't consume the | - if (isTypeLegal()) - { - construct(primaryContext, "TestWP1"); - assertTrue(getToken().parse( - primaryContext, - primaryProf, - "TestWP1" + getJoinCharacter() + "TYPE.TestType.OtherTestType" - + getJoinCharacter() + "TestWP2")); - assertFalse(primaryContext.ref.validate()); - } - } - - @Test - public void testValidInputs() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - assertTrue(getToken().parse(primaryContext, primaryProf, "TestWP1")); - assertTrue(primaryContext.ref.validate()); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TestWP1" + getJoinCharacter() + "TestWP2")); - assertTrue(primaryContext.ref.validate()); - if (isTypeLegal()) - { - assertTrue(getToken().parse(primaryContext, primaryProf, - "TYPE=TestType")); - assertTrue(primaryContext.ref.validate()); - assertTrue(getToken().parse(primaryContext, primaryProf, - "TYPE.TestType")); - assertTrue(primaryContext.ref.validate()); - assertTrue(getToken().parse( - primaryContext, - primaryProf, - "TestWP1" + getJoinCharacter() + "TestWP2" + getJoinCharacter() - + "TYPE=TestType")); - assertTrue(primaryContext.ref.validate()); - assertTrue(getToken().parse( - primaryContext, - primaryProf, - "TestWP1" + getJoinCharacter() + "TestWP2" + getJoinCharacter() - + "TYPE=TestType.OtherTestType")); - assertTrue(primaryContext.ref.validate()); - } - } - - @Test - public void testRoundRobinOne() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - construct(secondaryContext, "TestWP1"); - construct(secondaryContext, "TestWP2"); - runRoundRobin("TestWP1"); - assertTrue(primaryContext.ref.validate()); - assertTrue(secondaryContext.ref.validate()); - } - - @Test - public void testRoundRobinThree() throws PersistenceLayerException - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - construct(primaryContext, "TestWP3"); - construct(secondaryContext, "TestWP1"); - construct(secondaryContext, "TestWP2"); - construct(secondaryContext, "TestWP3"); - runRoundRobin("TestWP1" + getJoinCharacter() + "TestWP2" - + getJoinCharacter() + "TestWP3"); - assertTrue(primaryContext.ref.validate()); - assertTrue(secondaryContext.ref.validate()); - } - - @Test - public void testRoundRobinWithEqualType() throws PersistenceLayerException - { - if (isTypeLegal()) - { - construct(primaryContext, "TestWP1"); - construct(primaryContext, "TestWP2"); - construct(secondaryContext, "TestWP1"); - construct(secondaryContext, "TestWP2"); - runRoundRobin("TestWP1" + getJoinCharacter() + "TestWP2" - + getJoinCharacter() + "TYPE=OtherTestType" - + getJoinCharacter() + "TYPE=TestType"); - assertTrue(primaryContext.ref.validate()); - assertTrue(secondaryContext.ref.validate()); - } - } - - @Test - public void testRoundRobinTestEquals() throws PersistenceLayerException - { - if (isTypeLegal()) - { - runRoundRobin("TYPE=TestType"); - assertTrue(primaryContext.ref.validate()); - assertTrue(secondaryContext.ref.validate()); - } - } - - @Test - public void testRoundRobinTestEqualThree() throws PersistenceLayerException - { - if (isTypeLegal()) - { - runRoundRobin("TYPE=TestAltType.TestThirdType.TestType"); - assertTrue(primaryContext.ref.validate()); - assertTrue(secondaryContext.ref.validate()); - } - } - - protected void construct(LoadContext loadContext, String one) - { - loadContext.ref.constructCDOMObject(getTargetClass(), one); - } -} Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractStringTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractStringTokenTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractStringTokenTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,81 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import org.junit.Test; - -import pcgen.cdom.enumeration.StringKey; -import pcgen.core.PObject; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.AbstractTokenTestCase; - -public abstract class AbstractStringTokenTestCase<T extends PObject> extends - AbstractTokenTestCase<T> -{ - - @Test - public void testValidInputs() throws PersistenceLayerException - { - assertTrue(getToken().parse(primaryContext, primaryProf, - "Nieder\xF6sterreich")); - assertEquals("Nieder\xF6sterreich", primaryProf.get(getStringKey())); - assertTrue(getToken() - .parse(primaryContext, primaryProf, "Finger Lakes")); - assertEquals("Finger Lakes", primaryProf.get(getStringKey())); - assertTrue(getToken().parse(primaryContext, primaryProf, "Rheinhessen")); - assertEquals("Rheinhessen", primaryProf.get(getStringKey())); - assertTrue(getToken().parse(primaryContext, primaryProf, - "Languedoc-Roussillon")); - assertEquals("Languedoc-Roussillon", primaryProf.get(getStringKey())); - assertTrue(getToken() - .parse(primaryContext, primaryProf, "Yarra Valley")); - assertEquals("Yarra Valley", primaryProf.get(getStringKey())); - } - - public abstract StringKey getStringKey(); - - @Test - public void testRoundRobinBase() throws PersistenceLayerException - { - runRoundRobin("Rheinhessen"); - } - - @Test - public void testRoundRobinWithSpace() throws PersistenceLayerException - { - runRoundRobin("Finger Lakes"); - } - - @Test - public void testRoundRobinNonEnglishAndN() throws PersistenceLayerException - { - runRoundRobin("Nieder\xF6sterreich"); - } - - @Test - public void testRoundRobinHyphen() throws PersistenceLayerException - { - runRoundRobin("Languedoc-Roussillon"); - } - - @Test - public void testRoundRobinY() throws PersistenceLayerException - { - runRoundRobin("Yarra Valley"); - } -} Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractTextPropertyTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractTextPropertyTokenTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractTextPropertyTokenTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,183 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import java.net.URISyntaxException; - -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; - -import pcgen.core.PObject; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.AbstractTokenTestCase; -import plugin.pretokens.parser.PreClassParser; -import plugin.pretokens.parser.PreLevelParser; -import plugin.pretokens.writer.PreClassWriter; -import plugin.pretokens.writer.PreLevelWriter; - -public abstract class AbstractTextPropertyTokenTestCase<T extends PObject> - extends AbstractTokenTestCase<T> -{ - - private static boolean classSetUpFired = false; - - @BeforeClass - public static final void localClassSetUp() throws URISyntaxException, - PersistenceLayerException - { - TokenRegistration.register(new PreLevelParser()); - TokenRegistration.register(new PreClassParser()); - TokenRegistration.register(new PreLevelWriter()); - TokenRegistration.register(new PreClassWriter()); - classSetUpFired = true; - } - - @Override - @Before - public void setUp() throws PersistenceLayerException, URISyntaxException - { - super.setUp(); - if (!classSetUpFired) - { - localClassSetUp(); - } - } - - @Test - public void testInvalidEmpty() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, "")); - } - - @Test - public void testInvalidPipeOnly() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, "|")); - } - - @Test - public void testInvalidEndsPipe() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "Yarra Valley|")); - } - - @Test - public void testInvalidStartsPipe() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "|Yarra Valley")); - } - - @Test - public void testInvalidDoublePipe() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "Yarra Valley||Rheinhessen")); - } - - @Test - public void testInvalidEmbeddedNotPre() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "Yarra Valley|!PRELEVEL:3|Rheinhessen")); - } - - @Test - public void testInvalidBadPre() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "Yarra Valley|Rheinhessen|PREFOO:3")); - } - - @Test - public void testInvalidNotBadPre() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "Yarra Valley|Rheinhessen|!PREFOO:3")); - } - - @Test - public void testInvalidEmbeddedPre() throws PersistenceLayerException - { - assertFalse(getToken().parse(primaryContext, primaryProf, - "Yarra Valley|PRELEVEL:4|Rheinhessen")); - } - - @Test - public void testRoundRobinBase() throws PersistenceLayerException - { - runRoundRobin("Rheinhessen"); - } - - @Test - public void testRoundRobinWithSpace() throws PersistenceLayerException - { - runRoundRobin("Finger Lakes"); - } - - @Test - public void testRoundRobinNonEnglishAndN() throws PersistenceLayerException - { - runRoundRobin("Nieder\xF6sterreich"); - } - - @Test - public void testRoundRobinHyphen() throws PersistenceLayerException - { - runRoundRobin("Languedoc-Roussillon"); - } - - @Test - public void testRoundRobinY() throws PersistenceLayerException - { - runRoundRobin("Yarra Valley"); - } - - @Test - public void testRoundRobinVariable() throws PersistenceLayerException - { - runRoundRobin("Rheinhessen|Variable"); - } - - @Test - public void testRoundRobinThreeVariable() throws PersistenceLayerException - { - runRoundRobin("Rheinhessen|VarOne|VarTwo|VarThree"); - } - - @Test - public void testRoundRobinPre() throws PersistenceLayerException - { - runRoundRobin("Rheinhessen|VarOne|VarTwo|PRELEVEL:5"); - } - - @Test - public void testRoundRobinNotPre() throws PersistenceLayerException - { - runRoundRobin("Rheinhessen|VarOne|VarTwo|!PRELEVEL:5"); - } - - @Test - public void testRoundRobinDoublePre() throws PersistenceLayerException - { - runRoundRobin("Rheinhessen|VarOne|VarTwo|PRELEVEL:5|PRECLASS:1,Fighter=1"); - } - -} Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractTokenTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,144 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import java.net.URI; -import java.net.URISyntaxException; - -import junit.framework.TestCase; - -import org.junit.Before; -import org.junit.BeforeClass; - -import pcgen.cdom.graph.PCGenGraph; -import pcgen.core.Campaign; -import pcgen.core.PObject; -import pcgen.persistence.LoadContext; -import pcgen.persistence.PersistenceLayerException; -import pcgen.persistence.lst.CDOMToken; -import pcgen.persistence.lst.CampaignSourceEntry; -import pcgen.persistence.lst.LstObjectFileLoader; -import pcgen.persistence.lst.LstToken; -import pcgen.persistence.lst.TokenStore; - -public abstract class AbstractTokenTestCase<T extends PObject> extends TestCase -{ - protected PCGenGraph primaryGraph; - protected PCGenGraph secondaryGraph; - protected LoadContext primaryContext; - protected LoadContext secondaryContext; - protected T primaryProf; - protected T secondaryProf; - - private static boolean classSetUpFired = false; - protected static CampaignSourceEntry testCampaign; - - @BeforeClass - public static final void classSetUp() throws URISyntaxException - { - testCampaign = - new CampaignSourceEntry(new Campaign(), new URI( - "file:/Test%20Case")); - classSetUpFired = true; - } - - @Override - @Before - public void setUp() throws PersistenceLayerException, URISyntaxException - { - if (!classSetUpFired) - { - classSetUp(); - } - // Yea, this causes warnings... - TokenRegistration.register(getToken()); - primaryGraph = new PCGenGraph(); - secondaryGraph = new PCGenGraph(); - primaryContext = new LoadContext(primaryGraph); - secondaryContext = new LoadContext(secondaryGraph); - primaryProf = - primaryContext.ref.constructCDOMObject(getCDOMClass(), - "TestObj"); - secondaryProf = - secondaryContext.ref.constructCDOMObject(getCDOMClass(), - "TestObj"); - } - - public abstract Class<T> getCDOMClass(); - - public static void addToken(LstToken tok) - { - TokenStore.inst().addToTokenMap(tok); - } - - public void runRoundRobin(String... str) throws PersistenceLayerException - { - // Default is not to write out anything - assertNull(getToken().unparse(primaryContext, primaryProf)); - // Ensure the graphs are the same at the start - assertEquals(primaryGraph, secondaryGraph); - - // Set value - for (String s : str) - { - assertTrue(getToken().parse(primaryContext, primaryProf, s)); - } - // Get back the appropriate token: - String[] unparsed = getToken().unparse(primaryContext, primaryProf); - - assertEquals(str.length, unparsed.length); - - for (int i = 0; i < str.length; i++) - { - assertEquals("Expected " + i + " item to be equal", str[i], - unparsed[i]); - } - - // Do round Robin - StringBuilder unparsedBuilt = new StringBuilder(); - for (String s : unparsed) - { - unparsedBuilt.append(getToken().getTokenName()).append(':').append( - s).append('\t'); - } - getLoader().parseLine(secondaryContext, secondaryProf, - "TestObj\t" + unparsedBuilt.toString(), testCampaign); - - // Ensure the objects are the same - assertEquals(primaryProf, secondaryProf); - - // Ensure the graphs are the same - assertEquals(primaryGraph, secondaryGraph); - - // And that it comes back out the same again - String[] sUnparsed = - getToken().unparse(secondaryContext, secondaryProf); - assertEquals(unparsed.length, sUnparsed.length); - - for (int i = 0; i < unparsed.length; i++) - { - assertEquals("Expected " + i + " item to be equal", unparsed[i], - sUnparsed[i]); - } - } - - public abstract LstObjectFileLoader<T> getLoader(); - - public abstract CDOMToken<T> getToken(); - -} Deleted: branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeListTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeListTestCase.java 2007-03-13 20:28:17 UTC (rev 2497) +++ branches/cdom/code/src/test/plugin/lsttokens/AbstractTypeSafeListTestCase.java 2007-03-13 22:29:50 UTC (rev 2498) @@ -1,205 +0,0 @@ -/* - * Copyright (c) 2007 Tom Parker <th...@us...> - * - * This program is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package plugin.lsttokens; - -import java.util.List; - -import org.junit.Test; - -import pcgen.cdom.enumeration.ListKey; -import pcgen.core.PObject; -import pcgen.persistence.PersistenceLayerException; -import plugin.lsttokens.AbstractTokenTestCase; - -public abstract class AbstractTypeSafeListTestCase<T extends PObject> extends - AbstractTokenTestCase<T> -{ - - public abstract Object getConstant(String string); - - public abstract char getJoinCharacter(); - - public abstract ListKey<?> getListKey(); - - @Test - public void testValidInputSimple() throws PersistenceLayerException - { - List<?> coll; - assertTrue(getToken().parse(primaryContext, primaryProf, "Rheinhessen")); - coll = primaryProf.getListFor(getListKey()); - assertEquals(1, coll.size()); - assertTrue(coll.contains(getConstant("Rheinhessen"))); - } - - @Test - public... [truncated message content] |
From: <th...@us...> - 2007-03-14 01:08:07
|
Revision: 2501 http://svn.sourceforge.net/pcgen/?rev=2501&view=rev Author: thpr Date: 2007-03-13 18:08:07 -0700 (Tue, 13 Mar 2007) Log Message: ----------- CDOM: Add some ADD SubToken Tests & associated code fixes Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/base/CDOMCompoundReference.java branches/cdom/code/src/java/pcgen/cdom/base/Restriction.java branches/cdom/code/src/java/pcgen/cdom/restriction/CompoundRestriction.java branches/cdom/code/src/java/pcgen/cdom/restriction/FollowerRestriction.java branches/cdom/code/src/java/pcgen/persistence/CategorizedReferenceContext.java branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java branches/cdom/code/src/java/pcgen/persistence/lst/AddLstToken.java branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java branches/cdom/code/src/java/plugin/lsttokens/AddLst.java branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java branches/cdom/code/src/java/plugin/lsttokens/add/DotClearToken.java branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java branches/cdom/code/src/java/plugin/lsttokens/add/TemplateToken.java branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java Added Paths: ----------- branches/cdom/code/src/test/plugin/lsttokens/add/ branches/cdom/code/src/test/plugin/lsttokens/add/AbstractAddTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/add/EquipTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/LanguageTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/SkillTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/TemplateTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/VFeatTokenTest.java Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMCompoundReference.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMCompoundReference.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMCompoundReference.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -19,6 +19,8 @@ import java.util.ArrayList; +import pcgen.cdom.util.ReferenceUtilities; + public class CDOMCompoundReference<T extends PrereqObject> extends CDOMGroupRef<T> { @@ -57,8 +59,7 @@ @Override public String getLSTformat() { - // FIXME Auto-generated method stub - return null; + return ReferenceUtilities.joinLstFormat(references, Constants.COMMA); } @Override Modified: branches/cdom/code/src/java/pcgen/cdom/base/Restriction.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/Restriction.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/pcgen/cdom/base/Restriction.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -24,4 +24,6 @@ boolean qualifies(T o); + String toLSTform(); + } Modified: branches/cdom/code/src/java/pcgen/cdom/restriction/CompoundRestriction.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/restriction/CompoundRestriction.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/pcgen/cdom/restriction/CompoundRestriction.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -98,4 +98,10 @@ return restrictedClass; } + public String toLSTform() + { + // TODO Auto-generated method stub + return null; + } + } Modified: branches/cdom/code/src/java/pcgen/cdom/restriction/FollowerRestriction.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/restriction/FollowerRestriction.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/pcgen/cdom/restriction/FollowerRestriction.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -52,4 +52,10 @@ { return Follower.class; } + + public String toLSTform() + { + // TODO Auto-generated method stub + return null; + } } Modified: branches/cdom/code/src/java/pcgen/persistence/CategorizedReferenceContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/CategorizedReferenceContext.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/pcgen/persistence/CategorizedReferenceContext.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -383,10 +383,13 @@ boolean returnGood = true; for (Class cl : referenced.getKeySet()) { + System.err.println(cl); for (Category cat : referenced.getSecondaryKeySet(cl)) { + System.err.println(cat); for (String s : referenced.getTertiaryKeySet(cl, cat)) { + System.err.println(s); if (!active.containsKey(cl, cat, s)) { Logging.errorPrint("Unconstructed Reference: " Modified: branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -25,6 +25,8 @@ */ package pcgen.persistence.lst; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import pcgen.base.util.Logging; @@ -42,7 +44,7 @@ super(); } - public static boolean parseLine(LoadContext context, CDOMObject obj, + public static boolean parseLine(LoadContext context, PObject obj, String value) throws PersistenceLayerException { Map<String, LstToken> tokenMap = @@ -65,6 +67,7 @@ { Logging.errorPrint("Error parsing ADD in " + obj.getDisplayName() + ':' + value); + return false; } } else @@ -105,4 +108,22 @@ return false; } } + + public static String[] unparse(LoadContext context, CDOMObject obj) + { + List<String> list = new ArrayList<String>(); + for (LstToken token : TokenStore.inst().getTokenMap(AddLstToken.class) + .values()) + { + String[] s = ((AddLstToken) token).unparse(context, (PObject) obj); + if (s != null) + { + for (String aString : s) + { + list.add(token.getTokenName() + "|" + aString); + } + } + } + return list.size() == 0 ? null : list.toArray(new String[list.size()]); + } } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/AddLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/AddLstToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/pcgen/persistence/lst/AddLstToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -25,20 +25,14 @@ */ package pcgen.persistence.lst; -import pcgen.cdom.base.CDOMObject; import pcgen.core.PObject; -import pcgen.persistence.LoadContext; -import pcgen.persistence.PersistenceLayerException; /** * <code>AutoLstToken</code> * * @author Thomas Parker <th...@us...> */ -public interface AddLstToken extends LstToken +public interface AddLstToken extends CDOMToken<PObject> { public boolean parse(PObject target, String value, int level); - - public boolean parse(LoadContext context, CDOMObject obj, String value) - throws PersistenceLayerException; } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -147,7 +147,32 @@ else if (s.startsWith(Constants.LST_TYPE_OLD) || s.startsWith(Constants.LST_TYPE)) { - String[] types = s.substring(5).split("\\."); + String subStr = s.substring(5); + if (subStr.length() == 0) + { + Logging.errorPrint("Type may not be empty in: " + s); + return null; + } + if (subStr.charAt(0) == '.' + || subStr.charAt(subStr.length() - 1) == '.') + { + Logging.errorPrint("Type may not start or end with . in: " + s); + return null; + } + String[] types = subStr.split("\\."); + for (String type : types) + { + /* + * TODO May be faster to just look for .. in the input string - + * make sure to do this in the uncategorized version too. + */ + if (type.length() == 0) + { + Logging + .errorPrint("Attempt to acquire empty Type in: " + s); + return null; + } + } return context.ref.getCategorizedCDOMTypeReference(cl, cat, types); } else Modified: branches/cdom/code/src/java/plugin/lsttokens/AddLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/AddLst.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/AddLst.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -167,14 +167,11 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) throws PersistenceLayerException { - //FIXME This is a hack - return true; - //return AddLoader.parseLine(context, obj, value); + return AddLoader.parseLine(context, (PObject) obj, value); } public String[] unparse(LoadContext context, CDOMObject obj) { - // TODO Auto-generated method stub - return null; + return AddLoader.unparse(context, obj); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,6 +1,5 @@ package plugin.lsttokens.add; -import pcgen.cdom.base.CDOMObject; import pcgen.core.Constants; import pcgen.core.PCClass; import pcgen.core.PObject; @@ -49,10 +48,16 @@ return "CLASSSKILLS"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { // FIXME This is a hack return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + // TODO Auto-generated method stub + return null; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/DotClearToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/DotClearToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/DotClearToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,6 +1,5 @@ package plugin.lsttokens.add; -import pcgen.cdom.base.CDOMObject; import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; @@ -34,13 +33,19 @@ public String getTokenName() { - return "VFEAT"; + return ".CLEAR"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { // FIXME This is a hack return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + // TODO Auto-generated method stub + return null; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,18 +1,23 @@ package plugin.lsttokens.add; +import java.util.List; +import java.util.Set; import java.util.StringTokenizer; import pcgen.cdom.base.CDOMCompoundReference; -import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; import pcgen.cdom.base.Slot; +import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Equipment; import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; public class EquipToken implements AddLstToken @@ -50,7 +55,7 @@ return "EQUIP"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { int pipeLoc = value.indexOf(Constants.PIPE); @@ -67,6 +72,12 @@ try { count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } } catch (NumberFormatException nfe) { @@ -88,21 +99,66 @@ while (tok.hasMoreTokens()) { String token = tok.nextToken(); - if (token.startsWith(Constants.LST_TYPE_OLD) - || token.startsWith(Constants.LST_TYPE)) + CDOMReference<Equipment> ref = + TokenUtilities.getObjectReference(context, EQUIPMENT_CLASS, + token); + if (ref == null) { - String[] types = token.substring(5).split("\\."); - cr.addReference(context.ref.getCDOMTypeReference( - EQUIPMENT_CLASS, types)); + return false; } - else - { - cr.addReference(context.ref.getCDOMReference(EQUIPMENT_CLASS, - token)); - } + cr.addReference(ref); } + slot.addSinkRestriction(new GroupRestriction<Equipment>( EQUIPMENT_CLASS, cr)); + // FIXME Slot needs to know AbilityNature.NORMAL ?? + return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + if (links.size() > 1) + { + context.addWriteMessage("Invalid Slot Count " + links.size() + + " associated with " + getTokenName() + + ": Only one Slot allowed."); + return null; + } + PCGraphEdge edge = links.iterator().next(); + Slot<Equipment> slot = (Slot<Equipment>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(EQUIPMENT_CLASS)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + String result; + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + if ("1".equals(slotCount)) + { + result = res.toLSTform(); + } + else + { + result = slotCount + "|" + res.toLSTform(); + } + return new String[]{result}; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,21 +1,24 @@ package plugin.lsttokens.add; +import java.util.List; +import java.util.Set; import java.util.StringTokenizer; import pcgen.cdom.base.CDOMCompoundReference; -import pcgen.cdom.base.CDOMGroupRef; -import pcgen.cdom.base.CDOMObject; -import pcgen.cdom.base.CDOMSingleRef; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; import pcgen.cdom.base.Slot; import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Ability; import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; public class FeatToken implements AddLstToken @@ -53,7 +56,7 @@ return "FEAT"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { int pipeLoc = value.indexOf(Constants.PIPE); @@ -70,6 +73,12 @@ try { count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } } catch (NumberFormatException nfe) { @@ -91,28 +100,66 @@ while (tok.hasMoreTokens()) { String token = tok.nextToken(); - if (token.startsWith(Constants.LST_TYPE_OLD) - || token.startsWith(Constants.LST_TYPE)) + CDOMReference<Ability> ref = + TokenUtilities.getObjectReference(context, Ability.class, + AbilityCategory.FEAT, token); + if (ref == null) { - String[] types = token.substring(5).split("\\."); - CDOMGroupRef<Ability> ref = - context.ref.getCategorizedCDOMTypeReference( - ABILITY_CLASS, AbilityCategory.FEAT, types); - cr.addReference(ref); + return false; } - else - { - CDOMSingleRef<Ability> ref = - context.ref.getCDOMReference(ABILITY_CLASS, - AbilityCategory.FEAT, token); - cr.addReference(ref); - } + cr.addReference(ref); } slot .addSinkRestriction(new GroupRestriction<Ability>(ABILITY_CLASS, cr)); // FIXME Slot needs to know AbilityNature.NORMAL ?? - return false; + return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + if (links.size() > 1) + { + context.addWriteMessage("Invalid Slot Count " + links.size() + + " associated with " + getTokenName() + + ": Only one Slot allowed."); + return null; + } + PCGraphEdge edge = links.iterator().next(); + Slot<Ability> slot = (Slot<Ability>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(ABILITY_CLASS)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + String result; + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + if ("1".equals(slotCount)) + { + result = res.toLSTform(); + } + else + { + result = slotCount + "|" + res.toLSTform(); + } + return new String[]{result}; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,18 +1,23 @@ package plugin.lsttokens.add; +import java.util.List; +import java.util.Set; import java.util.StringTokenizer; import pcgen.cdom.base.CDOMCompoundReference; -import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; import pcgen.cdom.base.Slot; +import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Language; import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; public class LanguageToken implements AddLstToken @@ -50,7 +55,7 @@ return "LANGUAGE"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { int pipeLoc = value.indexOf(Constants.PIPE); @@ -67,6 +72,12 @@ try { count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } } catch (NumberFormatException nfe) { @@ -88,21 +99,66 @@ while (tok.hasMoreTokens()) { String token = tok.nextToken(); - if (token.startsWith(Constants.LST_TYPE_OLD) - || token.startsWith(Constants.LST_TYPE)) + CDOMReference<Language> ref = + TokenUtilities.getObjectReference(context, LANGUAGE_CLASS, + token); + if (ref == null) { - String[] types = token.substring(5).split("\\."); - cr.addReference(context.ref.getCDOMTypeReference( - LANGUAGE_CLASS, types)); + return false; } - else - { - cr.addReference(context.ref.getCDOMReference(LANGUAGE_CLASS, - token)); - } + cr.addReference(ref); } + slot.addSinkRestriction(new GroupRestriction<Language>(LANGUAGE_CLASS, cr)); + // FIXME Slot needs to know AbilityNature.NORMAL ?? + return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + if (links.size() > 1) + { + context.addWriteMessage("Invalid Slot Count " + links.size() + + " associated with " + getTokenName() + + ": Only one Slot allowed."); + return null; + } + PCGraphEdge edge = links.iterator().next(); + Slot<Language> slot = (Slot<Language>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(LANGUAGE_CLASS)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + String result; + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + if ("1".equals(slotCount)) + { + result = res.toLSTform(); + } + else + { + result = slotCount + "|" + res.toLSTform(); + } + return new String[]{result}; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,6 +1,5 @@ package plugin.lsttokens.add; -import pcgen.cdom.base.CDOMObject; import pcgen.core.Constants; import pcgen.core.PObject; import pcgen.persistence.LoadContext; @@ -44,10 +43,16 @@ return "SA"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { // FIXME This is a hack return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + // TODO Auto-generated method stub + return null; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,18 +1,23 @@ package plugin.lsttokens.add; +import java.util.List; +import java.util.Set; import java.util.StringTokenizer; import pcgen.cdom.base.CDOMCompoundReference; -import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; import pcgen.cdom.base.Slot; +import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.PObject; import pcgen.core.Skill; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; public class SkillToken implements AddLstToken @@ -51,7 +56,7 @@ return "SKILL"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { int pipeLoc = value.indexOf(Constants.PIPE); @@ -68,6 +73,12 @@ try { count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } } catch (NumberFormatException nfe) { @@ -89,21 +100,65 @@ while (tok.hasMoreTokens()) { String token = tok.nextToken(); - if (token.startsWith(Constants.LST_TYPE_OLD) - || token.startsWith(Constants.LST_TYPE)) + CDOMReference<Skill> ref = + TokenUtilities.getObjectReference(context, SKILL_CLASS, + token); + if (ref == null) { - String[] types = token.substring(5).split("\\."); - cr.addReference(context.ref.getCDOMTypeReference(SKILL_CLASS, - types)); + return false; } - else - { - cr.addReference(context.ref - .getCDOMReference(SKILL_CLASS, token)); - } + cr.addReference(ref); } + slot.addSinkRestriction(new GroupRestriction<Skill>(SKILL_CLASS, cr)); + // FIXME Slot needs to know AbilityNature.NORMAL ?? return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + if (links.size() > 1) + { + context.addWriteMessage("Invalid Slot Count " + links.size() + + " associated with " + getTokenName() + + ": Only one Slot allowed."); + return null; + } + PCGraphEdge edge = links.iterator().next(); + Slot<Skill> slot = (Slot<Skill>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(SKILL_CLASS)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + String result; + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + if ("1".equals(slotCount)) + { + result = res.toLSTform(); + } + else + { + result = slotCount + "|" + res.toLSTform(); + } + return new String[]{result}; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,6 +1,5 @@ package plugin.lsttokens.add; -import pcgen.cdom.base.CDOMObject; import pcgen.core.Constants; import pcgen.core.PObject; import pcgen.persistence.LoadContext; @@ -42,10 +41,16 @@ return "SPELLCASTER"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { // FIXME This is a hack return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + // TODO Auto-generated method stub + return null; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,6 +1,5 @@ package plugin.lsttokens.add; -import pcgen.cdom.base.CDOMObject; import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; @@ -20,10 +19,16 @@ return "SPELLLEVEL"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { // FIXME This is a hack return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + // TODO Auto-generated method stub + return null; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/TemplateToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/TemplateToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/TemplateToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,11 +1,14 @@ package plugin.lsttokens.add; +import java.util.List; +import java.util.Set; import java.util.StringTokenizer; import pcgen.cdom.base.CDOMCompoundReference; -import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; import pcgen.cdom.base.Slot; +import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Constants; import pcgen.core.PCTemplate; @@ -51,7 +54,7 @@ return "TEMPLATE"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { int pipeLoc = value.indexOf(Constants.PIPE); @@ -68,6 +71,12 @@ try { count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } } catch (NumberFormatException nfe) { @@ -94,6 +103,52 @@ slot.addSinkRestriction(new GroupRestriction<PCTemplate>( PCTEMPLATE_CLASS, cr)); - return false; + return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + if (links.size() > 1) + { + context.addWriteMessage("Invalid Slot Count " + links.size() + + " associated with " + getTokenName() + + ": Only one Slot allowed."); + return null; + } + PCGraphEdge edge = links.iterator().next(); + Slot<PCTemplate> slot = (Slot<PCTemplate>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(PCTEMPLATE_CLASS)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + String result; + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + if ("1".equals(slotCount)) + { + result = res.toLSTform(); + } + else + { + result = slotCount + "|" + res.toLSTform(); + } + return new String[]{result}; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java 2007-03-13 23:37:51 UTC (rev 2500) +++ branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -1,21 +1,24 @@ package plugin.lsttokens.add; +import java.util.List; +import java.util.Set; import java.util.StringTokenizer; import pcgen.cdom.base.CDOMCompoundReference; -import pcgen.cdom.base.CDOMGroupRef; -import pcgen.cdom.base.CDOMObject; -import pcgen.cdom.base.CDOMSingleRef; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; import pcgen.cdom.base.Slot; import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Ability; import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; public class VFeatToken implements AddLstToken @@ -53,7 +56,7 @@ return "VFEAT"; } - public boolean parse(LoadContext context, CDOMObject obj, String value) + public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { int pipeLoc = value.indexOf(Constants.PIPE); @@ -70,6 +73,12 @@ try { count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } } catch (NumberFormatException nfe) { @@ -91,28 +100,66 @@ while (tok.hasMoreTokens()) { String token = tok.nextToken(); - if (token.startsWith(Constants.LST_TYPE_OLD) - || token.startsWith(Constants.LST_TYPE)) + CDOMReference<Ability> ref = + TokenUtilities.getObjectReference(context, Ability.class, + AbilityCategory.FEAT, token); + if (ref == null) { - String[] types = token.substring(5).split("\\."); - CDOMGroupRef<Ability> ref = - context.ref.getCategorizedCDOMTypeReference( - ABILITY_CLASS, AbilityCategory.FEAT, types); - cr.addReference(ref); + return false; } - else - { - CDOMSingleRef<Ability> ref = - context.ref.getCDOMReference(ABILITY_CLASS, - AbilityCategory.FEAT, token); - cr.addReference(ref); - } + cr.addReference(ref); } slot .addSinkRestriction(new GroupRestriction<Ability>(ABILITY_CLASS, cr)); // FIXME Slot needs to know AbilityNature.VIRTUAL ?? - return false; + return true; } + + public String[] unparse(LoadContext context, PObject obj) + { + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + if (links.size() > 1) + { + context.addWriteMessage("Invalid Slot Count " + links.size() + + " associated with " + getTokenName() + + ": Only one Slot allowed."); + return null; + } + PCGraphEdge edge = links.iterator().next(); + Slot<Ability> slot = (Slot<Ability>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(ABILITY_CLASS)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + String result; + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + if ("1".equals(slotCount)) + { + result = res.toLSTform(); + } + else + { + result = slotCount + "|" + res.toLSTform(); + } + return new String[]{result}; + } } Added: branches/cdom/code/src/test/plugin/lsttokens/add/AbstractAddTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/AbstractAddTokenTestCase.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/AbstractAddTokenTestCase.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -0,0 +1,454 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.add; + +import java.net.URISyntaxException; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.core.PObject; +import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.GlobalLstToken; +import plugin.lsttokens.AddLst; +import plugin.lsttokens.testsupport.GlobalTokenTestCase; +import plugin.lsttokens.testsupport.TokenRegistration; + +public abstract class AbstractAddTokenTestCase extends GlobalTokenTestCase +{ + + static AddLst token = new AddLst(); + + @Override + @Before + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + TokenRegistration.register(getSubToken()); + } + + protected abstract AddLstToken getSubToken(); + + protected abstract <T extends PObject> Class<T> getSubTokenType(); + + public String getSubTokenString() + { + return getSubToken().getTokenName(); + } + + @Test + public void testInvalidInputString() throws PersistenceLayerException + { + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|String")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testInvalidInputType() throws PersistenceLayerException + { + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestType")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testInvalidInputJoinedPipe() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1|TestWP2")); + } + + @Test + public void testInvalidInputJoinedDot() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1.TestWP2")); + assertFalse(primaryContext.ref.validate()); + } + + public abstract boolean isTypeLegal(); + + @Test + public void testInvalidInputTypeEmpty() throws PersistenceLayerException + { + boolean result = + getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TYPE="); + if (isTypeLegal()) + { + assertFalse(result); + } + else + { + assertTrue(result); + assertFalse(primaryContext.ref.validate()); + } + } + + @Test + public void testInvalidInputTypeUnterminated() + throws PersistenceLayerException + { + boolean result = + getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TYPE=One."); + if (isTypeLegal()) + { + assertFalse(result); + } + else + { + assertTrue(result); + assertFalse(primaryContext.ref.validate()); + } + } + + @Test + public void testInvalidInputTypeDoubleSeparator() + throws PersistenceLayerException + { + boolean result = + getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TYPE=One..Two"); + if (isTypeLegal()) + { + assertFalse(result); + } + else + { + assertTrue(result); + assertFalse(primaryContext.ref.validate()); + } + } + + @Test + public void testInvalidInputTypeFalseStart() + throws PersistenceLayerException + { + boolean result = + getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TYPE=.One"); + if (isTypeLegal()) + { + assertFalse(result); + } + else + { + assertTrue(result); + assertFalse(primaryContext.ref.validate()); + } + } + + // FIXME These are invalid due to RC being overly protective at the moment + // @Test + // public void testInvalidInputAll() + // { + // assertTrue(getToken().parse(primaryContext, primaryProf, + // getSubTokenString() + "|ALL")); + // assertFalse(primaryContext.ref.validate()); + // } + // + // @Test + // public void testInvalidInputAny() + // { + // assertTrue(getToken().parse(primaryContext, primaryProf, + // getSubTokenString() + "|ANY")); + // assertFalse(primaryContext.ref.validate()); + // } + // @Test + // public void testInvalidInputCheckType() + // { + // if (!isTypeLegal()) + // { + // assertTrue(token.parse(primaryContext, primaryProf, + // getSubTokenString() + "|TYPE=TestType")); + // assertFalse(primaryContext.ref.validate()); + // } + // } + // + + @Test + public void testInvalidListEnd() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1|")); + } + + @Test + public void testInvalidListStart() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "||TestWP1")); + } + + @Test + public void testInvalidZeroCount() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|0|TestWP1")); + } + + @Test + public void testInvalidNegativeCount() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|-4|TestWP1")); + } + + @Test + public void testInvalidListDoubleJoin() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP2||TestWP1")); + } + + @Test + public void testInvalidInputCheckMult() throws PersistenceLayerException + { + // Explicitly do NOT build TestWP2 + construct(primaryContext, "TestWP1"); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1,TestWP2")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testInvalidInputCheckTypeEqualLength() + throws PersistenceLayerException + { + // Explicitly do NOT build TestWP2 (this checks that the TYPE= doesn't + // consume the , + construct(primaryContext, "TestWP1"); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1,TYPE=TestType,TestWP2")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testInvalidInputCheckTypeDotLength() + throws PersistenceLayerException + { + // Explicitly do NOT build TestWP2 (this checks that the TYPE= doesn't + // consume the , + construct(primaryContext, "TestWP1"); + assertTrue(getToken().parse( + primaryContext, + primaryProf, + getSubTokenString() + + "|TestWP1,TYPE.TestType.OtherTestType,TestWP2")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testValidInputs() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1,TestWP2")); + assertTrue(primaryContext.ref.validate()); + if (isTypeLegal()) + { + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TYPE=TestType")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TYPE.TestType")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1,TestWP2,TYPE=TestType")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse( + primaryContext, + primaryProf, + getSubTokenString() + + "|TestWP1,TestWP2,TYPE=TestType.OtherTestType")); + } + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|2|TestWP1,TestWP2")); + assertTrue(primaryContext.ref.validate()); + if (isTypeLegal()) + { + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|2|TYPE=TestType")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|6|TYPE.TestType")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|8|TestWP1,TestWP2,TYPE=TestType")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse( + primaryContext, + primaryProf, + getSubTokenString() + + "|3|TestWP1,TestWP2,TYPE=TestType.OtherTestType")); + assertTrue(primaryContext.ref.validate()); + } + } + + @Test + public void testRoundRobinOne() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + runRoundRobin(getSubTokenString() + "|TestWP1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinThree() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(primaryContext, "TestWP3"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + construct(secondaryContext, "TestWP3"); + runRoundRobin(getSubTokenString() + "|TestWP1,TestWP2,TestWP3"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinWithEqualType() throws PersistenceLayerException + { + if (isTypeLegal()) + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + runRoundRobin(getSubTokenString() + + "|TestWP1,TestWP2,TYPE=OtherTestType,TYPE=TestType"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + } + + @Test + public void testRoundRobinTestEquals() throws PersistenceLayerException + { + if (isTypeLegal()) + { + runRoundRobin(getSubTokenString() + "|TYPE=TestType"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + } + + @Test + public void testRoundRobinTestEqualThree() throws PersistenceLayerException + { + if (isTypeLegal()) + { + runRoundRobin(getSubTokenString() + + "|TYPE=TestAltType.TestThirdType.TestType"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + } + + @Test + public void testRoundRobinTwoCountThree() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(primaryContext, "TestWP3"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + construct(secondaryContext, "TestWP3"); + runRoundRobin(getSubTokenString() + "|2|TestWP1,TestWP2,TestWP3"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinCountThreeWithEqualType() + throws PersistenceLayerException + { + if (isTypeLegal()) + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + runRoundRobin(getSubTokenString() + + "|3|TestWP1,TestWP2,TYPE=OtherTestType,TYPE=TestType"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + } + + @Test + public void testRoundRobinCountTwoTestEquals() + throws PersistenceLayerException + { + if (isTypeLegal()) + { + runRoundRobin(getSubTokenString() + "|2|TYPE=TestType"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + } + + @Test + public void testRoundRobinCountFourTestEqualThree() + throws PersistenceLayerException + { + if (isTypeLegal()) + { + runRoundRobin(getSubTokenString() + + "|4|TYPE=TestAltType.TestThirdType.TestType"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + } + + protected void construct(LoadContext loadContext, String one) + { + loadContext.ref.constructCDOMObject(getSubTokenType(), one); + } + + @Override + public GlobalLstToken getToken() + { + return token; + } + +} Added: branches/cdom/code/src/test/plugin/lsttokens/add/EquipTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/EquipTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/EquipTokenTest.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -0,0 +1,45 @@ +package plugin.lsttokens.add; + +import pcgen.core.Equipment; +import pcgen.core.PCTemplate; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; + +public class EquipTokenTest extends AbstractAddTokenTestCase +{ + + private AddLstToken aToken = new EquipToken(); + + @Override + protected AddLstToken getSubToken() + { + return aToken; + } + + @Override + protected Class<Equipment> getSubTokenType() + { + return Equipment.class; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + public boolean isTypeLegal() + { + return true; + } +} Added: branches/cdom/code/src/test/plugin/lsttokens/add/FeatTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/FeatTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/FeatTokenTest.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -0,0 +1,55 @@ +package plugin.lsttokens.add; + +import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.core.Ability; +import pcgen.core.PCTemplate; +import pcgen.persistence.LoadContext; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; + +public class FeatTokenTest extends AbstractAddTokenTestCase +{ + + private AddLstToken aToken = new FeatToken(); + + @Override + protected AddLstToken getSubToken() + { + return aToken; + } + + @Override + protected Class<Ability> getSubTokenType() + { + return Ability.class; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + protected void construct(LoadContext loadContext, String one) + { + Ability ab = + loadContext.ref.constructCDOMObject(getSubTokenType(), one); + loadContext.ref.reassociateReference(AbilityCategory.FEAT, ab); + } + + @Override + public boolean isTypeLegal() + { + return true; + } +} Added: branches/cdom/code/src/test/plugin/lsttokens/add/LanguageTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/LanguageTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/LanguageTokenTest.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -0,0 +1,45 @@ +package plugin.lsttokens.add; + +import pcgen.core.Language; +import pcgen.core.PCTemplate; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; + +public class LanguageTokenTest extends AbstractAddTokenTestCase +{ + + private AddLstToken aToken = new LanguageToken(); + + @Override + protected AddLstToken getSubToken() + { + return aToken; + } + + @Override + protected Class<Language> getSubTokenType() + { + return Language.class; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + public boolean isTypeLegal() + { + return true; + } +} Added: branches/cdom/code/src/test/plugin/lsttokens/add/SkillTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/SkillTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/SkillTokenTest.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -0,0 +1,45 @@ +package plugin.lsttokens.add; + +import pcgen.core.PCTemplate; +import pcgen.core.Skill; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; + +public class SkillTokenTest extends AbstractAddTokenTestCase +{ + + private AddLstToken aToken = new SkillToken(); + + @Override + protected AddLstToken getSubToken() + { + return aToken; + } + + @Override + protected Class<Skill> getSubTokenType() + { + return Skill.class; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + public boolean isTypeLegal() + { + return true; + } +} Added: branches/cdom/code/src/test/plugin/lsttokens/add/TemplateTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/TemplateTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/TemplateTokenTest.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -0,0 +1,44 @@ +package plugin.lsttokens.add; + +import pcgen.core.PCTemplate; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; + +public class TemplateTokenTest extends AbstractAddTokenTestCase +{ + + private AddLstToken aToken = new TemplateToken(); + + @Override + protected AddLstToken getSubToken() + { + return aToken; + } + + @Override + protected Class<PCTemplate> getSubTokenType() + { + return PCTemplate.class; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + public boolean isTypeLegal() + { + return false; + } +} Added: branches/cdom/code/src/test/plugin/lsttokens/add/VFeatTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/VFeatTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/VFeatTokenTest.java 2007-03-14 01:08:07 UTC (rev 2501) @@ -0,0 +1,55 @@ +package plugin.lsttokens.add; + +import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.core.Ability; +import pcgen.core.PCTemplate; +import pcgen.persistence.LoadContext; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; + +public class VFeatTokenTest extends AbstractAddTokenTestCase +{ + + private AddLstToken aToken = new VFeatToken(); + + @Override + protected AddLstToken getSubToken() + { + return aToken; + } + + @Override + protected Class<Ability> getSubTokenType() + { + return Ability.class; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + protected void construct(LoadContext loadContext, String one) + { + Ability ab = + loadContext.ref.constructCDOMObject(getSubTokenType(), one); + loadContext.ref.reassociateReference(AbilityCategory.FEAT, ab); + } + + @Override + public boolean isTypeLegal() + { + return true; + } +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-03-26 22:24:03
|
Revision: 2589 http://svn.sourceforge.net/pcgen/?rev=2589&view=rev Author: thpr Date: 2007-03-26 15:24:03 -0700 (Mon, 26 Mar 2007) Log Message: ----------- CDOM: The rest of the ADD Round Robin Tests and associated code fixes Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/base/Slot.java branches/cdom/code/src/java/pcgen/cdom/content/ChoiceSet.java branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java branches/cdom/code/src/java/pcgen/core/SpellList.java branches/cdom/code/src/java/pcgen/core/SpellProgressionInfo.java branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java branches/cdom/code/src/java/pcgen/persistence/SimpleReferenceContext.java branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java branches/cdom/code/src/java/plugin/lsttokens/template/BonusskillpointsToken.java branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java branches/cdom/code/src/test/plugin/lsttokens/add/EquipTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/LanguageTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/SkillTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/TemplateTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/VFeatTokenTest.java Added Paths: ----------- branches/cdom/code/src/test/plugin/lsttokens/add/ClassSkillsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/SATokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/SpellCasterTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/add/SpellLevelTokenTest.java Removed Paths: ------------- branches/cdom/code/src/java/plugin/lsttokens/add/DotClearToken.java Modified: branches/cdom/code/src/java/pcgen/cdom/base/Slot.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/Slot.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/pcgen/cdom/base/Slot.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -22,6 +22,8 @@ public class Slot<T extends PrereqObject> extends ConcretePrereqObject { + private String name; + private final Class<T> slotClass; private final Formula slotCount; @@ -38,6 +40,16 @@ slotCount = count; } + public String getName() + { + return name; + } + + public void setName(String name) + { + this.name = name; + } + public boolean isValid(PrereqObject o) { if (!slotClass.isAssignableFrom(o.getClass())) @@ -100,6 +112,20 @@ return false; } Slot otherSlot = (Slot) o; + if (name == null) + { + if (otherSlot.name != null) + { + return false; + } + } + else + { + if (!name.equals(otherSlot.name)) + { + return false; + } + } return slotClass.equals(otherSlot.slotClass) && slotCount.equals(otherSlot.slotCount); } Modified: branches/cdom/code/src/java/pcgen/cdom/content/ChoiceSet.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/ChoiceSet.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/pcgen/cdom/content/ChoiceSet.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -74,11 +74,13 @@ set.clear(); } + @Override public int hashCode() { return set.hashCode() ^ count; } + @Override public boolean equals(Object o) { if (!(o instanceof ChoiceSet)) Modified: branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -22,11 +22,13 @@ public final class Aggregator extends CDOMObject { + private final Object aggregatorOwner; private final Object aggregatorSource; private final String aggSourceToken; - public Aggregator(Object source, String sourceToken) + public Aggregator(Object owner, Object source, String sourceToken) { + aggregatorOwner = owner; aggregatorSource = source; aggSourceToken = sourceToken; } @@ -36,7 +38,8 @@ @Override public int hashCode() { - return aggregatorSource.hashCode() ^ aggSourceToken.hashCode(); + return aggregatorOwner.hashCode() ^ aggregatorSource.hashCode() + ^ aggSourceToken.hashCode(); } @Override @@ -52,6 +55,7 @@ } Aggregator other = (Aggregator) o; return other.aggSourceToken.equals(aggSourceToken) + && other.aggregatorOwner.equals(aggregatorOwner) && other.aggregatorSource.equals(aggregatorSource) && this.isCDOMEqual(other); } Modified: branches/cdom/code/src/java/pcgen/core/SpellList.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/SpellList.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/pcgen/core/SpellList.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,9 +1,7 @@ package pcgen.core; -import pcgen.cdom.base.CDOMObject; +public class SpellList extends PObject { -public class SpellList extends CDOMObject { - // No additional Functionality :) } Modified: branches/cdom/code/src/java/pcgen/core/SpellProgressionInfo.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/SpellProgressionInfo.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/pcgen/core/SpellProgressionInfo.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -36,7 +36,9 @@ * * @author Tom Parker <th...@us...> */ -public class SpellProgressionInfo implements Cloneable { +public class SpellProgressionInfo extends PObject implements + Cloneable +{ /* * FUTURETYPESAFETY Currently can't do better than String in knownMap, Modified: branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -87,7 +87,7 @@ } } - public void constructIfNecessary(Class<WeaponProf> cl, String value) + public <T extends CDOMObject> void constructIfNecessary(Class<T> cl, String value) { simple.constructIfNecessary(cl, value); } Modified: branches/cdom/code/src/java/pcgen/persistence/SimpleReferenceContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/SimpleReferenceContext.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/pcgen/persistence/SimpleReferenceContext.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -363,7 +363,7 @@ return returnGood; } - public void constructIfNecessary(Class<WeaponProf> cl, String value) + public <T extends CDOMObject> void constructIfNecessary(Class<T> cl, String value) { /* * TODO FIXME Need to ensure that items that are built here are tagged Modified: branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -57,6 +57,10 @@ return false; } String key = value.substring(0, pipeLoc); + if (".CLEAR".equals(key)) + { + //TODO Need to perform .CLEAR + } AddLstToken token = (AddLstToken) tokenMap.get(key); @@ -91,6 +95,27 @@ { Map<String, LstToken> tokenMap = TokenStore.inst().getTokenMap(AddLstToken.class); + if (".CLEAR".equals(key)) + { + if (level > 0) + { + Logging + .errorPrint("Warning: You performed a Dangerous .CLEAR in a ADD: Token"); + Logging + .errorPrint(" A non-level limited .CLEAR was used in a Class Level line"); + Logging + .errorPrint(" Today, this performs a .CLEAR on the entire PCClass"); + Logging + .errorPrint(" However, you are using undocumented behavior that is subject to change"); + Logging.errorPrint(" Hint: It will change after PCGen 5.12"); + Logging + .errorPrint(" Please level limit the .CLEAR (e.g. .CLEAR.LEVEL2)"); + Logging + .errorPrint(" ... or put the ADD:.CLEAR on a non-level Class line"); + } + target.clearAdds(); + return true; + } AddLstToken token = (AddLstToken) tokenMap.get(key); if (token != null) { Modified: branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,16 +1,31 @@ package plugin.lsttokens.add; +import java.util.List; +import java.util.Set; +import java.util.StringTokenizer; + +import pcgen.cdom.base.CDOMCompoundReference; +import pcgen.cdom.base.CDOMReference; +import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; +import pcgen.cdom.base.Slot; +import pcgen.cdom.graph.PCGraphEdge; +import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Constants; import pcgen.core.PCClass; import pcgen.core.PObject; +import pcgen.core.Skill; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; public class ClassSkillsToken implements AddLstToken { + private static final Class<Skill> SKILL_CLASS = Skill.class; + public boolean parse(PObject target, String value, int level) { if (!target.getClass().equals(PCClass.class)) @@ -51,13 +66,109 @@ public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { - // FIXME This is a hack + int pipeLoc = value.indexOf(Constants.PIPE); + int count; + String items; + if (pipeLoc == -1) + { + count = 1; + items = value; + } + else + { + String countString = value.substring(0, pipeLoc); + try + { + count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } + } + catch (NumberFormatException nfe) + { + Logging.errorPrint("Invalid Count in ADD:" + getTokenName() + + ": " + countString); + return false; + } + items = value.substring(pipeLoc + 1); + } + + StringTokenizer tok = new StringTokenizer(items, Constants.COMMA); + + Slot<Skill> slot = + context.graph.addSlotIntoGraph(getTokenName(), obj, + SKILL_CLASS, FormulaFactory.getFormulaFor(count)); + CDOMCompoundReference<Skill> cr = + new CDOMCompoundReference<Skill>(SKILL_CLASS, getTokenName() + + " items"); + while (tok.hasMoreTokens()) + { + String token = tok.nextToken(); + CDOMReference<Skill> ref = + TokenUtilities.getObjectReference(context, SKILL_CLASS, + token); + if (ref == null) + { + return false; + } + cr.addReference(ref); + } + + /* + * BUG FIXME How do I get the ASSOCIATIONS indicating this is a CLASS + * skill, not a CROSS_CLASS skill? + */ + slot.addSinkRestriction(new GroupRestriction<Skill>(SKILL_CLASS, cr)); + return true; } public String[] unparse(LoadContext context, PObject obj) { - // TODO Auto-generated method stub - return null; + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + if (links.size() > 1) + { + context.addWriteMessage("Invalid Slot Count " + links.size() + + " associated with " + getTokenName() + + ": Only one Slot allowed."); + return null; + } + PCGraphEdge edge = links.iterator().next(); + Slot<Skill> slot = (Slot<Skill>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(SKILL_CLASS)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + String result; + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + if ("1".equals(slotCount)) + { + result = res.toLSTform(); + } + else + { + result = slotCount + "|" + res.toLSTform(); + } + return new String[]{result}; } } Deleted: branches/cdom/code/src/java/plugin/lsttokens/add/DotClearToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/DotClearToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/add/DotClearToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,51 +0,0 @@ -package plugin.lsttokens.add; - -import pcgen.core.PObject; -import pcgen.persistence.LoadContext; -import pcgen.persistence.PersistenceLayerException; -import pcgen.persistence.lst.AddLstToken; -import pcgen.util.Logging; - -public class DotClearToken implements AddLstToken -{ - - public boolean parse(PObject target, String value, int aLevel) - { - if (aLevel > 0) - { - Logging - .errorPrint("Warning: You performed a Dangerous .CLEAR in a ADD: Token"); - Logging - .errorPrint(" A non-level limited .CLEAR was used in a Class Level line"); - Logging - .errorPrint(" Today, this performs a .CLEAR on the entire PCClass"); - Logging - .errorPrint(" However, you are using undocumented behavior that is subject to change"); - Logging.errorPrint(" Hint: It will change after PCGen 5.12"); - Logging - .errorPrint(" Please level limit the .CLEAR (e.g. .CLEAR.LEVEL2)"); - Logging - .errorPrint(" ... or put the ADD:.CLEAR on a non-level Class line"); - } - target.clearAdds(); - return true; - } - - public String getTokenName() - { - return ".CLEAR"; - } - - public boolean parse(LoadContext context, PObject obj, String value) - throws PersistenceLayerException - { - // FIXME This is a hack - return true; - } - - public String[] unparse(LoadContext context, PObject obj) - { - // TODO Auto-generated method stub - return null; - } -} Modified: branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -111,7 +111,6 @@ slot.addSinkRestriction(new GroupRestriction<Equipment>( EQUIPMENT_CLASS, cr)); - // FIXME Slot needs to know AbilityNature.NORMAL ?? return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -111,7 +111,6 @@ slot.addSinkRestriction(new GroupRestriction<Language>(LANGUAGE_CLASS, cr)); - // FIXME Slot needs to know AbilityNature.NORMAL ?? return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,7 +1,19 @@ package plugin.lsttokens.add; +import java.util.List; +import java.util.Set; +import java.util.StringTokenizer; +import java.util.TreeSet; + +import pcgen.cdom.base.CDOMCompoundReference; +import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; +import pcgen.cdom.base.Slot; +import pcgen.cdom.graph.PCGraphEdge; +import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Constants; import pcgen.core.PObject; +import pcgen.core.SpecialAbility; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; @@ -10,6 +22,9 @@ public class SAToken implements AddLstToken { + private static final Class<SpecialAbility> SPECABILITY_CLASS = + SpecialAbility.class; + public boolean parse(PObject target, String value, int level) { int pipeLoc = value.indexOf(Constants.PIPE); @@ -46,13 +61,139 @@ public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { - // FIXME This is a hack + int pipeLoc = value.indexOf(Constants.PIPE); + if (pipeLoc == -1) + { + Logging.errorPrint("Lack of a SUBTOKEN for ADD:SA " + + "is prohibited."); + Logging.errorPrint("Please use ADD:SA|name|[count|]X,X"); + return false; + } + String name = value.substring(0, pipeLoc); + if (name.length() == 0) + { + Logging.errorPrint("Empty name for ADD:SA " + "is prohibited."); + Logging.errorPrint("Please use ADD:SA|name|[count|]X,X"); + return false; + } + String rest = value.substring(pipeLoc + 1); + int count; + String items; + pipeLoc = rest.indexOf(Constants.PIPE); + if (pipeLoc == -1) + { + count = 1; + items = rest; + } + else + { + String countString = rest.substring(0, pipeLoc); + try + { + count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } + } + catch (NumberFormatException nfe) + { + Logging.errorPrint("Invalid Count in ADD:" + getTokenName() + + ": " + countString); + return false; + } + items = rest.substring(pipeLoc + 1); + } + + if (items.length() == 0) + { + Logging.errorPrint("Invalid: Empty SAs in ADD:" + getTokenName() + + ": " + value); + return false; + } + + if (items.charAt(0) == ',') + { + Logging.errorPrint(getTokenName() + + " SA List may not start with , : " + value); + return false; + } + if (items.charAt(items.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " SA List may not end with , : " + value); + return false; + } + if (items.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " SA List uses double separator ,, : " + value); + return false; + } + + StringTokenizer tok = new StringTokenizer(items, Constants.COMMA); + + Slot<SpecialAbility> slot = + context.graph.addSlotIntoGraph(getTokenName(), obj, + SPECABILITY_CLASS, FormulaFactory.getFormulaFor(count)); + slot.setName(name); + CDOMCompoundReference<SpecialAbility> cr = + new CDOMCompoundReference<SpecialAbility>(SPECABILITY_CLASS, + getTokenName() + " items"); + while (tok.hasMoreTokens()) + { + String token = tok.nextToken(); + context.ref.constructIfNecessary(SPECABILITY_CLASS, token); + cr.addReference(context.ref.getCDOMReference(SPECABILITY_CLASS, + token)); + } + + slot.addSinkRestriction(new GroupRestriction<SpecialAbility>( + SPECABILITY_CLASS, cr)); return true; } public String[] unparse(LoadContext context, PObject obj) { - // TODO Auto-generated method stub - return null; + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + Set<String> set = new TreeSet<String>(); + for (PCGraphEdge edge : links) + { + Slot<SpecialAbility> slot = + (Slot<SpecialAbility>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(SpecialAbility.class)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + StringBuilder sb = new StringBuilder(); + sb.append(slot.getName()).append('|'); + if (!"1".equals(slotCount)) + { + sb.append(slotCount).append('|'); + } + sb.append(res.toLSTform()); + set.add(sb.toString()); + } + return set.toArray(new String[set.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -111,7 +111,6 @@ } slot.addSinkRestriction(new GroupRestriction<Skill>(SKILL_CLASS, cr)); - // FIXME Slot needs to know AbilityNature.NORMAL ?? return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,15 +1,31 @@ package plugin.lsttokens.add; -import pcgen.core.Constants; +import java.util.List; +import java.util.Set; +import java.util.StringTokenizer; + +import pcgen.cdom.base.CDOMCompoundReference; +import pcgen.cdom.base.CDOMReference; +import pcgen.cdom.base.Constants; +import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.Restriction; +import pcgen.cdom.base.Slot; +import pcgen.cdom.graph.PCGraphEdge; +import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.PObject; +import pcgen.core.SpellProgressionInfo; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; public class SpellCasterToken implements AddLstToken { + private static final Class<SpellProgressionInfo> SPELL_PROG_CLASS = + SpellProgressionInfo.class; + public boolean parse(PObject target, String value, int level) { int pipeLoc = value.indexOf(Constants.PIPE); @@ -44,13 +60,108 @@ public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { - // FIXME This is a hack + int pipeLoc = value.indexOf(Constants.PIPE); + int count; + String items; + if (pipeLoc == -1) + { + count = 1; + items = value; + } + else + { + String countString = value.substring(0, pipeLoc); + try + { + count = Integer.parseInt(countString); + if (count < 1) + { + Logging.errorPrint("Count in ADD:" + getTokenName() + + " must be > 0"); + return false; + } + } + catch (NumberFormatException nfe) + { + Logging.errorPrint("Invalid Count in ADD:" + getTokenName() + + ": " + countString); + return false; + } + items = value.substring(pipeLoc + 1); + } + + StringTokenizer tok = new StringTokenizer(items, Constants.COMMA); + + Slot<SpellProgressionInfo> slot = + context.graph.addSlotIntoGraph(getTokenName(), obj, + SPELL_PROG_CLASS, FormulaFactory.getFormulaFor(count)); + + CDOMCompoundReference<SpellProgressionInfo> cr = + new CDOMCompoundReference<SpellProgressionInfo>( + SPELL_PROG_CLASS, getTokenName() + " items"); + while (tok.hasMoreTokens()) + { + String token = tok.nextToken(); + CDOMReference<SpellProgressionInfo> ref = + TokenUtilities.getObjectReference(context, + SPELL_PROG_CLASS, token); + if (ref == null) + { + return false; + } + cr.addReference(ref); + } + + slot.addSinkRestriction(new GroupRestriction<SpellProgressionInfo>( + SPELL_PROG_CLASS, cr)); + return true; } public String[] unparse(LoadContext context, PObject obj) { - // TODO Auto-generated method stub - return null; + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Slot.class); + if (links == null || links.isEmpty()) + { + return null; + } + if (links.size() > 1) + { + context.addWriteMessage("Invalid Slot Count " + links.size() + + " associated with " + getTokenName() + + ": Only one Slot allowed."); + return null; + } + PCGraphEdge edge = links.iterator().next(); + Slot<SpellProgressionInfo> slot = + (Slot<SpellProgressionInfo>) edge.getSinkNodes().get(0); + if (!slot.getSlotClass().equals(SPELL_PROG_CLASS)) + { + context.addWriteMessage("Invalid Slot Type associated with " + + getTokenName() + ": Type cannot be " + + slot.getSlotClass().getSimpleName()); + return null; + } + String slotCount = slot.toLSTform(); + String result; + List<Restriction<?>> restr = slot.getSinkRestrictions(); + if (restr.size() != 1) + { + context.addWriteMessage("Slot for " + getTokenName() + + " must have only one restriction"); + return null; + } + Restriction<?> res = restr.get(0); + if ("1".equals(slotCount)) + { + result = res.toLSTform(); + } + else + { + result = slotCount + "|" + res.toLSTform(); + } + return new String[]{result}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,13 +1,27 @@ package plugin.lsttokens.add; +import java.util.Set; +import java.util.TreeSet; + +import pcgen.cdom.base.CDOMReference; +import pcgen.cdom.base.Constants; +import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.graph.PCGraphAllowsEdge; +import pcgen.cdom.graph.PCGraphEdge; +import pcgen.cdom.inst.Aggregator; import pcgen.core.PObject; +import pcgen.core.SpellList; +import pcgen.core.spell.Spell; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AddLstToken; +import pcgen.util.Logging; public class SpellLevelToken implements AddLstToken { + private static final Class<Spell> SPELL_CLASS = Spell.class; + public boolean parse(PObject target, String value, int level) { target.addAddList(level, getTokenName() + ":" + value); @@ -22,13 +36,153 @@ public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { - // FIXME This is a hack + if (!value.startsWith("CLASS|SPELLCASTER.")) + { + Logging.errorPrint(getTokenName() + + " syntax starts with CLASS|SPELLCASTER."); + return false; + } + String classSpell = value.substring(18); + int pipeLoc = classSpell.indexOf(Constants.PIPE); + if (pipeLoc == -1) + { + Logging.errorPrint(getTokenName() + " has too few | present"); + return false; + } + if (pipeLoc != classSpell.lastIndexOf(Constants.PIPE)) + { + Logging.errorPrint(getTokenName() + " has too many | present"); + return false; + } + String classLevel = classSpell.substring(0, pipeLoc); + int equalsLoc = classLevel.indexOf(Constants.EQUALS); + if (equalsLoc == -1) + { + Logging.errorPrint(getTokenName() + + " does not follow SpellList=Level syntax"); + return false; + } + if (equalsLoc != classLevel.lastIndexOf(Constants.EQUALS)) + { + Logging.errorPrint(getTokenName() + " has too many = present"); + return false; + } + + CDOMReference<SpellList> spelllist = + context.ref.getCDOMReference(SpellList.class, classLevel + .substring(0, equalsLoc)); + Integer level; + try + { + level = Integer.valueOf(classLevel.substring(equalsLoc + 1)); + } + catch (NumberFormatException nfe) + { + Logging.errorPrint(getTokenName() + + " encountered a level which is not an integer"); + return false; + } + if (level.intValue() < 0) + { + Logging.errorPrint(getTokenName() + + " encountered a level which is negative"); + return false; + } + + /* + * BUG TODO I suspect this is actually broken, as ADD produces a SLOT, + * and this is not currently doing that. + */ + String spell = classSpell.substring(pipeLoc + 1); + if (spell.length() == 0) + { + Logging.errorPrint(getTokenName() + " has no spell present"); + return false; + } + CDOMReference<Spell> sp = + context.ref.getCDOMReference(SPELL_CLASS, spell); + + Aggregator agg = new Aggregator(obj, spelllist, getTokenName()); + /* + * This is intentionally Holds, as the context for traversal must only + * be the ref (linked by the Activation Edge). So we need an edge to the + * Activator to get it copied into the PC, but since this is a 3rd party + * Token, the granting object should never grant anything hung off the + * aggregator. + */ + context.graph.linkHoldsIntoGraph(getTokenName(), obj, agg); + context.graph.linkActivationIntoGraph(getTokenName(), spelllist, agg); + + PCGraphAllowsEdge edge = + context.graph.linkAllowIntoGraph(getTokenName(), agg, sp); + edge.setAssociation(AssociationKey.SPELL_LEVEL, level); return true; } public String[] unparse(LoadContext context, PObject obj) { - // TODO Auto-generated method stub - return null; + Set<PCGraphEdge> edgeList = + context.graph.getChildLinksFromToken(getTokenName(), obj, + Aggregator.class); + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } + Set<String> set = new TreeSet<String>(); + for (PCGraphEdge edge : edgeList) + { + if (!processEdge(set, context, edge)) + { + return null; + } + } + return set.toArray(new String[set.size()]); } + + private boolean processEdge(Set<String> set, LoadContext context, + PCGraphEdge edge) + { + Aggregator a = (Aggregator) edge.getNodeAt(1); + Set<PCGraphEdge> edgeFromSourceList = + context.graph.getParentLinksFromToken(getTokenName(), a, + SpellList.class); + if (edgeFromSourceList.size() != 1) + { + context + .addWriteMessage("Spell must have one source SpellList for Token " + + getTokenName()); + return false; + } + CDOMReference<SpellList> sourceList = + (CDOMReference<SpellList>) edgeFromSourceList.iterator().next() + .getNodeAt(0); + + Set<PCGraphEdge> edgeToSpellList = + context.graph.getChildLinksFromToken(getTokenName(), a, + SPELL_CLASS); + for (PCGraphEdge se : edgeToSpellList) + { + Integer level = se.getAssociation(AssociationKey.SPELL_LEVEL); + if (level == null) + { + context.addWriteMessage("Spell must have level for Token " + + getTokenName()); + return false; + } + if (level.intValue() < 0) + { + context + .addWriteMessage("Spell must have positive integer level for Token " + + getTokenName()); + return false; + } + CDOMReference<Spell> spell = (CDOMReference<Spell>) se.getNodeAt(1); + String string = + new StringBuilder().append("CLASS|SPELLCASTER.").append( + sourceList.getLSTformat()).append('=').append(level) + .append('|').append(spell.getLSTformat()).toString(); + set.add(string); + } + return true; + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -255,7 +255,7 @@ hdm = new HitDieLock(new HitDie(i)); } - Aggregator ag = new Aggregator(race, getTokenName()); + Aggregator ag = new Aggregator(race, owner, getTokenName()); context.graph.linkAllowIntoGraph(getTokenName(), race, ag); context.graph.linkActivationIntoGraph(getTokenName(), owner, ag); context.graph.linkObjectIntoGraph(getTokenName(), ag, hdm); Modified: branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -82,7 +82,9 @@ + " arguments uses double separator || : " + value); return false; } - Aggregator agg = new Aggregator(race, getTokenName()); + CDOMGroupRef<PCClass> ref = + context.ref.getCDOMTypeReference(PCClass.class, "Monster"); + Aggregator agg = new Aggregator(race, ref, getTokenName()); /* * This is intentionally Holds, as the context for traversal must only * be the ref (linked by the Activation Edge). So we need an edge to the @@ -90,8 +92,6 @@ * Token, the Race should never grant anything hung off the aggregator. */ context.graph.linkHoldsIntoGraph(getTokenName(), race, agg); - CDOMGroupRef<PCClass> ref = - context.ref.getCDOMTypeReference(PCClass.class, "Monster"); context.graph.linkActivationIntoGraph(getTokenName(), ref, agg); StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); Modified: branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -83,7 +83,9 @@ return false; } - Aggregator agg = new Aggregator(race, getTokenName()); + CDOMGroupRef<PCClass> ref = + context.ref.getCDOMTypeReference(PCClass.class, "Monster"); + Aggregator agg = new Aggregator(race, ref, getTokenName()); /* * This is intentionally Holds, as the context for traversal must only * be the ref (linked by the Activation Edge). So we need an edge to the @@ -91,8 +93,6 @@ * Token, the Race should never grant anything hung off the aggregator. */ context.graph.linkHoldsIntoGraph(getTokenName(), race, agg); - CDOMGroupRef<PCClass> ref = - context.ref.getCDOMTypeReference(PCClass.class, "Monster"); context.graph.linkActivationIntoGraph(getTokenName(), ref, agg); StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); Modified: branches/cdom/code/src/java/plugin/lsttokens/template/BonusskillpointsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/BonusskillpointsToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/template/BonusskillpointsToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -78,17 +78,11 @@ return false; } - /* - * BUG This is insufficient because Aggregator's .equals is very - * simple... Need some method of uniquifying each Aggregator in a common - * fashion between graphs... source object key and token name? (not good - * because keys can be changed)... ??? - */ - Aggregator ag = new Aggregator(template, getTokenName()); - LevelSkillPoints lsp = new LevelSkillPoints(skillCount); - context.graph.linkAllowIntoGraph(getTokenName(), template, ag); CDOMGroupRef<PCClass> owner = context.ref.getCDOMAllReference(PCClass.class); + Aggregator ag = new Aggregator(template, owner, getTokenName()); + LevelSkillPoints lsp = new LevelSkillPoints(skillCount); + context.graph.linkAllowIntoGraph(getTokenName(), template, ag); context.graph.linkActivationIntoGraph(getTokenName(), owner, ag); context.graph.linkObjectIntoGraph(getTokenName(), ag, lsp); return true; Modified: branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -253,13 +253,7 @@ hdm = new HitDieLock(new HitDie(i)); } - /* - * BUG This is insufficient because Aggregator's .equals is very - * simple... Need some method of uniquifying each Aggregator in a - * common fashion between graphs... source object key and token - * name? (not good because keys can be changed)... ??? - */ - Aggregator ag = new Aggregator(template, getTokenName()); + Aggregator ag = new Aggregator(template, owner, getTokenName()); context.graph.linkAllowIntoGraph(getTokenName(), template, ag); context.graph.linkActivationIntoGraph(getTokenName(), owner, ag); context.graph.linkObjectIntoGraph(getTokenName(), ag, hdm); Modified: branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/java/plugin/lsttokens/template/RepeatlevelToken.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -369,7 +369,7 @@ return false; } - Aggregator agg = new Aggregator(template, getTokenName()); + Aggregator agg = new Aggregator(template, template, getTokenName()); agg.put(IntegerKey.CONSECUTIVE, Integer.valueOf(consecutive)); agg.put(IntegerKey.MAX_LEVEL, Integer.valueOf(maxLevel)); agg.put(IntegerKey.LEVEL_INCREMENT, Integer.valueOf(lvlIncrement)); Added: branches/cdom/code/src/test/plugin/lsttokens/add/ClassSkillsTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/ClassSkillsTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/ClassSkillsTokenTest.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.add; + +import pcgen.core.PCTemplate; +import pcgen.core.Skill; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; + +public class ClassSkillsTokenTest extends AbstractAddTokenTestCase +{ + + private AddLstToken aToken = new ClassSkillsToken(); + + @Override + protected AddLstToken getSubToken() + { + return aToken; + } + + @Override + protected Class<Skill> getSubTokenType() + { + return Skill.class; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + public boolean isTypeLegal() + { + return true; + } +} Modified: branches/cdom/code/src/test/plugin/lsttokens/add/EquipTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/EquipTokenTest.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/test/plugin/lsttokens/add/EquipTokenTest.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens.add; import pcgen.core.Equipment; Modified: branches/cdom/code/src/test/plugin/lsttokens/add/FeatTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/FeatTokenTest.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/test/plugin/lsttokens/add/FeatTokenTest.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens.add; import pcgen.cdom.enumeration.AbilityCategory; Modified: branches/cdom/code/src/test/plugin/lsttokens/add/LanguageTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/LanguageTokenTest.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/test/plugin/lsttokens/add/LanguageTokenTest.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens.add; import pcgen.core.Language; Added: branches/cdom/code/src/test/plugin/lsttokens/add/SATokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/SATokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/SATokenTest.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.add; + +import java.net.URISyntaxException; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.core.PCTemplate; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.GlobalLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; +import plugin.lsttokens.AddLst; +import plugin.lsttokens.testsupport.GlobalTokenTestCase; +import plugin.lsttokens.testsupport.TokenRegistration; + +public class SATokenTest extends GlobalTokenTestCase +{ + + @Override + @Before + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + TokenRegistration.register(aToken); + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + static AddLst token = new AddLst(); + + @Override + public GlobalLstToken getToken() + { + return token; + } + + private AddLstToken aToken = new SAToken(); + + public String getSubTokenString() + { + return aToken.getTokenName(); + } + + @Test + public void testInvalidInputOnePipe() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|Slot Name")); + } + + @Test + public void testInvalidInputNullSecond() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|Slot Name|")); + } + + @Test + public void testInvalidInputNullStartItem() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|Slot Name|,Item")); + } + + @Test + public void testInvalidInputEmptyName() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "||Item")); + } + + @Test + public void testInvalidInputNullEndItem() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|Slot Name|Item,")); + } + + @Test + public void testInvalidInputNullMiddleItem() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|Slot Name|Item,,Item2")); + } + + @Test + public void testInvalidInputooManyPipe() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|Slot Name|Item|Item2")); + } + + @Test + public void testRoundRobinSimple() throws PersistenceLayerException + { + this.runRoundRobin(getSubTokenString() + "|Slot Name|Item"); + } + + @Test + public void testRoundRobinTwoItem() throws PersistenceLayerException + { + this.runRoundRobin(getSubTokenString() + "|Slot Name|Item,Item Two"); + } + + @Test + public void testRoundRobinTwoAdds() throws PersistenceLayerException + { + this.runRoundRobin(getSubTokenString() + "|Slot Name|Item,Item Two", + getSubTokenString() + "|Slot Too|Item Too,Item Two"); + } + + @Test + public void testRoundRobinCountItems() throws PersistenceLayerException + { + this.runRoundRobin(getSubTokenString() + + "|Slot Name|2|Item,Item Also,Item Last"); + } + + @Test + public void testRoundRobinCountTwoAdds() throws PersistenceLayerException + { + this.runRoundRobin(getSubTokenString() + + "|Slot Name|2|Item,Item Also,Item Last", getSubTokenString() + + "|Slot Name|3|Item,Item Also,Item Mid,Item X-Ray"); + } +} Modified: branches/cdom/code/src/test/plugin/lsttokens/add/SkillTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/SkillTokenTest.java 2007-03-26 21:31:06 UTC (rev 2588) +++ branches/cdom/code/src/test/plugin/lsttokens/add/SkillTokenTest.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package plugin.lsttokens.add; import pcgen.core.PCTemplate; Added: branches/cdom/code/src/test/plugin/lsttokens/add/SpellCasterTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/SpellCasterTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/SpellCasterTokenTest.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.add; + +import pcgen.core.PCTemplate; +import pcgen.core.SpellProgressionInfo; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; + +public class SpellCasterTokenTest extends AbstractAddTokenTestCase +{ + + private AddLstToken aToken = new SpellCasterToken(); + + @Override + protected AddLstToken getSubToken() + { + return aToken; + } + + @Override + protected Class<SpellProgressionInfo> getSubTokenType() + { + return SpellProgressionInfo.class; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + public boolean isTypeLegal() + { + return true; + } +} Added: branches/cdom/code/src/test/plugin/lsttokens/add/SpellLevelTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/add/SpellLevelTokenTest.java (rev 0) +++ branches/cdom/code/src/test/plugin/lsttokens/add/SpellLevelTokenTest.java 2007-03-26 22:24:03 UTC (rev 2589) @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.add; + +import java.net.URISyntaxException; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.core.PCTemplate; +import pcgen.core.SpellList; +import pcgen.core.spell.Spell; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.AddLstToken; +import pcgen.persistence.lst.GlobalLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; +import plugin.lsttokens.AddLst; +import plugin.lsttokens.testsupport.GlobalTokenTestCase; +import plugin.lsttokens.testsupport.TokenRegistration; + +public class SpellLevelTokenTest extends GlobalTokenTestCase +{ + + @Override + @Before + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + TokenRegistration.register(aToken); + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + static AddLst token = new AddLst(); + + @Override + public GlobalLstToken getToken() + { + return token; + } + + private AddLstToken aToken = new SpellLevelToken(); + + // ADD:SPELLLEVEL|CLASS|SPELLCASTER.Arcane=1|Change Self + + public String getSubTokenString() + { + return aToken.getTokenName(); + } + + @Test + public void testInvalidInputString() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|String")); + } + + @Test + public void testInvalidInputOnePipe() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS")); + } + + @Test + public void testInvalidInputNullSecond() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|")); + } + + @Test + public void testInvalidInputNoList() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|SPELLCASTER.Arcane=1")); + } + + @Test + public void testInvalidInputNoSpell() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|SPELLCASTER.")); + } + + @Test + public void testInvalidInputNullSpell() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|SPELLCASTER.Arcane=1|")); + } + + @Test + public void testInvalidInputNoLevel() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|SPELLCASTER.Arcane|Change Self")); + } + + @Test + public void testInvalidInputNotASpell() throws PersistenceLayerException + { + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|SPELLCASTER.Arcane=1|Change Self")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testInvalidInputNoClassString() + throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(Spell.class, "Change Self"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "||SPELLCASTER.Arcane=1|Change Self")); + } + + @Test + public void testInvalidInputNoSpellcasterString() + throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(Spell.class, "Change Self"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|Arcane=1|Change Self")); + } + + @Test + public void testInvalidInputTooManyEquals() + throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(Spell.class, "Change Self"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|SPELLCASTER.Arcane=1=2|Change Self")); + } + + @Test + public void testInvalidInputLevelNaN() throws PersistenceLayerException + { + assertFalse(getToken() + .parse( + primaryContext, + primaryProf, + getSubTokenString() + + "|CLASS|SPELLCASTER.Arcane=Three|Change Self")); + } + + @Test + public void testInvalidInputNegativeLevel() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|SPELLCASTER.Arcane=-2|Change Self")); + } + + @Test + public void testInvalidInputTooManyPipe() throws PersistenceLayerException + { + assertFalse(getToken().parse( + primaryContext, + primaryProf, + getSubTokenString() + + "|CLASS|SPELLCASTER.Arcane=3|Change Self|Alarm")); + } + + @Test + public void testInvalidInputNotAClass() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(Spell.class, "Change Self"); + assertTrue(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|CLASS|SPELLCASTER.Arcane=1|Change Self")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testRoundRobinSimple() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(Spell.class, "Change Self"); + primaryContext.ref.constructCDOMObject(SpellList.class, "Arcane"); + this.runRoundRobin(getSubTokenString() + + "|CLASS|SPELLCASTER.Arcane=1|Change Self"); + } + + @Test + public void testRoundRobinTwoSpell() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(Spell.class, "Alarm"); + primaryContext.ref.constructCDOMObject(Spell.class, "Change Self"); + primaryContext.ref.constructCDOMObject(SpellList.class, "Arcane"); + this.runRoundRobin(getSubTokenString() + + "|CLASS|SPELLCASTER.Arcane=1|Alarm", getSubTokenString() + + "|CLASS|SPELLCASTER.Arcane=4|Change Self"); + } + + @Test + public void testRoundRobinTwoGrant() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(Spell.class, "Alarm"); + primaryContext.ref.constructCDOMObject(Spell.class, "Change Self"); + primaryContext.ref.constructCDOMObject(SpellList.class, "Arcane"); + primaryContext.ref.constructCDOMObject(SpellList.class, "Divine"); + this.runRoundRobin(getSubTokenString() + + "|CLASS|SPELLCASTER.Arcane=2|Change Self", getSubTokenString() + + "|CLASS|SPELLCAS... [truncated message content] |
From: <th...@us...> - 2007-03-26 23:37:47
|
Revision: 2592 http://svn.sourceforge.net/pcgen/?rev=2592&view=rev Author: thpr Date: 2007-03-26 16:37:47 -0700 (Mon, 26 Mar 2007) Log Message: ----------- CDOM: Some global Token Round Robin Testing and associated core changes Modified Paths: -------------- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java branches/cdom/code/src/java/pcgen/cdom/content/SimpleMovement.java branches/cdom/code/src/java/pcgen/cdom/enumeration/Load.java branches/cdom/code/src/java/pcgen/cdom/modifier/MovementFormulaMod.java branches/cdom/code/src/java/pcgen/core/Movement.java branches/cdom/code/src/java/pcgen/core/Vision.java branches/cdom/code/src/java/pcgen/gui/editor/EditorMainForm.java branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java branches/cdom/code/src/java/plugin/lsttokens/DrLst.java branches/cdom/code/src/java/plugin/lsttokens/KitLst.java branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java branches/cdom/code/src/java/plugin/lsttokens/MoveLst.java branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java branches/cdom/code/src/java/plugin/lsttokens/MovecloneLst.java branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java branches/cdom/code/src/java/plugin/lsttokens/SaLst.java branches/cdom/code/src/java/plugin/lsttokens/TemplateLst.java branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java branches/cdom/code/src/java/plugin/lsttokens/UmultLst.java branches/cdom/code/src/java/plugin/lsttokens/UnencumberedmoveLst.java branches/cdom/code/src/java/plugin/lsttokens/VisionLst.java branches/cdom/code/src/java/plugin/pretokens/writer/PreRaceWriter.java branches/cdom/code/src/test/plugin/lsttokens/auto/AbstractProfTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractIntegerTokenTestCase.java Added Paths: ----------- branches/cdom/code/src/test/plugin/lsttokens/CCSkillLstTest.java branches/cdom/code/src/test/plugin/lsttokens/CSkillLstTest.java branches/cdom/code/src/test/plugin/lsttokens/DescispiLstTest.java branches/cdom/code/src/test/plugin/lsttokens/DrLstTest.java branches/cdom/code/src/test/plugin/lsttokens/KeyLstTest.java branches/cdom/code/src/test/plugin/lsttokens/KitLstTest.java branches/cdom/code/src/test/plugin/lsttokens/LangAutoLstTest.java branches/cdom/code/src/test/plugin/lsttokens/MoveLstTest.java branches/cdom/code/src/test/plugin/lsttokens/NameispiLstTest.java branches/cdom/code/src/test/plugin/lsttokens/OutputNameLstTest.java branches/cdom/code/src/test/plugin/lsttokens/RegionLstTest.java branches/cdom/code/src/test/plugin/lsttokens/SaLstTest.java branches/cdom/code/src/test/plugin/lsttokens/SourceDateLstTest.java branches/cdom/code/src/test/plugin/lsttokens/SourceLongLstTest.java branches/cdom/code/src/test/plugin/lsttokens/SourcePageLstTest.java branches/cdom/code/src/test/plugin/lsttokens/SourceShortLstTest.java branches/cdom/code/src/test/plugin/lsttokens/SourceWebLstTest.java branches/cdom/code/src/test/plugin/lsttokens/SrLstTest.java branches/cdom/code/src/test/plugin/lsttokens/TempdescLstTest.java branches/cdom/code/src/test/plugin/lsttokens/TemplateLstTest.java branches/cdom/code/src/test/plugin/lsttokens/TypeLstTest.java branches/cdom/code/src/test/plugin/lsttokens/UdamLstTest.java branches/cdom/code/src/test/plugin/lsttokens/UmultLstTest.java branches/cdom/code/src/test/plugin/lsttokens/UnencumberedmoveLstTest.java branches/cdom/code/src/test/plugin/lsttokens/VisionLstTest.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractGlobalFormulaTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractGlobalIntegerTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractGlobalListTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractGlobalStringTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractGlobalTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractGlobalTypeSafeListTestCase.java Removed Paths: ------------- branches/cdom/code/src/test/plugin/lsttokens/testsupport/GlobalTokenTestCase.java Modified: branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -407,16 +407,21 @@ al.removeAll(otherNodeList); for (Object o : al) { - System.err.println("1- " + o.hashCode()); + System.err.println("1- " + o.hashCode() + " " + o); } System.err.println("?!?"); ArrayList al2 = new ArrayList(otherGraph.getNodeList()); al2.removeAll(otherNodeList); for (Object o : al2) { - System.err.println("2- " + o.hashCode()); + System.err.println("2- " + o.hashCode() + " " + o); } System.err.println(al.equals(al2)); + System.err.println(al2.equals(al)); + if (al.equals(al2) && al2.equals(al)) + { + System.err.println("Hash code modified after object add to graph"); + } return false; } // Here, the node lists are identical... Modified: branches/cdom/code/src/java/pcgen/cdom/content/SimpleMovement.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/SimpleMovement.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/pcgen/cdom/content/SimpleMovement.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -22,7 +22,10 @@ */ package pcgen.cdom.content; +import java.math.BigDecimal; + import pcgen.cdom.base.ConcretePrereqObject; +import pcgen.util.BigDecimalHelper; /** * @author Tom Parker <th...@so...> @@ -36,27 +39,27 @@ * Contains the associated movement rate (in feet) for the movement type. A * movement rate must be greater than or equal to zero. */ - private double movement; + private BigDecimal movement; /** * Creates a Movement object */ - public SimpleMovement(String moveType, int i) + public SimpleMovement(String moveType, BigDecimal d) { super(); - if (i < 0) + if (d.compareTo(BigDecimal.ZERO) < 0) { throw new IllegalArgumentException( "Movement rate cannot be negative"); } type = moveType; - movement = i; + movement = BigDecimalHelper.trimBigDecimal(d); } /** * @return movement as a Double */ - public double getMovement() + public BigDecimal getMovement() { return movement; } @@ -73,18 +76,34 @@ /** * Converts this Movement object into a format suitable for storage in an - * LST or equivalent file. This method should be the complement of the - * static getMovementFrom() method. + * LST or equivalent file. * * @return a String in LST/PCC file format, suitable for persistent storage */ public String toLSTString() { - StringBuilder txt = new StringBuilder(); - txt.append("\tMOVE:"); - txt.append(type); - txt.append(','); - txt.append(movement); - return txt.toString(); + return new StringBuilder().append(type).append(',').append(movement) + .toString(); } + + @Override + public int hashCode() + { + return type.hashCode() ^ movement.hashCode(); + } + + @Override + public boolean equals(Object o) + { + if (o == this) + { + return true; + } + if (o instanceof SimpleMovement) + { + SimpleMovement sm = (SimpleMovement) o; + return type.equals(sm.type) && movement.equals(sm.movement); + } + return false; + } } Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/Load.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/Load.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/Load.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -75,6 +75,11 @@ return FACTORY.getAllConstants(); } + public static void constructConstant(String string, int i) + { + FACTORY.constructConstant(string, i); + } + public static Load valueOf(String s) { return FACTORY.valueOf(s); Modified: branches/cdom/code/src/java/pcgen/cdom/modifier/MovementFormulaMod.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/modifier/MovementFormulaMod.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/pcgen/cdom/modifier/MovementFormulaMod.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -17,6 +17,8 @@ */ package pcgen.cdom.modifier; +import java.math.BigDecimal; + import pcgen.base.formula.ReferenceFormula; import pcgen.cdom.base.ConcretePrereqObject; import pcgen.cdom.content.SimpleMovement; @@ -40,8 +42,8 @@ { if (type.equals(move.getMovementType())) { - Integer resolve = f.resolve(Double.valueOf(move.getMovement())); - return new SimpleMovement(type, resolve.intValue()); + Integer resolve = f.resolve(move.getMovement()); + return new SimpleMovement(type, new BigDecimal(resolve.intValue())); } return move; } Modified: branches/cdom/code/src/java/pcgen/core/Movement.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/Movement.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/pcgen/core/Movement.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -42,7 +42,7 @@ /** * Contains the associated movement rate (in feet) for the movement type of * the same index. A movement rate must be greater than or equal to zero. - * + * * REFACTOR This should be changed to double[] once PlayerCharacter can * handle it */ @@ -51,7 +51,7 @@ /** * The movement multiplier for the movement type of the same index. A * movement Multiplier be greater than zero. - * + * * REFACTOR This should be changed to double[] once PlayerCharacter can * handle it */ @@ -65,10 +65,9 @@ /** * The Movement Rates flag indicating which type of Movement object this is - * 0 indicates a basic assignment - * 1 indicates the movement rates are added to the existing movement rate - * for the contained types - * 2 indicates this clones one movement rate into another movement rate + * 0 indicates a basic assignment 1 indicates the movement rates are added + * to the existing movement rate for the contained types 2 indicates this + * clones one movement rate into another movement rate */ private int moveRatesFlag; @@ -102,7 +101,7 @@ * Creates a Movement object with arrays of the given length. It is assumed * that the user of this constructor will initialize all of the arrays, as * this constructor does not perform initialization. - * + * * @param i * The length of the movement arrays to be assigned. */ @@ -111,8 +110,8 @@ if (i < 0) { throw new IllegalArgumentException( - "Argument of array length to ConcreteMovement" - + "constructor cannot be negative"); + "Argument of array length to ConcreteMovement" + + "constructor cannot be negative"); } movementTypes = new String[i]; movements = new Double[i]; @@ -122,7 +121,7 @@ /** * Sets the Move Rates Flag on this Movement object. - * + * * @param i * The move rates flag. */ @@ -136,6 +135,7 @@ /** * Gets the Movement Rates Flag for this Movement object. + * * @return move rates flag */ public int getMoveRatesFlag() @@ -144,8 +144,10 @@ } /** - * TODO REFACTOR Some of these methods might need to be rebuilt - should this be - * dependent upon an index, or keyed off of a String name of a movementType? + * TODO REFACTOR Some of these methods might need to be rebuilt - should + * this be dependent upon an index, or keyed off of a String name of a + * movementType? + * * @return movement as a Double */ public Double getDoubleMovement() @@ -155,6 +157,7 @@ /** * Get a movement multiplier + * * @param index * @return a movement multiplier */ @@ -165,6 +168,7 @@ /** * a movement multiplier operator + * * @param index * @return a movement multiplier operator */ @@ -175,6 +179,7 @@ /** * Get all of the movement multipliers + * * @return clone of the movement multipliers array */ public Double[] getMovementMult() @@ -184,6 +189,7 @@ /** * Get all of the movement multiplier operators + * * @return clone of the movement multiplier operators array */ public String[] getMovementMultOp() @@ -193,6 +199,7 @@ /** * Get the number of movement types + * * @return the number of movement types */ public int getNumberOfMovementTypes() @@ -202,6 +209,7 @@ /** * Set the movement types + * * @param arrayString */ public void setMovementTypes(String[] arrayString) @@ -210,7 +218,8 @@ } /** - * Get the movement type from the array + * Get the movement type from the array + * * @param i * @return movement type */ @@ -226,6 +235,7 @@ /** * Get a movement type at a particular index + * * @param x * @return a movement type */ @@ -236,6 +246,7 @@ /** * Get the movement types + * * @return the movement types */ public String[] getMovementTypes() @@ -245,6 +256,7 @@ /** * Get the movement at index x + * * @param x * @return the movement at index x */ @@ -255,6 +267,7 @@ /** * Get the movement at index i + * * @param i * @return the movement at index i or 0 */ @@ -270,6 +283,7 @@ /** * Get the number of movements + * * @return number of movements */ public int getNumberOfMovements() @@ -279,6 +293,7 @@ /** * True if movements is not null + * * @return True if movements is not null */ public boolean isInitialized() @@ -288,6 +303,7 @@ /** * Get movements + * * @return movements */ public Double[] getMovements() @@ -298,6 +314,7 @@ /** * Provides a String representation of this Movement object, suitable for * display to a user. + * * @return String */ public String toString() @@ -305,13 +322,13 @@ final StringBuffer movelabel = new StringBuffer(); movelabel.append(movementTypes[0]); movelabel.append(' ').append( - Globals.getGameModeUnitSet().convertDistanceToUnitSet( - movements[0].doubleValue())); + Globals.getGameModeUnitSet().convertDistanceToUnitSet( + movements[0].doubleValue())); movelabel.append(Globals.getGameModeUnitSet().getDistanceUnit()); if (movementMult[0].doubleValue() != 0) { movelabel.append('(').append(movementMultOp[0]).append( - movementMult[0]).append(')'); + movementMult[0]).append(')'); } for (int i = 1; i < movementTypes.length; ++i) @@ -319,13 +336,13 @@ movelabel.append(", "); movelabel.append(movementTypes[i]); movelabel.append(' ').append( - Globals.getGameModeUnitSet().convertDistanceToUnitSet( - movements[i].doubleValue())); + Globals.getGameModeUnitSet().convertDistanceToUnitSet( + movements[i].doubleValue())); movelabel.append(Globals.getGameModeUnitSet().getDistanceUnit()); if (movementMult[i].doubleValue() != 0) { movelabel.append('(').append(movementMultOp[i]).append( - movementMult[i]).append(')'); + movementMult[i]).append(')'); } } return movelabel.toString(); @@ -335,7 +352,7 @@ * Converts this Movement object into a format suitable for storage in an * LST or equivalent file. This method should be the complement of the * static getMovementFrom() method. - * + * * @return a String in LST/PCC file format, suitable for persistent storage */ public String toLSTString() @@ -344,16 +361,16 @@ txt.append("\tMOVE"); switch (moveRatesFlag) { - case 1: // MOVEA: - txt.append('A'); - break; + case 1: // MOVEA: + txt.append('A'); + break; - case 2: // MOVECLONE: - txt.append("CLONE"); - break; + case 2: // MOVECLONE: + txt.append("CLONE"); + break; - default: // MOVE: - break; + default: // MOVE: + break; } txt.append(':'); for (int index = 0; index < movementTypes.length; ++index) @@ -364,7 +381,7 @@ } if ((movementTypes[index] != null) - && (movementTypes[index].length() > 0)) + && (movementTypes[index].length() > 0)) { txt.append(movementTypes[index]).append(','); } @@ -388,18 +405,18 @@ * rates flag of the returned ConcreteMovement in order for the * ConcreteMovement to function properly. (The default move rates flag is * zero, so assignment in that case is not necessary) - * + * * @param moveparse * The String from which a new ConcreteMovement should be * initialized * @return A new ConcreteMovement initialized from the given String. */ - public static Movement getMovementFrom(final String moveparse) + public static Movement getOldMovementFrom(final String moveparse) { if (moveparse == null) { throw new IllegalArgumentException( - "Null initialization String illegal"); + "Null initialization String illegal"); } final StringTokenizer moves = new StringTokenizer(moveparse, ","); String tok; @@ -411,7 +428,7 @@ cm = new Movement(1); if ((tok.length() > 0) - && ((tok.charAt(0) == '*') || (tok.charAt(0) == '/'))) + && ((tok.charAt(0) == '*') || (tok.charAt(0) == '/'))) { cm.movements[0] = Double.valueOf(0.0); cm.movement = Double.valueOf(0.0); @@ -421,7 +438,7 @@ if (multValue <= 0) { Logging.errorPrint("Illegal movement multiplier: " - + multValue + " in movement string " + tok); + + multValue + " in movement string " + tok); } cm.movementMult[0] = Double.valueOf(multValue); cm.movementMultOp[0] = tok.substring(0, 1); @@ -467,7 +484,7 @@ tok = moves.nextToken(); if ((tok.length() > 0) - && ((tok.charAt(0) == '*') || (tok.charAt(0) == '/'))) + && ((tok.charAt(0) == '*') || (tok.charAt(0) == '/'))) { cm.movements[x] = Double.valueOf(0.0); try @@ -476,7 +493,7 @@ if (multValue <= 0) { Logging.errorPrint("Illegal movement multiplier: " - + multValue + " in movement string " + tok); + + multValue + " in movement string " + tok); } cm.movementMult[x] = Double.valueOf(multValue); cm.movementMultOp[x] = tok.substring(0, 1); @@ -514,12 +531,127 @@ if (moves.countTokens() != 0) { Logging.errorPrint("Badly formed MOVE token " - + "(extra value at end of list): " + moveparse); + + "(extra value at end of list): " + moveparse); } } return cm; } + /** + * Returns a ConcreteMovement object initialized from the given string. This + * string can be any legal string for the MOVE, MOVEA, or MOVECLONE tags. + * The object which calls getMovementFrom MUST subsequently assign the move + * rates flag of the returned ConcreteMovement in order for the + * ConcreteMovement to function properly. (The default move rates flag is + * zero, so assignment in that case is not necessary) + * + * @param moveparse + * The String from which a new ConcreteMovement should be + * initialized + * @return A new ConcreteMovement initialized from the given String. + */ + public static Movement getMovementFrom(final String moveparse) + { + if (moveparse == null) + { + throw new IllegalArgumentException( + "Null initialization String illegal"); + } + if (moveparse.length() == 0) + { + throw new IllegalArgumentException( + "Empty initialization String illegal"); + } + if (moveparse.charAt(0) == ',') + { + throw new IllegalArgumentException( + "Movement arguments may not start with ,| : " + moveparse); + } + if (moveparse.charAt(moveparse.length() - 1) == ',') + { + throw new IllegalArgumentException( + "Movement arguments may not end with , : " + moveparse); + } + if (moveparse.indexOf(",,") != -1) + { + throw new IllegalArgumentException( + "Movement arguments uses double separator ,, : " + moveparse); + } + final StringTokenizer moves = new StringTokenizer(moveparse, ","); + Movement cm; + + int tokenCount = moves.countTokens(); + if (tokenCount % 2 != 0) + { + throw new IllegalArgumentException( + "String must value count that is a multiple of 2: " + moveparse); + } + cm = new Movement(tokenCount / 2); + + int x = 0; + + while (moves.hasMoreTokens()) + { + cm.movementTypes[x] = moves.nextToken(); // e.g. "Walk" + cm.movementMult[x] = Double.valueOf(0.0); + cm.movementMultOp[x] = ""; + + String tok = moves.nextToken(); + + if ((tok.length() > 0) + && ((tok.charAt(0) == '*') || (tok.charAt(0) == '/'))) + { + cm.movements[x] = Double.valueOf(0.0); + try + { + double multValue = Double.parseDouble(tok.substring(1)); + if (multValue <= 0) + { + Logging.errorPrint("Illegal movement multiplier: " + + multValue + " in movement string " + tok); + return null; + } + cm.movementMult[x] = Double.valueOf(multValue); + cm.movementMultOp[x] = tok.substring(0, 1); + } + catch (NumberFormatException e) + { + Logging.errorPrint("Badly formed MOVE token: " + tok); + return null; + } + } + else if (tok.length() > 0) + { + cm.movementMult[x] = Double.valueOf(0.0); + cm.movementMultOp[x] = ""; + + try + { + cm.movements[x] = new Double(tok); + } + catch (NumberFormatException e) + { + Logging.errorPrint("Badly formed MOVE token: " + tok); + return null; + } + + if ("Walk".equals(cm.movementTypes[x])) + { + cm.movement = cm.movements[x]; + } + } + else + { + Logging.errorPrint("Encounted Empty Movement Type in " + + moveparse); + return null; + } + + x++; + } + return cm; + } + public boolean equals(Object o) { if (!(o instanceof Movement)) Modified: branches/cdom/code/src/java/pcgen/core/Vision.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/Vision.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/pcgen/core/Vision.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -22,89 +22,176 @@ */ package pcgen.core; -import java.util.StringTokenizer; - import pcgen.cdom.base.ConcretePrereqObject; import pcgen.util.enumeration.VisionType; -public class Vision extends ConcretePrereqObject implements Comparable<Vision> { +public class Vision extends ConcretePrereqObject implements Comparable<Vision> +{ private final VisionType visionType; private final String distance; - public Vision(VisionType type, String dist) { - if (type == null) { + public Vision(VisionType type, String dist) + { + if (type == null) + { throw new IllegalArgumentException("Vision Type cannot be null"); } visionType = type; distance = dist; } - public String getDistance() { + public String getDistance() + { return distance; } - public VisionType getType() { + public VisionType getType() + { return visionType; } @Override - public String toString() { - try { + public String toString() + { + try + { return toString(Integer.parseInt(distance)); - } catch (NumberFormatException e) { - return visionType + " (" + distance + "')"; } + catch (NumberFormatException e) + { + return visionType + " (" + distance + ")"; + } } - private String toString(int d) { - if (d <= 0) { + private String toString(int d) + { + if (d <= 0) + { return visionType.toString(); - } else { + } + else + { return visionType + " (" + d + "')"; } } @Override - public int hashCode() { + public int hashCode() + { return visionType.hashCode() - ^ (distance == null ? 0 : distance.hashCode()); + ^ (distance == null ? 0 : distance.hashCode()); } @Override - public boolean equals(Object o) { - if (o instanceof Vision) { + public boolean equals(Object o) + { + if (o instanceof Vision) + { Vision v2 = (Vision) o; - if (v2.visionType.equals(visionType)) { + if (v2.visionType.equals(visionType)) + { return v2.distance == null && distance == null - || distance != null && distance.equals(v2.distance); + || distance != null && distance.equals(v2.distance); } } return false; } - public int compareTo(Vision v) { + public int compareTo(Vision v) + { // CONSIDER This is potentially a slow method, but definitely works - // thpr 10/26/06 return toString().compareTo(v.toString()); } - public static Vision getVision(String visionType) { - // expecting value in form of Darkvision (60') - StringTokenizer cTok = new StringTokenizer(visionType, "(')"); - String aKey = cTok.nextToken().trim(); // e.g. Darkvision - String aVal = "0"; - if (cTok.hasMoreTokens()) { - aVal = cTok.nextToken(); // e.g. 60 + public static Vision getVision(String visionType) + { + // expecting value in form of Darkvision (60') or Darkvision + int commaLoc = visionType.indexOf(','); + if (commaLoc != -1) + { + throw new IllegalArgumentException("Invalid Vision: " + visionType + + ". May not contain a comma"); } - return new Vision(VisionType.getVisionType(aKey), aVal); + int quoteLoc = visionType.indexOf('\''); + int openParenLoc = visionType.indexOf('('); + String distance; + String type; + if (openParenLoc == -1) + { + if (visionType.indexOf(')') != -1) + { + throw new IllegalArgumentException("Invalid Vision: " + + visionType + ". Had close paren without open paren"); + } + if (quoteLoc != -1) + { + throw new IllegalArgumentException("Invalid Vision: " + + visionType + ". Had quote parens"); + } + type = visionType; + distance = "0"; + } + else + { + int length = visionType.length(); + if (visionType.indexOf(')') != length - 1) + { + throw new IllegalArgumentException("Invalid Vision: " + + visionType + ". Close paren not at end of string"); + } + int endDistance = length - 1; + if (quoteLoc != -1) + { + if (quoteLoc == length - 2) + { + endDistance--; + } + else + { + throw new IllegalArgumentException( + "Invalid Vision: " + + visionType + + ". Foot character ' not immediately before close paren"); + } + } + type = visionType.substring(0, openParenLoc).trim(); + distance = visionType.substring(openParenLoc + 1, endDistance); + if (distance.length() == 0) + { + throw new IllegalArgumentException("Invalid Vision: " + + visionType + ". No Distance provided"); + } + if (quoteLoc != -1) + { + try + { + Integer.parseInt(distance); + } + catch (NumberFormatException nfe) + { + throw new IllegalArgumentException( + "Invalid Vision: " + + visionType + + ". Vision Distance with Foot character ' was not an integer"); + } + } + } + if (type.length() == 0) + { + throw new IllegalArgumentException("Invalid Vision: " + visionType + + ". No Vision Type provided"); + } + return new Vision(VisionType.getVisionType(type), distance); } /* * REFACTOR NEED TO GET RID OF THIS - REFERENCES PlayerCharacter :( */ - public String toString(PlayerCharacter aPC) { + public String toString(PlayerCharacter aPC) + { return toString(aPC.getVariableValue(distance, "").intValue()); } } Modified: branches/cdom/code/src/java/pcgen/gui/editor/EditorMainForm.java =================================================================== --- branches/cdom/code/src/java/pcgen/gui/editor/EditorMainForm.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/pcgen/gui/editor/EditorMainForm.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -744,7 +744,7 @@ Race thisRace = (Race) thisPObject; //thisRace.setMovements(pnlMovement.getMoveRates()); - Movement cm = Movement.getMovementFrom(pnlMovement.getMoveValues()); + Movement cm = Movement.getOldMovementFrom(pnlMovement.getMoveValues()); cm.setMovementTypes(pnlMovement.getMoveTypes()); thisRace.setMovement(cm); @@ -908,7 +908,7 @@ case EditorConstants.EDIT_TEMPLATE: PCTemplate thisPCTemplate = (PCTemplate) thisPObject; - Movement cmv = Movement.getMovementFrom(pnlMovement.getMoveValues()); + Movement cmv = Movement.getOldMovementFrom(pnlMovement.getMoveValues()); cmv.setMoveRatesFlag(pnlMovement.getMoveRateType()); thisPCTemplate.setMovement(cmv); Modified: branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -24,23 +24,27 @@ import java.util.Set; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.PrereqObject; import pcgen.cdom.enumeration.AssociationKey; import pcgen.cdom.enumeration.SkillCost; import pcgen.cdom.graph.PCGraphAllowsEdge; import pcgen.cdom.graph.PCGraphEdge; +import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.PObject; import pcgen.core.Skill; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.GlobalLstToken; import pcgen.persistence.lst.utils.TokenUtilities; +import pcgen.util.Logging; /** * @author djones4 - * + * */ public class CcskillLst implements GlobalLstToken { @@ -64,6 +68,24 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); while (tok.hasMoreTokens()) { @@ -80,6 +102,8 @@ tokText.substring(7)); if (skill == null) { + Logging.errorPrint(" Error was encountered while parsing " + + getTokenName()); return false; } context.graph.unlinkChildNode(getTokenName(), obj, skill); @@ -97,6 +121,8 @@ tokText); if (skill == null) { + Logging.errorPrint(" Error was encountered while parsing " + + getTokenName()); return false; } PCGraphAllowsEdge edge = @@ -114,8 +140,13 @@ Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, SKILL_CLASS); - StringBuilder sb = new StringBuilder(); - boolean needsPipe = false; + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } + + Set<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); for (PCGraphEdge edge : edgeList) { if (!SkillCost.CROSS_CLASS.equals(edge @@ -126,17 +157,9 @@ + getTokenName()); return null; } - if (needsPipe) - { - sb.append(Constants.PIPE); - } - /* - * TODO FIXME This breaks for types... :( - */ - Skill sk = (Skill) edge.getSinkNodes().get(0); - sb.append(sk.getKeyName()); - needsPipe = true; + set.add((CDOMReference<?>) edge.getSinkNodes().get(0)); } - return new String[]{sb.toString()}; + return new String[]{ReferenceUtilities.joinLstFormat(set, + Constants.PIPE)}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -24,19 +24,23 @@ import java.util.Set; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.PrereqObject; import pcgen.cdom.enumeration.AssociationKey; import pcgen.cdom.enumeration.SkillCost; import pcgen.cdom.graph.PCGraphAllowsEdge; import pcgen.cdom.graph.PCGraphEdge; +import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.PObject; import pcgen.core.Skill; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.GlobalLstToken; import pcgen.persistence.lst.utils.TokenUtilities; +import pcgen.util.Logging; /** * @author djones4 @@ -64,6 +68,24 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); while (tok.hasMoreTokens()) { @@ -80,6 +102,8 @@ tokText.substring(7)); if (skill == null) { + Logging.errorPrint(" Error was encountered while parsing " + + getTokenName()); return false; } context.graph.unlinkChildNode(getTokenName(), obj, skill); @@ -97,6 +121,8 @@ tokText); if (skill == null) { + Logging.errorPrint(" Error was encountered while parsing " + + getTokenName()); return false; } PCGraphAllowsEdge edge = @@ -113,8 +139,12 @@ Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, SKILL_CLASS); - StringBuilder sb = new StringBuilder(); - boolean needsPipe = false; + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } + Set<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); for (PCGraphEdge edge : edgeList) { if (!SkillCost.CLASS.equals(edge @@ -124,17 +154,9 @@ + getTokenName()); return null; } - if (needsPipe) - { - sb.append(Constants.PIPE); - } - /* - * TODO FIXME This breaks for types... :( - */ - Skill sk = (Skill) edge.getSinkNodes().get(0); - sb.append(sk.getKeyName()); - needsPipe = true; + set.add((CDOMReference<?>) edge.getSinkNodes().get(0)); } - return new String[]{sb.toString()}; + return new String[]{ReferenceUtilities.joinLstFormat(set, + Constants.PIPE)}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/DrLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/DrLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/DrLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -127,18 +127,30 @@ } StringTokenizer tok = new StringTokenizer(value, "|"); - // String drString = tok.nextToken(); DamageReduction dr; try { - // dr = DamageReduction.getDamageReduction(drString); String[] values = tok.nextToken().split("/"); if (values.length != 2) { Logging.errorPrint(getTokenName() + " failed to build DamageReduction with value " + value); + Logging + .errorPrint(" ...expected a String with one / as a separator"); return false; } + if (values[0].length() == 0) + { + Logging.errorPrint("Amount of Reduction in " + getTokenName() + + " cannot be empty"); + return false; + } + if (values[1].length() == 0) + { + Logging.errorPrint("Damage Type in " + getTokenName() + + " cannot be empty"); + return false; + } dr = new DamageReduction(values[0], values[1]); } catch (IllegalArgumentException iae) @@ -168,6 +180,10 @@ Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, DamageReduction.class); + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } Set<String> set = new TreeSet<String>(); for (PCGraphEdge edge : edgeList) { Modified: branches/cdom/code/src/java/plugin/lsttokens/KitLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/KitLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/KitLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -26,8 +26,10 @@ import java.util.List; import java.util.Set; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.CDOMSimpleSingleRef; import pcgen.cdom.base.Constants; import pcgen.cdom.content.ChoiceSet; @@ -36,6 +38,7 @@ import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.GlobalLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; /** @@ -67,12 +70,36 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } final StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); ChoiceSet<CDOMSimpleSingleRef<Kit>> cl; try { int count = Integer.parseInt(tok.nextToken()); + if (count <= 0) + { + Logging.errorPrint("Count in " + getTokenName() + + " must be > 0"); + return false; + } cl = new ChoiceSet<CDOMSimpleSingleRef<Kit>>(count, tok .countTokens()); @@ -113,6 +140,8 @@ return null; } List<String> list = new ArrayList<String>(edgeList.size()); + Set<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); for (PCGraphEdge edge : edgeList) { StringBuilder sb = new StringBuilder(); @@ -120,7 +149,9 @@ (ChoiceSet<CDOMSimpleSingleRef<Kit>>) edge.getSinkNodes() .get(0); sb.append(cl.getCount()); - for (CDOMSimpleSingleRef<Kit> ref : cl.getSet()) + set.clear(); + set.addAll(cl.getSet()); + for (CDOMReference<?> ref : set) { sb.append(Constants.PIPE).append(ref.getLSTformat()); } Modified: branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -29,8 +29,6 @@ import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; -import pcgen.cdom.base.PrereqObject; -import pcgen.cdom.content.ChoiceSet; import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.Language; @@ -38,6 +36,7 @@ import pcgen.persistence.LoadContext; import pcgen.persistence.lst.GlobalLstToken; import pcgen.persistence.lst.utils.TokenUtilities; +import pcgen.util.Logging; /** * @author djones4 @@ -66,6 +65,25 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { + if (value.charAt(0) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with , : " + value); + return false; + } + if (value.charAt(value.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with , : " + value); + return false; + } + if (value.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator ,, : " + value); + return false; + } + final StringTokenizer tok = new StringTokenizer(value, Constants.COMMA); while (tok.hasMoreTokens()) @@ -76,23 +94,18 @@ context.graph.unlinkChildNodesOfClass(getTokenName(), obj, LANGUAGE_CLASS); } - else if (Constants.LST_ALL.equalsIgnoreCase(tokText)) - { - context.graph.linkObjectIntoGraph(getTokenName(), obj, - context.ref.getCDOMAllReference(LANGUAGE_CLASS)); - } - else if (tokText.startsWith(Constants.LST_TYPE) - || tokText.startsWith(Constants.LST_TYPE_OLD)) - { - String[] val = {tokText.substring(5)}; - context.graph.linkObjectIntoGraph(getTokenName(), obj, - context.ref.getCDOMTypeReference(LANGUAGE_CLASS, val)); - } else { - PrereqObject lang = - context.ref.getCDOMReference(LANGUAGE_CLASS, tokText); - context.graph.linkObjectIntoGraph(getTokenName(), obj, lang); + CDOMReference<Language> ref = + TokenUtilities.getObjectReference(context, + LANGUAGE_CLASS, tokText); + if (ref == null) + { + Logging.errorPrint(" Error was encountered while parsing " + + getTokenName()); + return false; + } + context.graph.linkObjectIntoGraph(getTokenName(), obj, ref); } } return true; @@ -111,10 +124,9 @@ new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); for (PCGraphEdge edge : edges) { - set.addAll(((ChoiceSet<CDOMReference<?>>) edge.getSinkNodes() - .get(0)).getSet()); + set.add((CDOMReference<?>) edge.getSinkNodes().get(0)); } return new String[]{ReferenceUtilities.joinLstFormat(set, - Constants.PIPE)}; + Constants.COMMA)}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/MoveLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/MoveLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/MoveLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -22,16 +22,21 @@ */ package plugin.lsttokens; +import java.math.BigDecimal; import java.util.Set; +import java.util.StringTokenizer; import java.util.TreeSet; +import pcgen.base.lang.StringUtil; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.content.SimpleMovement; import pcgen.cdom.graph.PCGraphEdge; import pcgen.core.Equipment; import pcgen.core.Movement; import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.GlobalLstToken; +import pcgen.util.Logging; /** * @author djones4 @@ -51,7 +56,7 @@ { return false; } - Movement cm = Movement.getMovementFrom(value); + Movement cm = Movement.getOldMovementFrom(value); cm.setMoveRatesFlag(0); obj.setMovement(cm); return true; @@ -59,9 +64,85 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { - Movement cm = Movement.getMovementFrom(value); - cm.setMoveRatesFlag(0); - context.graph.linkObjectIntoGraph(getTokenName(), obj, cm); + if (value == null) + { + Logging.errorPrint("Error encountered while parsing " + + getTokenName() + ": " + value); + Logging.errorPrint(" Null initialization String illegal"); + return false; + } + if (value.length() == 0) + { + Logging.errorPrint("Error encountered while parsing " + + getTokenName() + ": " + value); + Logging.errorPrint(" Empty initialization String illegal"); + return false; + } + if (value.charAt(0) == ',') + { + Logging.errorPrint("Error encountered while parsing " + + getTokenName() + ": " + value); + Logging.errorPrint(" Movement arguments may not start with ,| : " + + value); + return false; + } + if (value.charAt(value.length() - 1) == ',') + { + Logging.errorPrint("Error encountered while parsing " + + getTokenName() + ": " + value); + Logging.errorPrint(" Movement arguments may not end with , : " + + value); + return false; + } + if (value.indexOf(",,") != -1) + { + Logging.errorPrint("Error encountered while parsing " + + getTokenName() + ": " + value); + Logging + .errorPrint(" Movement arguments uses double separator ,, : " + + value); + return false; + } + final StringTokenizer moves = new StringTokenizer(value, ","); + + int tokenCount = moves.countTokens(); + if (tokenCount % 2 != 0) + { + Logging.errorPrint("Error encountered while parsing " + + getTokenName() + ": " + value); + Logging + .errorPrint(" String must value count that is a multiple of 2: " + + value); + return false; + } + while (moves.hasMoreTokens()) + { + String moveType = moves.nextToken(); // e.g. "Walk" + String moveDistance = moves.nextToken(); + + try + { + BigDecimal distance = new BigDecimal(moveDistance); + if (distance.compareTo(BigDecimal.ZERO) < 0) + { + Logging.errorPrint("Error encountered while parsing " + + getTokenName() + ": " + value); + Logging.errorPrint(" Distance: " + moveDistance + + " was negative"); + return false; + } + context.graph.linkObjectIntoGraph(getTokenName(), obj, + new SimpleMovement(moveType, distance)); + } + catch (NumberFormatException e) + { + Logging.errorPrint("Error encountered while parsing " + + getTokenName() + ": " + value); + Logging.errorPrint(" Badly formed MOVE token: " + moveDistance + + " was not a double"); + return false; + } + } return true; } @@ -69,13 +150,17 @@ { Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, - Movement.class); + SimpleMovement.class); + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } Set<String> set = new TreeSet<String>(); for (PCGraphEdge edge : edgeList) { - Movement m = (Movement) edge.getSinkNodes().get(0); + SimpleMovement m = (SimpleMovement) edge.getSinkNodes().get(0); set.add(m.toLSTString()); } - return set.toArray(new String[set.size()]); + return new String[]{StringUtil.join(set, ",")}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -46,7 +46,7 @@ public boolean parse(PObject obj, String value, int anInt) { - Movement cm = Movement.getMovementFrom(value); + Movement cm = Movement.getOldMovementFrom(value); cm.setMoveRatesFlag(1); obj.setMovement(cm); return true; @@ -65,6 +65,10 @@ Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, Movement.class); + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } Set<String> set = new TreeSet<String>(); for (PCGraphEdge edge : edgeList) { Modified: branches/cdom/code/src/java/plugin/lsttokens/MovecloneLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/MovecloneLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/MovecloneLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -46,7 +46,7 @@ public boolean parse(PObject obj, String value, int anInt) { - Movement cm = Movement.getMovementFrom(value); + Movement cm = Movement.getOldMovementFrom(value); cm.setMoveRatesFlag(2); obj.setMovement(cm); return true; @@ -65,6 +65,10 @@ Set<PCGraphEdge> edgeList = context.graph.getChildLinksFromToken(getTokenName(), obj, Movement.class); + if (edgeList == null || edgeList.isEmpty()) + { + return null; + } Set<String> set = new TreeSet<String>(); for (PCGraphEdge edge : edgeList) { Modified: branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -71,13 +71,37 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { - obj.setNamePI(value.charAt(0) != 'N'); + boolean set; + char firstChar = value.charAt(0); + if (firstChar == 'y' || firstChar == 'Y') + { + if (value.length() > 1 && !value.equalsIgnoreCase("YES")) + { + Logging.errorPrint("You should use 'YES' as the " + + getTokenName() + ": " + value); + return false; + } + set = true; + } + else + { + if (firstChar != 'N' && firstChar != 'n') + { + if (value.length() > 1 && !value.equalsIgnoreCase("NO")) + { + Logging.errorPrint("You should use 'YES' or 'NO' as the " + + getTokenName() + ": " + value); + return false; + } + } + set = false; + } + obj.setNamePI(set); return true; } public String[] unparse(LoadContext context, CDOMObject obj) { - boolean namePI = obj.isNamePI(); - return new String[]{namePI ? "YES" : "NO"}; + return new String[]{obj.isNamePI() ? "YES" : "NO"}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/SaLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/SaLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/SaLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -146,8 +146,7 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { - parseSpecialAbility(context, obj, value); - return true; + return parseSpecialAbility(context, obj, value); } /** @@ -164,14 +163,33 @@ public boolean parseSpecialAbility(LoadContext context, CDOMObject obj, String aString) { - StringTokenizer tok = new StringTokenizer(aString, Constants.PIPE); - if (aString == null || aString.length() == 0) { Logging.errorPrint("SA: line minimally requires SA:<text>"); return false; } + if (aString.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + aString); + return false; + } + if (aString.charAt(aString.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + aString); + return false; + } + if (aString.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + aString); + return false; + } + + StringTokenizer tok = new StringTokenizer(aString, Constants.PIPE); + String firstToken = tok.nextToken(); if (Constants.LST_DOT_CLEAR.equals(firstToken)) @@ -189,10 +207,10 @@ } SpecialAbility sa = new SpecialAbility(firstToken); - context.graph.linkObjectIntoGraph(getTokenName(), obj, sa); if (!tok.hasMoreTokens()) { + context.graph.linkObjectIntoGraph(getTokenName(), obj, sa); return true; } @@ -208,23 +226,25 @@ + "middle token: " + aString); return false; } + else if (token.startsWith("PRE") || token.startsWith("!PRE")) + { + break; + } else { - saName.append(token); + saName.append(Constants.PIPE).append(token); // sa.addVariable(FormulaFactory.getFormulaFor(token)); } if (!tok.hasMoreTokens()) { // No prereqs, so we're done + // CONSIDER This is a HACK and not the long term strategy of SA: + sa.setName(saName.toString()); + context.graph.linkObjectIntoGraph(getTokenName(), obj, sa); return true; } token = tok.nextToken(); - if (token.startsWith("PRE") || token.startsWith("!PRE")) - { - break; - } - saName.append(Constants.PIPE); } // CONSIDER This is a HACK and not the long term strategy of SA: sa.setName(saName.toString()); @@ -255,8 +275,8 @@ } token = tok.nextToken(); } + context.graph.linkObjectIntoGraph(getTokenName(), obj, sa); return true; - } public String[] unparse(LoadContext context, CDOMObject obj) @@ -274,7 +294,7 @@ { StringBuilder sb = new StringBuilder(); SpecialAbility ab = (SpecialAbility) edge.getSinkNodes().get(0); - sb.append(ab.getKeyName()); + sb.append(ab.getDisplayName()); List<Prerequisite> prereqs = ab.getPrerequisiteList(); if (prereqs != null && !prereqs.isEmpty()) { Modified: branches/cdom/code/src/java/plugin/lsttokens/TemplateLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/TemplateLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/TemplateLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -70,13 +70,32 @@ { if (value.startsWith(Constants.LST_CHOOSE)) { - return parseChoose(context, obj, value); + return parseChoose(context, obj, value.substring(7)); } else if (value.startsWith(Constants.LST_ADDCHOICE)) { return parseAddChoice(context, obj, value); } + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } + final StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); while (tok.hasMoreTokens()) @@ -106,8 +125,27 @@ private boolean parseChoose(LoadContext context, CDOMObject obj, String value) { - StringTokenizer tok = - new StringTokenizer(value.substring(7), Constants.PIPE); + + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } + + StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); ChoiceSet<CDOMSimpleSingleRef<PCTemplate>> cl = new ChoiceSet<CDOMSimpleSingleRef<PCTemplate>>(1, tok .countTokens()); @@ -128,6 +166,12 @@ ChoiceSet.class); if (edgeSet.size() != 1) { + /* + * BUG FIXME The problem here is that the CHOOSE isn't necessarily + * on THIS object... apparently CHOOSE is global, which leads to all + * kinds of conflict problems if a character can get more than one + * somehow :( + */ Logging.errorPrint(getTokenName() + ":ADDCHOICE cannot be performed because more than " + "one ChoiceList is attached to " @@ -160,6 +204,8 @@ } String[] array = new String[arrayLength]; int index = 0; + Set<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); if (!choiceEdgeList.isEmpty()) { if (choiceEdgeList.size() > 1) @@ -171,15 +217,14 @@ ChoiceSet<CDOMSimpleSingleRef<PCTemplate>> cl = (ChoiceSet<CDOMSimpleSingleRef<PCTemplate>>) choiceEdgeList .iterator().next().getSinkNodes().get(0); + set.addAll(cl.getSet()); array[index++] = - ReferenceUtilities.joinLstFormat(cl.getSet(), - Constants.PIPE); + "CHOOSE:" + + ReferenceUtilities.joinLstFormat(set, Constants.PIPE); } if (!templateEdgeList.isEmpty()) { - Set<CDOMReference<?>> set = - new TreeSet<CDOMReference<?>>( - TokenUtilities.REFERENCE_SORTER); + set.clear(); for (PCGraphEdge edge : templateEdgeList) { CDOMReference<?> pct = Modified: branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -33,6 +33,7 @@ import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.GlobalLstToken; +import pcgen.util.Logging; /** * @author djones4 @@ -54,6 +55,29 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " arguments may not be empty"); + return false; + } + if (value.charAt(0) == '.') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with . : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '.') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with . : " + value); + return false; + } + if (value.indexOf("..") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator .. : " + value); + return false; + } StringTokenizer aTok = new StringTokenizer(value.trim(), Constants.DOT); boolean removeType = false; Modified: branches/cdom/code/src/java/plugin/lsttokens/UmultLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/UmultLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/UmultLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -28,6 +28,7 @@ import pcgen.core.PObject; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.GlobalLstToken; +import pcgen.util.Logging; /** * @author djones4 @@ -62,7 +63,24 @@ } else { - obj.put(IntegerKey.UMULT, Integer.valueOf(value)); + try + { + Integer i = Integer.valueOf(value); + if (i.intValue() <= 0) + { + Logging.errorPrint("Invalid " + getTokenName() + ": " + + value); + Logging.errorPrint(" Expecting a positive integer"); + return false; + } + obj.put(IntegerKey.UMULT, i); + } + catch (NumberFormatException nfe) + { + Logging.errorPrint("Invalid " + getTokenName() + ": " + value); + Logging.errorPrint(" Expecting an integer"); + return false; + } } return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/UnencumberedmoveLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/UnencumberedmoveLst.java 2007-03-26 23:25:59 UTC (rev 2591) +++ branches/cdom/code/src/java/plugin/lsttokens/UnencumberedmoveLst.java 2007-03-26 23:37:47 UTC (rev 2592) @@ -51,13 +51,13 @@ { obj.setEncumberedLoadMove(Load.LIGHT, anInt); obj.setEncumberedArmorMove(Load.LIGHT, anInt); - + final StringTokenizer st = new StringTokenizer(value, "|"); - + while (st.hasMoreTokens()) { final String loadString = st.nextToken(); - + if (loadString.equalsIgnoreCase("MediumLoad")) { obj.setEncumberedLoadMove(Load.MEDIUM, anInt); @@ -78,14 +78,16 @@ { obj.setEncumberedArmorMove(Load.OVERLOAD, anInt); } - else if (loadString.equalsIgnoreCase("LightLoad") || loadString.equalsIgnoreCase("LightArmor")) + else if (loadString.equalsIgnoreCase("LightLoad") + || loadString.equalsIgnoreCase("LightArmor")) { - //do nothing, but accept values as valid + // do nothing, but accept values as valid } else { - ShowMessageDelegate.showMessageDialog("Invalid value of \"" + loadString + "\" for UNENCUMBEREDMOVE in \"" + obj.getDisplayName() + "\".", - "PCGen", MessageType.ERROR); + ShowMessageDelegate.showMessageDialog("Invalid value of \"" + + loadString + "\" for UNENCUMBEREDMOVE in \"" + + obj.getDisplayName() + "\".", "PCGen", MessageType.ERROR); } } return true; @@ -93,15 +95,45 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may no... [truncated message content] |
From: <th...@us...> - 2007-03-30 01:14:53
|
Revision: 2615 http://svn.sourceforge.net/pcgen/?rev=2615&view=rev Author: thpr Date: 2007-03-29 18:14:54 -0700 (Thu, 29 Mar 2007) Log Message: ----------- CDOM: Test polishing Modified Paths: -------------- branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java branches/cdom/code/src/java/plugin/lsttokens/add/TemplateToken.java branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/AppearanceToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/SymbolToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/TitleToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/WorshippersToken.java branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AltcritmultToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/CritmultToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/EqmodToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/RateoffireToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/FumblerangeToken.java branches/cdom/code/src/java/plugin/lsttokens/race/CrToken.java branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/race/LangbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java branches/cdom/code/src/java/plugin/lsttokens/race/WeaponbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/SpellresToken.java branches/cdom/code/src/java/plugin/lsttokens/template/CrToken.java branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/template/LangbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/template/TemplateToken.java branches/cdom/code/src/java/plugin/lsttokens/template/WeaponbonusToken.java branches/cdom/code/src/test/plugin/lsttokens/auto/AbstractProfTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/deity/DomainsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/equipment/AbstractCritMultTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/race/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/ClassesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/skill/VisibleTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/ClassesTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/spell/DomainsTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/template/FeatTokenTest.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractListTokenTestCase.java branches/cdom/code/src/test/plugin/lsttokens/testsupport/AbstractStringTokenTestCase.java Modified: branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -153,12 +153,12 @@ public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { - StringTokenizer st = new StringTokenizer(value, Constants.PIPE); - if (!st.hasMoreTokens()) + if (value.length() == 0) { - Logging.errorPrint("Invalid " + getTokenName() + ": is Empty"); + Logging.errorPrint(getTokenName() + " may not have empty argument"); return false; } + StringTokenizer st = new StringTokenizer(value, Constants.PIPE); String nextToken = st.nextToken(); int count; Modified: branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -83,6 +83,11 @@ public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); int count; String items; Modified: branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -43,6 +43,11 @@ public boolean parse(PObject target, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); String countString; String items; Modified: branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -44,6 +44,11 @@ public boolean parse(PObject target, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); String countString; String items; Modified: branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -43,6 +43,11 @@ public boolean parse(PObject target, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); String countString; String items; Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SAToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -44,6 +44,11 @@ public boolean parse(PObject target, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); if (pipeLoc == -1) { Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -44,6 +44,11 @@ public boolean parse(PObject target, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); String countString; String items; Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -45,6 +45,11 @@ public boolean parse(PObject target, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); String countString; String items; Modified: branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/SpellLevelToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -56,7 +56,7 @@ if (!value.startsWith("CLASS|SPELLCASTER.")) { Logging.errorPrint(getTokenName() - + " syntax starts with CLASS|SPELLCASTER."); + + " syntax must start with CLASS|SPELLCASTER."); return false; } String classSpell = value.substring(18); Modified: branches/cdom/code/src/java/plugin/lsttokens/add/TemplateToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/TemplateToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/TemplateToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -74,6 +74,11 @@ public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); int count; String items; Modified: branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -76,6 +76,11 @@ public boolean parse(LoadContext context, PObject obj, String value) throws PersistenceLayerException { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } int pipeLoc = value.indexOf(Constants.PIPE); int count; String items; Modified: branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -17,11 +17,15 @@ */ package plugin.lsttokens.auto; +import java.io.StringWriter; +import java.util.HashSet; +import java.util.List; import java.util.Set; import java.util.SortedSet; import java.util.StringTokenizer; import java.util.TreeSet; +import pcgen.base.util.HashMapToList; import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.graph.PCGraphEdge; @@ -29,16 +33,19 @@ import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.ArmorProf; import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.AutoLstToken; -import pcgen.persistence.lst.prereq.PreParserFactory; +import pcgen.persistence.lst.output.prereq.PrerequisiteWriter; import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; -public class ArmorProfToken implements AutoLstToken +public class ArmorProfToken extends AbstractToken implements AutoLstToken { + @Override public String getTokenName() { return "ARMORPROF"; @@ -53,7 +60,7 @@ public boolean parse(LoadContext context, PObject obj, String value) { String armorProfs; - String prereq = null; // Do not initialize, null is significant! + Prerequisite prereq = null; // Do not initialize, null is significant! /* * CONSIDER There is the ability to consolidate this PREREQ processing @@ -72,8 +79,17 @@ { Logging.errorPrint("Unresolved Prerequisite in " + getTokenName() + " " + value + " in " + getTokenName()); + return false; } - prereq = value.substring(openBracketLoc + 1, value.length() - 2); + prereq = + getPrerequisite(value.substring(openBracketLoc + 1, value + .length() - 1)); + if (prereq == null) + { + Logging.errorPrint("Error generating Prerequisite " + prereq + + " in " + getTokenName()); + return false; + } } if (armorProfs.charAt(0) == '|') @@ -125,16 +141,7 @@ ref); if (prereq != null) { - try - { - edge.addPreReq(PreParserFactory.getInstance().parse( - prereq)); - } - catch (PersistenceLayerException e) - { - Logging.errorPrint("Error generating Prerequisite " - + prereq + " in " + getTokenName()); - } + edge.addPreReq(prereq); } } } @@ -147,18 +154,55 @@ Set<PCGraphEdge> edges = context.graph.getChildLinksFromToken(getTokenName(), obj, ArmorProf.class); - if (edges.isEmpty()) + if (edges == null || edges.isEmpty()) { return null; } - SortedSet<CDOMReference<ArmorProf>> set = - new TreeSet<CDOMReference<ArmorProf>>( - TokenUtilities.REFERENCE_SORTER); + HashMapToList<Set<Prerequisite>, CDOMReference<ArmorProf>> m = + new HashMapToList<Set<Prerequisite>, CDOMReference<ArmorProf>>(); for (PCGraphEdge edge : edges) { - set.add((CDOMReference<ArmorProf>) edge.getSinkNodes().get(0)); + CDOMReference<ArmorProf> ab = + (CDOMReference<ArmorProf>) edge.getSinkNodes().get(0); + m.addToListFor( + new HashSet<Prerequisite>(edge.getPrerequisiteList()), ab); } - return new String[]{ReferenceUtilities.joinLstFormat(set, - Constants.PIPE)}; + + PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); + SortedSet<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); + + String[] array = new String[m.size()]; + int index = 0; + + for (Set<Prerequisite> prereqs : m.getKeySet()) + { + List<CDOMReference<ArmorProf>> profs = m.getListFor(prereqs); + set.clear(); + set.addAll(profs); + String ab = ReferenceUtilities.joinLstFormat(set, Constants.PIPE); + if (prereqs != null && !prereqs.isEmpty()) + { + if (prereqs.size() > 1) + { + // TODO Document Error + return null; + } + Prerequisite p = prereqs.iterator().next(); + StringWriter swriter = new StringWriter(); + try + { + prereqWriter.write(swriter, p); + } + catch (PersistenceLayerException e) + { + context.addWriteMessage("Error writing Prerequisite: " + e); + return null; + } + ab = ab + '[' + swriter.toString() + ']'; + } + array[index++] = ab; + } + return array; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -17,11 +17,15 @@ */ package plugin.lsttokens.auto; +import java.io.StringWriter; +import java.util.HashSet; +import java.util.List; import java.util.Set; import java.util.SortedSet; import java.util.StringTokenizer; import java.util.TreeSet; +import pcgen.base.util.HashMapToList; import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.graph.PCGraphEdge; @@ -29,16 +33,19 @@ import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.PObject; import pcgen.core.ShieldProf; +import pcgen.core.prereq.Prerequisite; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.AutoLstToken; -import pcgen.persistence.lst.prereq.PreParserFactory; +import pcgen.persistence.lst.output.prereq.PrerequisiteWriter; import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; -public class ShieldProfToken implements AutoLstToken +public class ShieldProfToken extends AbstractToken implements AutoLstToken { + @Override public String getTokenName() { return "SHIELDPROF"; @@ -53,7 +60,7 @@ public boolean parse(LoadContext context, PObject obj, String value) { String shieldProfs; - String prereq = null; // Do not initialize, null is significant! + Prerequisite prereq = null; // Do not initialize, null is significant! // Note: May contain PRExxx if (value.indexOf("[") == -1) @@ -68,8 +75,17 @@ { Logging.errorPrint("Unresolved Prerequisite in " + getTokenName() + " " + value + " in " + getTokenName()); + return false; } - prereq = value.substring(openBracketLoc + 1, value.length() - 2); + prereq = + getPrerequisite(value.substring(openBracketLoc + 1, value + .length() - 1)); + if (prereq == null) + { + Logging.errorPrint("Error generating Prerequisite " + prereq + + " in " + getTokenName()); + return false; + } } if (shieldProfs.charAt(0) == '|') @@ -121,16 +137,7 @@ ref); if (prereq != null) { - try - { - edge.addPreReq(PreParserFactory.getInstance().parse( - prereq)); - } - catch (PersistenceLayerException e) - { - Logging.errorPrint("Error generating Prerequisite " - + prereq + " in " + getTokenName()); - } + edge.addPreReq(prereq); } } } @@ -143,18 +150,55 @@ Set<PCGraphEdge> edges = context.graph.getChildLinksFromToken(getTokenName(), obj, ShieldProf.class); - if (edges.isEmpty()) + if (edges == null || edges.isEmpty()) { return null; } - SortedSet<CDOMReference<ShieldProf>> set = - new TreeSet<CDOMReference<ShieldProf>>( - TokenUtilities.REFERENCE_SORTER); + HashMapToList<Set<Prerequisite>, CDOMReference<ShieldProf>> m = + new HashMapToList<Set<Prerequisite>, CDOMReference<ShieldProf>>(); for (PCGraphEdge edge : edges) { - set.add((CDOMReference<ShieldProf>) edge.getSinkNodes().get(0)); + CDOMReference<ShieldProf> ab = + (CDOMReference<ShieldProf>) edge.getSinkNodes().get(0); + m.addToListFor( + new HashSet<Prerequisite>(edge.getPrerequisiteList()), ab); } - return new String[]{ReferenceUtilities.joinLstFormat(set, - Constants.PIPE)}; + + PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); + SortedSet<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); + + String[] array = new String[m.size()]; + int index = 0; + + for (Set<Prerequisite> prereqs : m.getKeySet()) + { + List<CDOMReference<ShieldProf>> profs = m.getListFor(prereqs); + set.clear(); + set.addAll(profs); + String ab = ReferenceUtilities.joinLstFormat(set, Constants.PIPE); + if (prereqs != null && !prereqs.isEmpty()) + { + if (prereqs.size() > 1) + { + // TODO Document Error + return null; + } + Prerequisite p = prereqs.iterator().next(); + StringWriter swriter = new StringWriter(); + try + { + prereqWriter.write(swriter, p); + } + catch (PersistenceLayerException e) + { + context.addWriteMessage("Error writing Prerequisite: " + e); + return null; + } + ab = ab + '[' + swriter.toString() + ']'; + } + array[index++] = ab; + } + return array; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -17,11 +17,15 @@ */ package plugin.lsttokens.auto; +import java.io.StringWriter; +import java.util.HashSet; +import java.util.List; import java.util.Set; import java.util.SortedSet; import java.util.StringTokenizer; import java.util.TreeSet; +import pcgen.base.util.HashMapToList; import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.graph.PCGraphEdge; @@ -29,16 +33,19 @@ import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.PObject; import pcgen.core.WeaponProf; +import pcgen.core.prereq.Prerequisite; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.AutoLstToken; -import pcgen.persistence.lst.prereq.PreParserFactory; +import pcgen.persistence.lst.output.prereq.PrerequisiteWriter; import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; -public class WeaponProfToken implements AutoLstToken +public class WeaponProfToken extends AbstractToken implements AutoLstToken { + @Override public String getTokenName() { return "WEAPONPROF"; @@ -53,7 +60,7 @@ public boolean parse(LoadContext context, PObject obj, String value) { String weaponProfs; - String prereq = null; // Do not initialize, null is significant! + Prerequisite prereq = null; // Do not initialize, null is significant! // Note: May contain PRExxx if (value.indexOf("[") == -1) @@ -68,8 +75,17 @@ { Logging.errorPrint("Unresolved Prerequisite in " + getTokenName() + " " + value + " in " + getTokenName()); + return false; } - prereq = value.substring(openBracketLoc + 1, value.length() - 2); + prereq = + getPrerequisite(value.substring(openBracketLoc + 1, value + .length() - 1)); + if (prereq == null) + { + Logging.errorPrint("Error generating Prerequisite " + prereq + + " in " + getTokenName()); + return false; + } } if (weaponProfs.charAt(0) == '|') @@ -121,16 +137,7 @@ ref); if (prereq != null) { - try - { - edge.addPreReq(PreParserFactory.getInstance().parse( - prereq)); - } - catch (PersistenceLayerException e) - { - Logging.errorPrint("Error generating Prerequisite " - + prereq + " in " + getTokenName()); - } + edge.addPreReq(prereq); } } } @@ -143,19 +150,56 @@ Set<PCGraphEdge> edges = context.graph.getChildLinksFromToken(getTokenName(), obj, WeaponProf.class); - if (edges.isEmpty()) + if (edges == null || edges.isEmpty()) { return null; } - SortedSet<CDOMReference<WeaponProf>> set = - new TreeSet<CDOMReference<WeaponProf>>( - TokenUtilities.REFERENCE_SORTER); + HashMapToList<Set<Prerequisite>, CDOMReference<WeaponProf>> m = + new HashMapToList<Set<Prerequisite>, CDOMReference<WeaponProf>>(); for (PCGraphEdge edge : edges) { - set.add((CDOMReference<WeaponProf>) edge.getSinkNodes().get(0)); + CDOMReference<WeaponProf> ab = + (CDOMReference<WeaponProf>) edge.getSinkNodes().get(0); + m.addToListFor( + new HashSet<Prerequisite>(edge.getPrerequisiteList()), ab); } - return new String[]{ReferenceUtilities.joinLstFormat(set, - Constants.PIPE)}; + + PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); + SortedSet<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); + + String[] array = new String[m.size()]; + int index = 0; + + for (Set<Prerequisite> prereqs : m.getKeySet()) + { + List<CDOMReference<WeaponProf>> profs = m.getListFor(prereqs); + set.clear(); + set.addAll(profs); + String ab = ReferenceUtilities.joinLstFormat(set, Constants.PIPE); + if (prereqs != null && !prereqs.isEmpty()) + { + if (prereqs.size() > 1) + { + // TODO Document Error + return null; + } + Prerequisite p = prereqs.iterator().next(); + StringWriter swriter = new StringWriter(); + try + { + prereqWriter.write(swriter, p); + } + catch (PersistenceLayerException e) + { + context.addWriteMessage("Error writing Prerequisite: " + e); + return null; + } + ab = ab + '[' + swriter.toString() + ']'; + } + array[index++] = ab; + } + return array; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/deity/AppearanceToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/deity/AppearanceToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/deity/AppearanceToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -25,6 +25,7 @@ import pcgen.core.Deity; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.DeityLstToken; +import pcgen.util.Logging; /** * Class deals with APPEARANCE Token @@ -45,6 +46,11 @@ public boolean parse(LoadContext context, Deity deity, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " arguments may not be empty"); + return false; + } deity.put(StringKey.APPEARANCE, value); return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/deity/SymbolToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/deity/SymbolToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/deity/SymbolToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -25,6 +25,7 @@ import pcgen.core.Deity; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.DeityLstToken; +import pcgen.util.Logging; /** * Class deals with SYMBOL Token @@ -45,6 +46,11 @@ public boolean parse(LoadContext context, Deity deity, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " arguments may not be empty"); + return false; + } deity.put(StringKey.HOLY_ITEM, value); return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/deity/TitleToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/deity/TitleToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/deity/TitleToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -25,6 +25,7 @@ import pcgen.core.Deity; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.DeityLstToken; +import pcgen.util.Logging; /** * Class deals with TITLE Token @@ -45,6 +46,11 @@ public boolean parse(LoadContext context, Deity deity, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " arguments may not be empty"); + return false; + } deity.put(StringKey.TITLE, value); return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/deity/WorshippersToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/deity/WorshippersToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/deity/WorshippersToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -25,6 +25,7 @@ import pcgen.core.Deity; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.DeityLstToken; +import pcgen.util.Logging; /** * Class deals with WORSHIPPERS Token @@ -57,6 +58,11 @@ public boolean parse(LoadContext context, Deity deity, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " arguments may not be empty"); + return false; + } deity.put(StringKey.WORSHIPPERS, value); return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -77,6 +77,11 @@ public boolean parseFeat(LoadContext context, CDOMObject obj, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/AltcritmultToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipment/AltcritmultToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/equipment/AltcritmultToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -68,39 +68,33 @@ public boolean parse(LoadContext context, Equipment eq, String value) { EquipmentHead altHead = getEquipmentHead(context, eq, 2); - try + if ((value.length() > 0) && (value.charAt(0) == 'x')) { - if ((value.length() > 0) && (value.charAt(0) == 'x')) + try { - try + Integer cm = Integer.valueOf(value.substring(1)); + if (cm.intValue() <= 0) { - Integer cm = Integer.valueOf(value.substring(1)); - if (cm.intValue() <= 0) - { - Logging.errorPrint(getTokenName() + " cannot be <= 0"); - return false; - } - altHead.put(IntegerKey.CRIT_MULT, cm); - return true; - } - catch (NumberFormatException nfe) - { + Logging.errorPrint(getTokenName() + " cannot be <= 0"); return false; } + altHead.put(IntegerKey.CRIT_MULT, cm); + return true; } - else if ("-".equals(value)) + catch (NumberFormatException nfe) { - altHead.put(IntegerKey.CRIT_MULT, Integer.valueOf(-1)); - return true; + return false; } - return false; } - catch (NumberFormatException nfe) + else if ("-".equals(value)) { - Logging.errorPrint(getTokenName() + " expected an integer. " - + "Tag must be of the form: " + getTokenName() + ":<int>"); - return false; + altHead.put(IntegerKey.CRIT_MULT, Integer.valueOf(-1)); + return true; } + Logging.errorPrint(getTokenName() + + " was expecting x followed by an integer " + + "or the special value '-' (representing no value)"); + return false; } protected EquipmentHead getEquipmentHead(LoadContext context, Equipment eq, Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -69,6 +69,11 @@ protected boolean parseEqMod(LoadContext context, EquipmentHead primHead, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (Constants.LST_NONE.equals(value)) { return true; Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/CritmultToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipment/CritmultToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/equipment/CritmultToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -68,39 +68,33 @@ public boolean parse(LoadContext context, Equipment eq, String value) { EquipmentHead primHead = getEquipmentHead(context, eq, 1); - try + if ((value.length() > 0) && (value.charAt(0) == 'x')) { - if ((value.length() > 0) && (value.charAt(0) == 'x')) + try { - try + Integer cm = Integer.valueOf(value.substring(1)); + if (cm.intValue() <= 0) { - Integer cm = Integer.valueOf(value.substring(1)); - if (cm.intValue() <= 0) - { - Logging.errorPrint(getTokenName() + " cannot be <= 0"); - return false; - } - primHead.put(IntegerKey.CRIT_MULT, cm); - return true; - } - catch (NumberFormatException nfe) - { + Logging.errorPrint(getTokenName() + " cannot be <= 0"); return false; } + primHead.put(IntegerKey.CRIT_MULT, cm); + return true; } - else if ("-".equals(value)) + catch (NumberFormatException nfe) { - primHead.put(IntegerKey.CRIT_MULT, Integer.valueOf(-1)); - return true; + return false; } - return false; } - catch (NumberFormatException nfe) + else if ("-".equals(value)) { - Logging.errorPrint(getTokenName() + " expected an integer. " - + "Tag must be of the form: " + getTokenName() + ":<int>"); - return false; + primHead.put(IntegerKey.CRIT_MULT, Integer.valueOf(-1)); + return true; } + Logging.errorPrint(getTokenName() + + " was expecting x followed by an integer " + + "or the special value '-' (representing no value)"); + return false; } protected EquipmentHead getEquipmentHead(LoadContext context, Equipment eq, Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/EqmodToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipment/EqmodToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/equipment/EqmodToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -69,6 +69,11 @@ protected boolean parseEqMod(LoadContext context, EquipmentHead primHead, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (Constants.LST_NONE.equals(value)) { return true; Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/RateoffireToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipment/RateoffireToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/equipment/RateoffireToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -25,6 +25,7 @@ import pcgen.core.Equipment; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.EquipmentLstToken; +import pcgen.util.Logging; /** * Deals with RATEOFFIRE token @@ -45,6 +46,11 @@ public boolean parse(LoadContext context, Equipment eq, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " argument may not be empty"); + return false; + } eq.put(StringKey.RATE_OF_FIRE, value); return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/FumblerangeToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/FumblerangeToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/FumblerangeToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -25,6 +25,7 @@ import pcgen.core.EquipmentModifier; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.EquipmentModifierLstToken; +import pcgen.util.Logging; /** * Deals with FUMBLERANGE token @@ -46,6 +47,11 @@ public boolean parse(LoadContext context, EquipmentModifier mod, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } mod.put(StringKey.FUMBLE_RANGE, value); return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/CrToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/CrToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/race/CrToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -60,16 +60,9 @@ public boolean parse(LoadContext context, Race race, String value) { - try - { - ChallengeRating cr = new ChallengeRating(value); - context.graph.linkObjectIntoGraph(getTokenName(), race, cr); - return true; - } - catch (NumberFormatException nfe) - { - return false; - } + ChallengeRating cr = new ChallengeRating(value); + context.graph.linkObjectIntoGraph(getTokenName(), race, cr); + return true; } public String[] unparse(LoadContext context, Race race) Modified: branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -30,6 +30,7 @@ import java.util.StringTokenizer; import java.util.TreeSet; +import pcgen.base.lang.StringUtil; import pcgen.base.util.HashMapToList; import pcgen.cdom.base.CDOMCategorizedSingleRef; import pcgen.cdom.base.CDOMObject; @@ -77,6 +78,11 @@ public boolean parseFeat(LoadContext context, CDOMObject obj, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() @@ -98,11 +104,6 @@ final StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); - if (!tok.hasMoreTokens()) - { - return false; - } - List<PCGraphGrantsEdge> edgeList = new ArrayList<PCGraphGrantsEdge>(); String token = tok.nextToken(); @@ -135,7 +136,7 @@ Prerequisite prereq = getPrerequisite(token); if (prereq == null) { - Logging.errorPrint(" (Did you put spells after the " + Logging.errorPrint(" (Did you put feats after the " + "PRExxx tags in FEAT:?)"); return false; } @@ -217,6 +218,7 @@ } if (prereqs != null && !prereqs.isEmpty()) { + TreeSet<String> prereqSet = new TreeSet<String>(); for (Prerequisite p : prereqs) { StringWriter swriter = new StringWriter(); @@ -230,8 +232,10 @@ + e); return null; } - sb.append(Constants.PIPE).append(swriter.toString()); + prereqSet.add(swriter.toString()); } + sb.append(Constants.PIPE).append( + StringUtil.join(prereqSet, Constants.PIPE)); } list.add(sb.toString()); } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/LangbonusToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/LangbonusToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/race/LangbonusToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -58,6 +58,11 @@ public boolean parse(LoadContext context, Race race, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == ',') { Logging.errorPrint(getTokenName() Modified: branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -64,6 +64,11 @@ public boolean parse(LoadContext context, Race race, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() Modified: branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -64,6 +64,11 @@ public boolean parse(LoadContext context, Race race, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() Modified: branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -36,6 +36,7 @@ import pcgen.core.prereq.Prerequisite; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.RaceLstToken; import pcgen.persistence.lst.prereq.PreParserFactory; import pcgen.util.Logging; @@ -43,10 +44,11 @@ /** * Class deals with STARTFEATS Token */ -public class StartfeatsToken implements RaceLstToken +public class StartfeatsToken extends AbstractToken implements RaceLstToken { private static final Class<Ability> ABILITY_CLASS = Ability.class; + @Override public String getTokenName() { return "STARTFEATS"; @@ -96,14 +98,19 @@ return false; } - /* - * TODO Why was this PREMULT added in 5.11.? What situation would this - * PREMULT fail in? - */ - // buf.append("PREMULT:1,[PRELEVEL:1],[PREHD:1]"); Slot<Ability> slot = context.graph.addSlotIntoGraph(getTokenName(), race, ABILITY_CLASS, FormulaFactory.getFormulaFor(featCount)); + /* + * This prereq exists solely to prevent the ability to select Feats + * before first level. It simply aligns this to the rules that provide + * for the extra feats for a starting character (which is first level) + * This was established through questioning of the more senior code + * monkeys on one of the lists in early 2007 - Tom Parker Mar/28/2007 + */ + Prerequisite prereq = + getPrerequisite("PREMULT:1,[PRELEVEL:1],[PREHD:1]"); + slot.addPreReq(prereq); CDOMGroupRef<Ability> ref = context.ref.getCategorizedCDOMAllReference(ABILITY_CLASS, AbilityCategory.FEAT); Modified: branches/cdom/code/src/java/plugin/lsttokens/race/WeaponbonusToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/WeaponbonusToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/race/WeaponbonusToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -71,6 +71,11 @@ public boolean parseWeaponBonus(LoadContext context, CDOMObject obj, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() Modified: branches/cdom/code/src/java/plugin/lsttokens/spell/SpellresToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/spell/SpellresToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/spell/SpellresToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -25,6 +25,7 @@ import pcgen.core.spell.Spell; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.SpellLstToken; +import pcgen.util.Logging; /** * Class deals with SPELLRES Token @@ -45,6 +46,11 @@ public boolean parse(LoadContext context, Spell spell, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } spell.put(StringKey.CAN_BE_RESISTED, value); return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/template/CrToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/CrToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/template/CrToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -55,16 +55,9 @@ public boolean parse(LoadContext context, PCTemplate template, String value) { - try - { - ChallengeRating cr = new ChallengeRating(value); - context.graph.linkObjectIntoGraph(getTokenName(), template, cr); - return true; - } - catch (NumberFormatException nfe) - { - return false; - } + ChallengeRating cr = new ChallengeRating(value); + context.graph.linkObjectIntoGraph(getTokenName(), template, cr); + return true; } public String[] unparse(LoadContext context, PCTemplate pct) Modified: branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -30,6 +30,7 @@ import java.util.StringTokenizer; import java.util.TreeSet; +import pcgen.base.lang.StringUtil; import pcgen.base.util.HashMapToList; import pcgen.cdom.base.CDOMCategorizedSingleRef; import pcgen.cdom.base.CDOMObject; @@ -78,6 +79,11 @@ public boolean parseFeat(LoadContext context, CDOMObject obj, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() @@ -199,6 +205,7 @@ String ab = ReferenceUtilities.joinLstFormat(set, Constants.PIPE); if (prereqs != null && !prereqs.isEmpty()) { + TreeSet<String> prereqSet = new TreeSet<String>(); for (Prerequisite p : prereqs) { StringWriter swriter = new StringWriter(); @@ -212,10 +219,11 @@ + e); return null; } - ab = - new StringBuilder(ab).append(Constants.PIPE) - .append(swriter.toString()).toString(); + prereqSet.add(swriter.toString()); } + ab = + ab + Constants.PIPE + + StringUtil.join(prereqSet, Constants.PIPE); } array[index++] = ab; } Modified: branches/cdom/code/src/java/plugin/lsttokens/template/LangbonusToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/LangbonusToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/template/LangbonusToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -58,6 +58,11 @@ public boolean parse(LoadContext context, PCTemplate template, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == ',') { Logging.errorPrint(getTokenName() Modified: branches/cdom/code/src/java/plugin/lsttokens/template/TemplateToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/TemplateToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/template/TemplateToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -126,6 +126,11 @@ } else { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() Modified: branches/cdom/code/src/java/plugin/lsttokens/template/WeaponbonusToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/WeaponbonusToken.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/java/plugin/lsttokens/template/WeaponbonusToken.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -71,6 +71,11 @@ public boolean parseWeaponBonus(LoadContext context, CDOMObject obj, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() Modified: branches/cdom/code/src/test/plugin/lsttokens/auto/AbstractProfTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/auto/AbstractProfTokenTestCase.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/test/plugin/lsttokens/auto/AbstractProfTokenTestCase.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -30,21 +30,36 @@ import plugin.lsttokens.AutoLst; import plugin.lsttokens.testsupport.AbstractGlobalTokenTestCase; import plugin.lsttokens.testsupport.TokenRegistration; +import plugin.pretokens.parser.PreClassParser; +import plugin.pretokens.parser.PreRaceParser; +import plugin.pretokens.writer.PreClassWriter; +import plugin.pretokens.writer.PreRaceWriter; -public abstract class AbstractProfTokenTestCase extends AbstractGlobalTokenTestCase +public abstract class AbstractProfTokenTestCase extends + AbstractGlobalTokenTestCase { static AutoLst token = new AutoLst(); + PreClassParser preclass = new PreClassParser(); + PreClassWriter preclasswriter = new PreClassWriter(); + PreRaceParser prerace = new PreRaceParser(); + PreRaceWriter preracewriter = new PreRaceWriter(); + @Override @Before public void setUp() throws PersistenceLayerException, URISyntaxException { super.setUp(); + TokenRegistration.register(preclass); + TokenRegistration.register(preclasswriter); + TokenRegistration.register(prerace); + TokenRegistration.register(preracewriter); TokenRegistration.register(getSubToken()); } protected abstract AutoLstToken getSubToken(); + protected abstract <T extends PObject> Class<T> getSubTokenType(); public String getSubTokenString() @@ -148,6 +163,23 @@ // @Test + public void testInvalidEmptyPrereq() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1[]")); + } + + @Test + public void testInvalidUnterminatedPrereq() + throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, + getSubTokenString() + "|TestWP1[PRERACE:1,Human")); + } + + @Test public void testInvalidListEnd() throws PersistenceLayerException { construct(primaryContext, "TestWP1"); @@ -250,6 +282,18 @@ } @Test + public void testRoundRobinOnePrereq() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + runRoundRobin(getSubTokenString() + "|TestWP1[PRERACE:1,Human]"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test public void testRoundRobinThree() throws PersistenceLayerException { construct(primaryContext, "TestWP1"); Modified: branches/cdom/code/src/test/plugin/lsttokens/deity/DomainsTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/deity/DomainsTokenTest.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/test/plugin/lsttokens/deity/DomainsTokenTest.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -22,6 +22,7 @@ import pcgen.core.Deity; import pcgen.core.Domain; import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.CDOMToken; import pcgen.persistence.lst.DeityLoader; import pcgen.persistence.lst.LstObjectFileLoader; @@ -75,9 +76,9 @@ } @Test - public void dummyTest() + public void testRoundRobinAll() throws PersistenceLayerException { - //Just to get Eclipse to recognize this as a JUnit 4.0 Test Case + this.runRoundRobin("ALL"); } } Modified: branches/cdom/code/src/test/plugin/lsttokens/equipment/AbstractCritMultTokenTestCase.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/equipment/AbstractCritMultTokenTestCase.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/test/plugin/lsttokens/equipment/AbstractCritMultTokenTestCase.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -100,6 +100,12 @@ } @Test + public void testInvalidTimesNaNInput() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "xY")); + } + + @Test public void testInvalidNoTimesInput() throws PersistenceLayerException { assertFalse(getToken().parse(primaryContext, primaryProf, "3")); Modified: branches/cdom/code/src/test/plugin/lsttokens/race/FeatTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/race/FeatTokenTest.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/test/plugin/lsttokens/race/FeatTokenTest.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -17,23 +17,48 @@ */ package plugin.lsttokens.race; +import java.net.URISyntaxException; + +import org.junit.Before; import org.junit.Test; import pcgen.cdom.enumeration.AbilityCategory; import pcgen.core.Ability; import pcgen.core.Race; import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.CDOMToken; import pcgen.persistence.lst.LstObjectFileLoader; import pcgen.persistence.lst.RaceLoader; import plugin.lsttokens.testsupport.AbstractListTokenTestCase; +import plugin.lsttokens.testsupport.TokenRegistration; +import plugin.pretokens.parser.PreClassParser; +import plugin.pretokens.parser.PreRaceParser; +import plugin.pretokens.writer.PreClassWriter; +import plugin.pretokens.writer.PreRaceWriter; public class FeatTokenTest extends AbstractListTokenTestCase<Race, Ability> { static FeatToken token = new FeatToken(); static RaceLoader loader = new RaceLoader(); + PreClassParser preclass = new PreClassParser(); + PreClassWriter preclasswriter = new PreClassWriter(); + PreRaceParser prerace = new PreRaceParser(); + PreRaceWriter preracewriter = new PreRaceWriter(); + @Override + @Before + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + TokenRegistration.register(preclass); + TokenRegistration.register(preclasswriter); + TokenRegistration.register(prerace); + TokenRegistration.register(preracewriter); + } + + @Override public char getJoinCharacter() { return '|'; @@ -77,9 +102,74 @@ } @Test - public void dummyTest() + public void testInvalidInputEmpty() { - //Just to get Eclipse to recognize this as a JUnit 4.0 Test Case + assertFalse(token.parse(primaryContext, primaryProf, "")); } + @Test + public void testInvalidInputEmbeddedPre() + { + construct(primaryContext, "TestWP1"); + assertFalse(token.parse(primaryContext, primaryProf, + "TestWP1|PRECLASS:1,Fighter=1|TestWP2")); + } + + @Test + public void testInvalidInputDoublePipePre() + { + construct(primaryContext, "TestWP1"); + assertFalse(token.parse(primaryContext, primaryProf, + "TestWP1||PRECLASS:1,Fighter=1")); + } + + @Test + public void testInvalidInputPostPrePipe() + { + construct(primaryContext, "TestWP1"); + assertFalse(token.parse(primaryContext, primaryProf, + "TestWP1|PRECLASS:1,Fighter=1|")); + } + + @Test + public void testRoundRobinPre() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(secondaryContext, "TestWP1"); + runRoundRobin("TestWP1|PRECLASS:1,Fighter=1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinTwoPre() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(secondaryContext, "TestWP1"); + runRoundRobin("TestWP1|!PRERACE:1,Human|PRECLASS:1,Fighter=1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinNotPre() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(secondaryContext, "TestWP1"); + runRoundRobin("TestWP1|!PRECLASS:1,Fighter=1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinWWoPre() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + runRoundRobin("TestWP1|PRECLASS:1,Fighter=1", "TestWP2"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } } Modified: branches/cdom/code/src/test/plugin/lsttokens/skill/ClassesTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/skill/ClassesTokenTest.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/test/plugin/lsttokens/skill/ClassesTokenTest.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -79,6 +79,12 @@ } @Test + public void testInvalidInputEmpty() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "")); + } + + @Test public void testInvalidInputLeadingBar() throws PersistenceLayerException { assertFalse(getToken().parse(primaryContext, primaryProf, "|Wizard")); Modified: branches/cdom/code/src/test/plugin/lsttokens/skill/VisibleTokenTest.java =================================================================== --- branches/cdom/code/src/test/plugin/lsttokens/skill/VisibleTokenTest.java 2007-03-30 00:52:34 UTC (rev 2614) +++ branches/cdom/code/src/test/plugin/lsttokens/skill/VisibleTokenTest.java 2007-03-30 01:14:54 UTC (rev 2615) @@ -75,6 +75,14 @@ internalTestInvalidInputString(Visibility.EXPORT); } + @Test + public void testInvalidInputStringSetDisplay() throws PersistenceLayerException + { + assertTrue(token.parse(primaryContext, primaryProf, "DISPLAY")); + assertEquals(Visibility.DISPLAY, primaryProf.get(ObjectKey.VISIBILITY)); + internalTestInvalidInputString(Visibility.DISPLAY); + } + public void internalTestInvalidInputString(Object val) throws PersistenceLayerException { @@ -89,8 +97,18 @@ assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); assertFalse(token.parse(primaryContext, primaryProf, "ALL")); assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); - //Note case sensitivity + // Must be EXPORT|READONLY + assertFalse(token.parse(primaryContext, primaryProf, "DISPLAY|")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + assertFalse(token.parse(primaryContext, primaryProf, "DISPLAY|FLUFF")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + // Note case sensitivity assertFalse(token.parse(primaryContext, primaryProf, "Display")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + assertFalse(token.parse(primaryContext, primaryProf, "DISPLAY|ReadOnly")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + ass... [truncated message content] |
From: <th...@us...> - 2007-04-06 20:32:31
|
Revision: 2678 http://svn.sourceforge.net/pcgen/?rev=2678&view=rev Author: thpr Date: 2007-04-06 13:32:29 -0700 (Fri, 06 Apr 2007) Log Message: ----------- CDOM: Re-add WeaponProf Token Tests (in src/utest) Added Paths: ----------- branches/cdom/code/src/utest/ branches/cdom/code/src/utest/plugin/ branches/cdom/code/src/utest/plugin/lsttokens/ branches/cdom/code/src/utest/plugin/lsttokens/weaponprof/ branches/cdom/code/src/utest/plugin/lsttokens/weaponprof/TokenWeaponProfTestSuite.java Copied: branches/cdom/code/src/utest/plugin/lsttokens/weaponprof (from rev 2596, branches/cdom/code/src/test/plugin/lsttokens/weaponprof) Added: branches/cdom/code/src/utest/plugin/lsttokens/weaponprof/TokenWeaponProfTestSuite.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/weaponprof/TokenWeaponProfTestSuite.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/weaponprof/TokenWeaponProfTestSuite.java 2007-04-06 20:32:29 UTC (rev 2678) @@ -0,0 +1,13 @@ +package plugin.lsttokens.weaponprof; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +import junit.framework.TestSuite; + +@RunWith(Suite.class) +@Suite.SuiteClasses({HandsTokenTest.class}) +public class TokenWeaponProfTestSuite extends TestSuite +{ + //No content, see annotations +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-04-06 22:31:33
|
Revision: 2685 http://svn.sourceforge.net/pcgen/?rev=2685&view=rev Author: thpr Date: 2007-04-06 15:31:32 -0700 (Fri, 06 Apr 2007) Log Message: ----------- CDOM: Code changes for Unit Tests + Additional Test Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/enumeration/ObjectKey.java branches/cdom/code/src/java/pcgen/cdom/helper/Capacity.java branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/ContainsToken.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/TokenEquipmentTestSuite.java Added Paths: ----------- branches/cdom/code/src/utest/plugin/lsttokens/equipment/ContainsTokenTest.java Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/ObjectKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/ObjectKey.java 2007-04-06 20:53:34 UTC (rev 2684) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/ObjectKey.java 2007-04-06 22:31:32 UTC (rev 2685) @@ -127,7 +127,7 @@ public static final ObjectKey<Boolean> EXCLUSIVE = new ObjectKey<Boolean>(); - public static final ObjectKey<Double> CONTAINER_WEIGHT_CAPACITY = new ObjectKey<Double>(); + public static final ObjectKey<BigDecimal> CONTAINER_WEIGHT_CAPACITY = new ObjectKey<BigDecimal>(); public static final ObjectKey<Boolean> CONTAINER_CONSTANT_WEIGHT = new ObjectKey<Boolean>(); Modified: branches/cdom/code/src/java/pcgen/cdom/helper/Capacity.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/helper/Capacity.java 2007-04-06 20:53:34 UTC (rev 2684) +++ branches/cdom/code/src/java/pcgen/cdom/helper/Capacity.java 2007-04-06 22:31:32 UTC (rev 2685) @@ -17,28 +17,31 @@ */ package pcgen.cdom.helper; +import java.math.BigDecimal; + import pcgen.cdom.enumeration.Type; public class Capacity { + public static BigDecimal UNLIMITED = new BigDecimal(-1); /* * CONSIDER Need to flesh out how this works; depends on how Capacity * interacts with the core... - Tom Parker 3/1/07 */ - public static final Capacity ANY = new Capacity(null, -1); + public static final Capacity ANY = new Capacity(null, UNLIMITED); private final Type type; - private final double limit; + private final BigDecimal limit; - public Capacity(Type typ, double cap) + public Capacity(Type typ, BigDecimal cap) { type = typ; limit = cap; } - public double getCapacity() + public BigDecimal getCapacity() { return limit; } @@ -48,9 +51,19 @@ return type; } - public static Capacity getTotalCapacity(double d) + public static Capacity getTotalCapacity(BigDecimal d) { return new Capacity(null, d); } + @Override + public String toString() + { + StringBuilder sb = new StringBuilder(); + sb.append("Capacity: "); + sb.append(type == null ? "Total" : type); + sb.append('='); + sb.append(UNLIMITED.equals(limit) ? "UNLIMITED" : limit); + return sb.toString(); + } } Modified: branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java 2007-04-06 20:53:34 UTC (rev 2684) +++ branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java 2007-04-06 22:31:32 UTC (rev 2685) @@ -185,7 +185,10 @@ { if (prereqs.size() > 1) { - // TODO Document Error + context.addWriteMessage("Error: " + + obj.getClass().getSimpleName() + + " had more than one Prerequisite for " + + getTokenName()); return null; } Prerequisite p = prereqs.iterator().next(); Modified: branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java 2007-04-06 20:53:34 UTC (rev 2684) +++ branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java 2007-04-06 22:31:32 UTC (rev 2685) @@ -181,7 +181,10 @@ { if (prereqs.size() > 1) { - // TODO Document Error + context.addWriteMessage("Error: " + + obj.getClass().getSimpleName() + + " had more than one Prerequisite for " + + getTokenName()); return null; } Prerequisite p = prereqs.iterator().next(); Modified: branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java 2007-04-06 20:53:34 UTC (rev 2684) +++ branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java 2007-04-06 22:31:32 UTC (rev 2685) @@ -181,7 +181,10 @@ { if (prereqs.size() > 1) { - // TODO Document Error + context.addWriteMessage("Error: " + + obj.getClass().getSimpleName() + + " had more than one Prerequisite for " + + getTokenName()); return null; } Prerequisite p = prereqs.iterator().next(); Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/ContainsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipment/ContainsToken.java 2007-04-06 20:53:34 UTC (rev 2684) +++ branches/cdom/code/src/java/plugin/lsttokens/equipment/ContainsToken.java 2007-04-06 22:31:32 UTC (rev 2685) @@ -21,9 +21,11 @@ */ package plugin.lsttokens.equipment; +import java.math.BigDecimal; import java.util.List; import java.util.StringTokenizer; +import pcgen.base.util.Logging; import pcgen.cdom.base.Constants; import pcgen.cdom.enumeration.IntegerKey; import pcgen.cdom.enumeration.ListKey; @@ -33,6 +35,7 @@ import pcgen.core.Equipment; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.EquipmentLstToken; +import pcgen.util.BigDecimalHelper; /** * Deals with CONTAINS token @@ -53,6 +56,24 @@ public boolean parse(LoadContext context, Equipment eq, String value) { + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | , see: " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | , see: " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } StringTokenizer pipeTok = new StringTokenizer(value, Constants.PIPE); if (!pipeTok.hasMoreTokens()) @@ -63,8 +84,10 @@ String weightCapacity = pipeTok.nextToken(); + boolean hadAsterisk = false; if (weightCapacity.charAt(0) == Constants.CHAR_ASTERISK) { + hadAsterisk = true; eq.put(ObjectKey.CONTAINER_CONSTANT_WEIGHT, Boolean.TRUE); weightCapacity = weightCapacity.substring(1); } @@ -72,10 +95,19 @@ int percentLoc = weightCapacity.indexOf(Constants.PERCENT); if (percentLoc != weightCapacity.lastIndexOf(Constants.PERCENT)) { + Logging.errorPrint("Cannot have two weight reduction " + + "characters (indicated by %): " + value); return false; } if (percentLoc != -1) { + if (hadAsterisk) + { + Logging + .errorPrint("Cannot have Constant Weight (indicated by *) " + + "and weight reduction (indicated by %): " + value); + return false; + } String redString = weightCapacity.substring(0, percentLoc); weightCapacity = weightCapacity.substring(percentLoc + 1); @@ -92,8 +124,8 @@ try { - eq.put(ObjectKey.CONTAINER_WEIGHT_CAPACITY, Double - .valueOf(weightCapacity)); + eq.put(ObjectKey.CONTAINER_WEIGHT_CAPACITY, new BigDecimal( + weightCapacity)); } catch (NumberFormatException ex) { @@ -107,7 +139,7 @@ eq.addToListFor(ListKey.CAPACITY, Capacity.ANY); } - double limitedCapacity = 0; + BigDecimal limitedCapacity = BigDecimal.ZERO; while (pipeTok.hasMoreTokens()) { @@ -121,19 +153,35 @@ { limited = false; Type t = Type.getConstant(typeString); - eq.addToListFor(ListKey.CAPACITY, new Capacity(t, -1)); + eq.addToListFor(ListKey.CAPACITY, new Capacity(t, + Capacity.UNLIMITED)); } else { String itemType = typeString.substring(0, equalLoc); - double itemNumber = - Double.parseDouble(typeString.substring(equalLoc + 1)); - if (limited) + try { - limitedCapacity += itemNumber; + BigDecimal itemNumber = + BigDecimalHelper.trimBigDecimal(new BigDecimal( + typeString.substring(equalLoc + 1))); + if (BigDecimal.ZERO.compareTo(itemNumber) >= 0) + { + Logging.errorPrint("Cannot have negative quantity of " + + itemType + ": " + value); + return false; + } + if (limited) + { + limitedCapacity = limitedCapacity.add(itemNumber); + } + Type t = Type.getConstant(itemType); + eq.addToListFor(ListKey.CAPACITY, new Capacity(t, + itemNumber)); } - Type t = Type.getConstant(itemType); - eq.addToListFor(ListKey.CAPACITY, new Capacity(t, itemNumber)); + catch (NumberFormatException nfe) + { + return false; + } } } @@ -147,13 +195,14 @@ List<Capacity> list = eq.getListFor(ListKey.CAPACITY); for (Capacity cap : list) { - if ("Total".equals(cap.getType())) + if (cap.getType() == null) { return true; } } - double totalCapacity = limited ? limitedCapacity : -1; + BigDecimal totalCapacity = + limited ? limitedCapacity : Capacity.UNLIMITED; eq.addToListFor(ListKey.CAPACITY, Capacity .getTotalCapacity(totalCapacity)); @@ -181,7 +230,7 @@ sb.append(reducePercent).append(Constants.PERCENT); } - Double cap = eq.get(ObjectKey.CONTAINER_WEIGHT_CAPACITY); + BigDecimal cap = eq.get(ObjectKey.CONTAINER_WEIGHT_CAPACITY); if (cap == null) { // CONSIDER ERROR?? @@ -189,37 +238,34 @@ } sb.append(cap); - if (capacityList.size() == 2) + if (capacityList.size() == 1) { for (Capacity c : capacityList) { - if ("Any".equals(c.getType()) && c.getCapacity() == -1) + if (c.getType() == null + && Capacity.UNLIMITED.equals(c.getCapacity())) { // Special Case: Nothing additional return new String[]{sb.toString()}; } } } - double limitedCapacity = 0; + BigDecimal limitedCapacity = BigDecimal.ZERO; boolean limited = true; - boolean needsPipe = false; Capacity total = null; for (Capacity c : capacityList) { Type capType = c.getType(); - if ("Total".equals(capType)) + if (capType == null) { total = c; } else { - if (needsPipe) - { - sb.append(Constants.PIPE); - } - double thisCap = c.getCapacity(); + sb.append(Constants.PIPE); + BigDecimal thisCap = c.getCapacity(); sb.append(capType); - if (thisCap == -1) + if (Capacity.UNLIMITED.equals(thisCap)) { limited = false; } @@ -227,7 +273,7 @@ { if (limited) { - limitedCapacity += thisCap; + limitedCapacity = limitedCapacity.add(thisCap); } sb.append(Constants.EQUALS).append(thisCap); } @@ -238,7 +284,8 @@ // Error return null; } - if (limitedCapacity != total.getCapacity()) + if (!limitedCapacity.equals(total.getCapacity()) + && !Capacity.UNLIMITED.equals(total.getCapacity())) { // Need to write out total sb.append("Total").append(Constants.EQUALS).append( Added: branches/cdom/code/src/utest/plugin/lsttokens/equipment/ContainsTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/equipment/ContainsTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/equipment/ContainsTokenTest.java 2007-04-06 22:31:32 UTC (rev 2685) @@ -0,0 +1,428 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.equipment; + +import org.junit.Test; + +import pcgen.core.Equipment; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.EquipmentLoader; +import pcgen.persistence.lst.LstObjectFileLoader; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class ContainsTokenTest extends AbstractTokenTestCase<Equipment> +{ + + static ContainsToken token = new ContainsToken(); + static EquipmentLoader loader = new EquipmentLoader(); + + @Override + public Class<Equipment> getCDOMClass() + { + return Equipment.class; + } + + @Override + public LstObjectFileLoader<Equipment> getLoader() + { + return loader; + } + + @Override + public CDOMToken<Equipment> getToken() + { + return token; + } + + @Test + public void testInvalidInputNaN() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "X4")); + } + + @Test + public void testInvalidInputReducingFirstNaN() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "X4%60")); + } + + @Test + public void testInvalidInputReducingSecondNaN() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "50%X4")); + } + + @Test + public void testInvalidInputSplatReducing() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*50%40")); + } + + @Test + public void testInvalidInputTwoPercent() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "50%40%30")); + } + + @Test + public void testInvalidInputTrailingSplat() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "4*")); + } + + @Test + public void testInvalidInputEmbeddedSplat() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5*4")); + } + + @Test + public void testInvalidInputNaNTyped() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "X4|Any=25")); + } + + @Test + public void testInvalidInputReducingFirstNaNTyped() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "X4%60|Any=25")); + } + + @Test + public void testInvalidInputReducingSecondNaNTyped() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "50%X4|Any=25")); + } + + @Test + public void testInvalidInputSplatReducingTyped() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*50%40|Any=25")); + } + + @Test + public void testInvalidInputTwoPercentTyped() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "50%40%30|Any=25")); + } + + @Test + public void testInvalidInputTrailingSplatTyped() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "4*|Any=25")); + } + + @Test + public void testInvalidInputEmbeddedSplatTyped() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5*4|Any=25")); + } + + public void testInvalidNoCapacity() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "|Cookies")); + } + + @Test + public void testInvalidCapacityNoTypeQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5|Any=")); + } + + @Test + public void testInvalidCapacityZeroQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5|Cookies=0")); + } + + @Test + public void testInvalidCapacityNegativeQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5|Cookies=-10")); + } + + @Test + public void testInvalidCapacityTypeQuantityNaN() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5|Any=4X")); + } + + public void testInvalidCapacityUselessPipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5|")); + } + + @Test + public void testInvalidCapacityTypeLeadingDoublePipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5||Any=4")); + } + + @Test + public void testInvalidCapacityTypeTrailingPipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5|Any=4|")); + } + + @Test + public void testInvalidCapacityTypeDoubleEquals() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "5|Any=4=3")); + } + + @Test + public void testInvalidCapacityTypeMiddlePipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "5|Cookies=4||Crackers=3")); + } + + @Test + public void testInvalidWeightlessNoTypeQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*5|Any=")); + } + + @Test + public void testInvalidWeightlessZeroQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*5|Cookies=0")); + } + + @Test + public void testInvalidWeightlessNegativeQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*5|Cookies=-10")); + } + + @Test + public void testInvalidWeightlessTypeQuantityNaN() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*5|Any=4X")); + } + + public void testInvalidWeightlessUselessPipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*5|")); + } + + @Test + public void testInvalidWeightlessTypeLeadingDoublePipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*5||Any=4")); + } + + @Test + public void testInvalidWeightlessTypeTrailingPipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*5|Any=4|")); + } + + @Test + public void testInvalidWeightlessTypeDoubleEquals() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "*5|Any=4=3")); + } + + @Test + public void testInvalidWeightlessTypeMiddlePipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "*5|Cookies=4||Crackers=3")); + } + + @Test + public void testInvalidReducedNoTypeQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "40%30|Any=")); + } + + @Test + public void testInvalidReducedTypeQuantityNaN() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "40%30|Any=4X")); + } + + public void testInvalidReducedUselessPipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "40%30|")); + } + + @Test + public void testInvalidReducedTypeLeadingDoublePipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "40%30||Any=4")); + } + + @Test + public void testInvalidReducedTypeTrailingPipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "40%30|Any=4|")); + } + + @Test + public void testInvalidReducedZeroQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "40%30|Cookies=0")); + } + + @Test + public void testInvalidReducedNegativeQuantity() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "40%30|Cookies=-10")); + } + + @Test + public void testInvalidReducedTypeDoubleEquals() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "40%30|Any=4=3")); + } + + @Test + public void testInvalidReducedTypeMiddlePipe() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "40%30|Cookies=4||Crackers=3")); + } + + @Test + public void testRoundRobinSimple() throws PersistenceLayerException + { + this.runRoundRobin("500"); + } + + @Test + public void testRoundRobinSimpleWeightless() + throws PersistenceLayerException + { + this.runRoundRobin("*500"); + } + + @Test + public void testRoundRobinSimpleReducing() throws PersistenceLayerException + { + this.runRoundRobin("50%40"); + } + + @Test + public void testRoundRobinTypeLimited() throws PersistenceLayerException + { + this.runRoundRobin("50|Cookies"); + } + + @Test + public void testRoundRobinTypeLimitMix() throws PersistenceLayerException + { + this.runRoundRobin("5|Cookies=4|Crackers"); + } + + @Test + public void testRoundRobinWeightlessTypeLimitMix() + throws PersistenceLayerException + { + this.runRoundRobin("*15|Cookies=4|Crackers"); + } + + @Test + public void testRoundRobinLimitedReducing() + throws PersistenceLayerException + { + this.runRoundRobin("50%30|Any=25"); + } + + @Test + public void testRoundRobinCountLimitedReducing() + throws PersistenceLayerException + { + this.runRoundRobin("25%-1|Any=100"); + } + + @Test + public void testRoundRobinCountLimitedCursedAdding() + throws PersistenceLayerException + { + this.runRoundRobin("-35%-1|Any=100"); + } + + @Test + public void testRoundRobinTypeQuantityLimited() + throws PersistenceLayerException + { + this.runRoundRobin("500|Potions=100"); + } + + @Test + public void testRoundRobinTypeUnlimited() throws PersistenceLayerException + { + this.runRoundRobin("-1"); + } + + @Test + public void testRoundRobinTypeCountLimited() + throws PersistenceLayerException + { + this.runRoundRobin("-1|Any=100"); + } + + @Test + public void testRoundRobinTypeComplexWeightUnlimited() + throws PersistenceLayerException + { + this.runRoundRobin("-1|Total=10|Paper=10|Scroll=10"); + } +} Modified: branches/cdom/code/src/utest/plugin/lsttokens/equipment/TokenEquipmentTestSuite.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/equipment/TokenEquipmentTestSuite.java 2007-04-06 20:53:34 UTC (rev 2684) +++ branches/cdom/code/src/utest/plugin/lsttokens/equipment/TokenEquipmentTestSuite.java 2007-04-06 22:31:32 UTC (rev 2685) @@ -9,15 +9,15 @@ @Suite.SuiteClasses({AcCheckTokenTest.class, AltCritMultTokenTest.class, AltCritRangeTokenTest.class, AltDamageTokenTest.class, AltEqModTokenTest.class, AltTypeTokenTest.class, BaseItemTokenTest.class, - BaseqtyTokenTest.class, CostTokenTest.class, CritMultTokenTest.class, - CritRangeTokenTest.class, DamageTokenTest.class, EdrTokenTest.class, - EqmodTokenTest.class, FumbleRangeTokenTest.class, HandsTokenTest.class, - MaxDexTokenTest.class, ModsTokenTest.class, NumPagesTokenTest.class, - PageUsageTokenTest.class, ProficiencyTokenTest.class, - QualityTokenTest.class, RangeTokenTest.class, RateOfFireTokenTest.class, - ReachMultTokenTest.class, ReachTokenTest.class, SlotsTokenTest.class, - SpellfailureTokenTest.class, SPropTokenTest.class, WeildTokenTest.class, - WtTokenTest.class}) + BaseqtyTokenTest.class, ContainsTokenTest.class, CostTokenTest.class, + CritMultTokenTest.class, CritRangeTokenTest.class, DamageTokenTest.class, + EdrTokenTest.class, EqmodTokenTest.class, FumbleRangeTokenTest.class, + HandsTokenTest.class, MaxDexTokenTest.class, ModsTokenTest.class, + NumPagesTokenTest.class, PageUsageTokenTest.class, + ProficiencyTokenTest.class, QualityTokenTest.class, RangeTokenTest.class, + RateOfFireTokenTest.class, ReachMultTokenTest.class, ReachTokenTest.class, + SlotsTokenTest.class, SpellfailureTokenTest.class, SPropTokenTest.class, + WeildTokenTest.class, WtTokenTest.class}) public class TokenEquipmentTestSuite extends TestSuite { // No contents, see annotations This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-04-07 20:16:45
|
Revision: 2693 http://svn.sourceforge.net/pcgen/?rev=2693&view=rev Author: thpr Date: 2007-04-07 13:16:45 -0700 (Sat, 07 Apr 2007) Log Message: ----------- CDOM: Code changes for Unit Tests + Additional Tests Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java branches/cdom/code/src/java/pcgen/cdom/base/Slot.java branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java branches/cdom/code/src/java/pcgen/cdom/enumeration/ObjectKey.java branches/cdom/code/src/java/pcgen/cdom/mode/Size.java branches/cdom/code/src/java/pcgen/persistence/GraphContext.java branches/cdom/code/src/java/plugin/lsttokens/DescispiLst.java branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/SizeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/SpropToken.java branches/cdom/code/src/java/plugin/lsttokens/race/FavclassToken.java branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceadvancementToken.java branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/SizeToken.java branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/ItemToken.java branches/cdom/code/src/java/plugin/lsttokens/template/FavoredclassToken.java branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java branches/cdom/code/src/java/plugin/lsttokens/template/SizeToken.java branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java branches/cdom/code/src/utest/plugin/lsttokens/KeyLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/add/AbstractAddTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/TokenEquipmentTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/race/TokenRaceTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/template/TokenTemplateTestSuite.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/base/formula/Resolver.java branches/cdom/code/src/java/pcgen/cdom/formula/ branches/cdom/code/src/java/pcgen/cdom/formula/FixedSizeResolver.java branches/cdom/code/src/java/pcgen/cdom/formula/FormulaSizeResolver.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/SizeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/FavoredClassTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/HitDiceAdvancementTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/SizeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/StartFeatsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/FavoredClassTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/SizeTokenTest.java Removed Paths: ------------- branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/BonusToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/BabToken.java branches/cdom/code/src/java/plugin/lsttokens/race/InitToken.java Added: branches/cdom/code/src/java/pcgen/base/formula/Resolver.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/formula/Resolver.java (rev 0) +++ branches/cdom/code/src/java/pcgen/base/formula/Resolver.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -0,0 +1,9 @@ +package pcgen.base.formula; + +public interface Resolver<T> +{ + + public T resolve(); + + public String toLSTFormat(); +} Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -64,9 +64,9 @@ private final MapKeyMapToList mapChar = new MapKeyMapToList(); - private boolean namePI = false; + private Boolean namePI = null; - private boolean descPI = false; + private Boolean descPI = null; public SourceEntry getSourceEntry() { @@ -239,23 +239,33 @@ return mapChar.getKeySet(key1); } - public final boolean isDescPI() + public final Boolean getDescPIObject() { return descPI; } - public final void setDescPI(boolean descIsPI) + public final boolean isDescPI() { + return descPI == null ? false : descPI.booleanValue(); + } + + public final void setDescPI(Boolean descIsPI) + { this.descPI = descIsPI; } - public final boolean isNamePI() + public final Boolean getNamePIObject() { return namePI; } - public final void setNamePI(boolean nameIsPI) + public final boolean isNamePI() { + return namePI == null ? false : namePI.booleanValue(); + } + + public final void setNamePI(Boolean nameIsPI) + { this.namePI = nameIsPI; } Modified: branches/cdom/code/src/java/pcgen/cdom/base/Slot.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/Slot.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/pcgen/cdom/base/Slot.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -17,7 +17,13 @@ */ package pcgen.cdom.base; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; + import pcgen.base.formula.Formula; +import pcgen.cdom.enumeration.AssociationKey; public class Slot<T extends PrereqObject> extends ConcretePrereqObject { @@ -129,4 +135,34 @@ return slotClass.equals(otherSlot.slotClass) && slotCount.equals(otherSlot.slotCount); } + + /* + * CONSIDER Use AssociationSupport? - Tom Parker Apr 7 07 + */ + private Map<AssociationKey<?>, Object> associationMap; + + public <AKT> void setAssociation(AssociationKey<AKT> key, AKT value) + { + if (associationMap == null) + { + associationMap = new HashMap<AssociationKey<?>, Object>(); + } + associationMap.put(key, value); + } + + public <AKT> AKT getAssociation(AssociationKey<AKT> key) + { + return (AKT) (associationMap == null ? null : associationMap.get(key)); + } + + public Collection<AssociationKey<?>> getAssociationKeys() + { + return new HashSet<AssociationKey<?>>(associationMap.keySet()); + } + + public boolean hasAssociations() + { + return associationMap != null && !associationMap.isEmpty(); + } + } Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -58,6 +58,8 @@ public static final AssociationKey<String> ONLY = new AssociationKey<String>(); + public static final AssociationKey<AbilityCategory> ABILITY_CATEGORY = new AssociationKey<AbilityCategory>(); + private static CaseInsensitiveMap<AssociationKey<?>> map = null; private AssociationKey() { Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -30,10 +30,12 @@ import java.util.Map; import pcgen.base.util.CaseInsensitiveMap; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.CDOMSimpleSingleRef; import pcgen.cdom.helper.Capacity; import pcgen.core.Description; import pcgen.core.EquipmentModifier; +import pcgen.core.PCClass; import pcgen.core.WeaponProf; /** @@ -79,6 +81,11 @@ public static final ListKey<RaceSubType> REMOVED_RACESUBTYPE = new ListKey<RaceSubType>(); + public static final ListKey<Integer> HITDICE_ADVANCEMENT = + new ListKey<Integer>(); + + public static final ListKey<CDOMReference<PCClass>> FAVORED_CLASS = new ListKey<CDOMReference<PCClass>>(); + /** Private constructor to prevent instantiation of this class */ private ListKey() { // Only allow instantation here Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/ObjectKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/ObjectKey.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/ObjectKey.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -30,13 +30,14 @@ import java.util.HashSet; import java.util.Map; +import pcgen.base.formula.Resolver; import pcgen.base.util.CaseInsensitiveMap; import pcgen.base.util.DefaultMap; import pcgen.cdom.base.CDOMSimpleSingleRef; +import pcgen.cdom.mode.Size; import pcgen.core.Equipment; import pcgen.core.PCClass; import pcgen.core.PCStat; -import pcgen.core.SizeAdjustment; import pcgen.core.WeaponProf; import pcgen.util.enumeration.Visibility; @@ -53,6 +54,9 @@ * * have a .cast(Object o) method on ObjectKey??? */ + public static final ObjectKey<Resolver<Size>> SIZE = + new ObjectKey<Resolver<Size>>(); + public static final ObjectKey<Region> REGION = new ObjectKey<Region>(); public static final ObjectKey<SubRegion> SUBREGION = new ObjectKey<SubRegion>(); @@ -131,8 +135,6 @@ public static final ObjectKey<Boolean> CONTAINER_CONSTANT_WEIGHT = new ObjectKey<Boolean>(); - public static final ObjectKey<SizeAdjustment> SIZE = new ObjectKey<SizeAdjustment>(); - public static final ObjectKey<AbilityCategory> CATEGORY = new ObjectKey<AbilityCategory>(); public static final ObjectKey<Boolean> ATTACKS_PROGRESS = new ObjectKey<Boolean>(); Added: branches/cdom/code/src/java/pcgen/cdom/formula/FixedSizeResolver.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/formula/FixedSizeResolver.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/formula/FixedSizeResolver.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -0,0 +1,26 @@ +package pcgen.cdom.formula; + +import pcgen.base.formula.Resolver; +import pcgen.cdom.mode.Size; + +public class FixedSizeResolver implements Resolver<Size> +{ + + private final Size size; + + public FixedSizeResolver(Size s) + { + size = s; + } + + public Size resolve() + { + return size; + } + + public String toLSTFormat() + { + return size.toLSTFormat(); + } + +} Added: branches/cdom/code/src/java/pcgen/cdom/formula/FormulaSizeResolver.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/formula/FormulaSizeResolver.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/formula/FormulaSizeResolver.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -0,0 +1,28 @@ +package pcgen.cdom.formula; + +import pcgen.base.formula.Formula; +import pcgen.base.formula.Resolver; +import pcgen.cdom.mode.Size; + +public class FormulaSizeResolver implements Resolver<Size> +{ + + private final Formula size; + + public FormulaSizeResolver(Formula s) + { + size = s; + } + + public Size resolve() + { + //TODO Need to define how this will happen + return null; + } + + public String toLSTFormat() + { + return size.toString(); + } + +} Modified: branches/cdom/code/src/java/pcgen/cdom/mode/Size.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/mode/Size.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/pcgen/cdom/mode/Size.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -18,17 +18,12 @@ package pcgen.cdom.mode; import java.util.Collection; -import java.util.List; import pcgen.base.enumeration.AbstractSequencedConstantFactory; import pcgen.base.enumeration.SequencedType; import pcgen.base.enumeration.TypeSafeConstant; -import pcgen.cdom.base.ConcretePrereqObject; -import pcgen.cdom.base.PrereqObject; -import pcgen.core.prereq.Prerequisite; -public final class Size implements SequencedType, TypeSafeConstant, - PrereqObject +public final class Size implements SequencedType, TypeSafeConstant { /** @@ -115,46 +110,8 @@ } - private PrereqObject pro = new ConcretePrereqObject(); - - public void addAllPrerequisites(Prerequisite... prereqs) + public String toLSTFormat() { - pro.addAllPrerequisites(prereqs); + return toString(); } - - public void addPrerequisite(Prerequisite preReq) - { - pro.addPrerequisite(preReq); - } - - public void clearPrerequisiteList() - { - pro.clearPrerequisiteList(); - } - - public int getPrerequisiteCount() - { - return pro.getPrerequisiteCount(); - } - - public List<Prerequisite> getPrerequisiteList() - { - return pro.getPrerequisiteList(); - } - - public boolean hasPrerequisiteOfType(String matchType) - { - return pro.hasPrerequisiteOfType(matchType); - } - - public boolean hasPrerequisites() - { - return pro.hasPrerequisites(); - } - - public void setPrerequisiteListFrom(PrereqObject prereqObject) - { - pro.setPrerequisiteListFrom(prereqObject); - } - } Modified: branches/cdom/code/src/java/pcgen/persistence/GraphContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/GraphContext.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/pcgen/persistence/GraphContext.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -33,6 +33,7 @@ import pcgen.cdom.graph.PCGraphGrantsEdge; import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.graph.PCGraphHoldsEdge; +import pcgen.cdom.inst.Aggregator; public class GraphContext { @@ -318,4 +319,11 @@ return set; } + public void deleteAggregator(String tokenName, Aggregator agg) + { + unlinkChildNodes(tokenName, agg); + unlinkParentNodes(tokenName, agg); + graph.removeNode(agg); + } + } Modified: branches/cdom/code/src/java/plugin/lsttokens/DescispiLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/DescispiLst.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/DescispiLst.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -71,7 +71,7 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { - boolean set; + Boolean set; char firstChar = value.charAt(0); if (firstChar == 'y' || firstChar == 'Y') { @@ -81,7 +81,7 @@ + getTokenName() + ": " + value); return false; } - set = true; + set = Boolean.TRUE; } else { @@ -94,7 +94,7 @@ return false; } } - set = false; + set = Boolean.FALSE; } obj.setDescPI(set); return true; @@ -102,7 +102,11 @@ public String[] unparse(LoadContext context, CDOMObject obj) { - boolean namePI = obj.isDescPI(); - return new String[]{namePI ? "YES" : "NO"}; + Boolean descPI = obj.getDescPIObject(); + if (descPI == null) + { + return null; + } + return new String[]{descPI.booleanValue() ? "YES" : "NO"}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/NameispiLst.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -71,7 +71,7 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { - boolean set; + Boolean set; char firstChar = value.charAt(0); if (firstChar == 'y' || firstChar == 'Y') { @@ -81,7 +81,7 @@ + getTokenName() + ": " + value); return false; } - set = true; + set = Boolean.TRUE; } else { @@ -94,7 +94,7 @@ return false; } } - set = false; + set = Boolean.FALSE; } obj.setNamePI(set); return true; @@ -102,6 +102,11 @@ public String[] unparse(LoadContext context, CDOMObject obj) { - return new String[]{obj.isNamePI() ? "YES" : "NO"}; + Boolean namePI = obj.getNamePIObject(); + if (namePI == null) + { + return null; + } + return new String[]{namePI.booleanValue() ? "YES" : "NO"}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -36,6 +36,8 @@ import pcgen.cdom.base.Restriction; import pcgen.cdom.base.Slot; import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.cdom.enumeration.AbilityNature; +import pcgen.cdom.enumeration.AssociationKey; import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Ability; @@ -67,8 +69,8 @@ * <li>Choices can be specified by including them in parenthesis after the * ability key name (whitespace is ignored).</li> * - * Last Editor: $Author$ Last Edited: $Date: 2007-03-25 08:09:48 - * -0400 (Sun, 25 Mar 2007) $ + * Last Editor: $Author$ Last Edited: $Date: 2007-03-25 08:09:48 -0400 + * (Sun, 25 Mar 2007) $ * * @author James Dempsey <jde...@us...> * @version $Revision$ @@ -182,7 +184,7 @@ catch (NumberFormatException e) { count = 1; - //This is OK, count is optional + // This is OK, count is optional } // 2 left, because the first was already fetched if (st.countTokens() != 2) @@ -204,10 +206,10 @@ return false; } - Ability.Nature nat; + AbilityNature nat; try { - nat = Ability.Nature.valueOf(st.nextToken()); + nat = AbilityNature.valueOf(st.nextToken()); } catch (IllegalArgumentException iae) { @@ -235,8 +237,7 @@ + " arguments uses double separator ,, : " + value); return false; } - StringTokenizer tok = - new StringTokenizer(items, Constants.COMMA); + StringTokenizer tok = new StringTokenizer(items, Constants.COMMA); Slot<Ability> slot = context.graph.addSlotIntoGraph(getTokenName(), obj, @@ -259,8 +260,8 @@ slot .addSinkRestriction(new GroupRestriction<Ability>(ABILITY_CLASS, cr)); - // FIXME Slot needs to know AbilityNature ?? - + slot.setAssociation(AssociationKey.ABILITY_CATEGORY, ac); + slot.setAssociation(AssociationKey.ABILITY_NATURE, nat); return true; } @@ -290,7 +291,7 @@ return null; } String slotCount = slot.toLSTform(); - String result; + StringBuilder result = new StringBuilder(); List<Restriction<?>> restr = slot.getSinkRestrictions(); if (restr.size() != 1) { @@ -302,14 +303,15 @@ /* * TODO FIXME These need to account for CATEGORY and NATURE */ - if ("1".equals(slotCount)) + if (!"1".equals(slotCount)) { - result = res.toLSTform(); + result.append(slotCount).append(Constants.PIPE); } - else - { - result = slotCount + "|" + res.toLSTform(); - } - return new String[]{result}; + result.append(slot.getAssociation(AssociationKey.ABILITY_CATEGORY)) + .append(Constants.PIPE); + result.append(slot.getAssociation(AssociationKey.ABILITY_NATURE)) + .append(Constants.PIPE); + result.append(res.toLSTform()); + return new String[]{result.toString()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -196,8 +196,9 @@ SortedSet<CategorizedCDOMReference<Ability>> set = new TreeSet<CategorizedCDOMReference<Ability>>( TokenUtilities.CAT_REFERENCE_SORTER); - List<String> list = new ArrayList<String>(m.size()); + Set<String> list = new TreeSet<String>(); + for (Set<Prerequisite> prereqs : m.getKeySet()) { List<CategorizedCDOMReference<Ability>> abilities = Modified: branches/cdom/code/src/java/plugin/lsttokens/equipment/SizeToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipment/SizeToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/equipment/SizeToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -21,9 +21,9 @@ */ package plugin.lsttokens.equipment; -import java.util.Set; - -import pcgen.cdom.graph.PCGraphEdge; +import pcgen.base.formula.Resolver; +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.formula.FixedSizeResolver; import pcgen.cdom.mode.Size; import pcgen.core.Equipment; import pcgen.persistence.LoadContext; @@ -51,8 +51,7 @@ { try { - Size size = Size.valueOf(value); - context.graph.linkObjectIntoGraph(getTokenName(), eq, size); + eq.put(ObjectKey.SIZE, new FixedSizeResolver(Size.valueOf(value))); return true; } catch (IllegalArgumentException e) @@ -65,19 +64,11 @@ public String[] unparse(LoadContext context, Equipment eq) { - Set<PCGraphEdge> links = - context.graph.getChildLinksFromToken(getTokenName(), eq, - Size.class); - if (links == null || links.isEmpty()) + Resolver<Size> res = eq.get(ObjectKey.SIZE); + if (res == null) { return null; } - if (links.size() > 1) - { - context.addWriteMessage("Only 1 Size is allowed per Equipment"); - return null; - } - Size s = (Size) links.iterator().next().getSinkNodes().get(0); - return new String[]{s.toString()}; + return new String[]{res.toLSTFormat()}; } } Deleted: branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/BonusToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/BonusToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/BonusToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -1,60 +0,0 @@ -/* - * Copyright 2006-2007 (C) Tom Parker <th...@us...> - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Current Ver: $Revision$ - * Last Editor: $Author$ - * Last Edited: $Date$ - */ -package plugin.lsttokens.equipmentmodifier; - -import pcgen.core.EquipmentModifier; -import pcgen.persistence.LoadContext; -import pcgen.persistence.PersistenceLayerException; -import pcgen.persistence.lst.EquipmentModifierLstToken; - -/** - * Deals with BONUS token - */ -public class BonusToken implements EquipmentModifierLstToken -{ - - public String getTokenName() - { - return "BONUS"; - } - - public boolean parse(EquipmentModifier mod, String value) - { - mod.addBonusList(value); - return true; - } - - public boolean parse(LoadContext context, EquipmentModifier mod, - String value) throws PersistenceLayerException - { - // FIXME Auto-generated method stub - // Blank because I think this token is useless - <this> only valid - // outside of eqmods... - return true; - } - - public String[] unparse(LoadContext context, EquipmentModifier mod) - { - // FIXME Auto-generated method stub - return null; - } -} Modified: branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/SpropToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/SpropToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/SpropToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -62,29 +62,41 @@ public boolean parse(LoadContext context, EquipmentModifier mod, String value) { + SpecialProperty sa = subParse(context, mod, value); + if (sa == null) + { + return false; + } + context.graph.linkObjectIntoGraph(getTokenName(), mod, sa); + return true; + } + + public SpecialProperty subParse(LoadContext context, EquipmentModifier mod, + String value) + { if (value == null || value.length() == 0) { Logging.errorPrint(getTokenName() + ": line minimally requires " + getTokenName() + ":<text>"); - return false; + return null; } if (value.charAt(0) == '|') { Logging.errorPrint(getTokenName() + " arguments may not start with | : " + value); - return false; + return null; } if (value.charAt(value.length() - 1) == '|') { Logging.errorPrint(getTokenName() + " arguments may not end with | : " + value); - return false; + return null; } if (value.indexOf("||") != -1) { Logging.errorPrint(getTokenName() + " arguments uses double separator || : " + value); - return false; + return null; } StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); @@ -102,20 +114,15 @@ { Logging.errorPrint(getTokenName() + " tag confused by redundant '.CLEAR'" + value); - return false; + return null; } SpecialProperty sa = new SpecialProperty(firstToken); - /* - * CONSIDER TODO This is another issue with this system - it is linked - * in before it's determined if it's really valid... :( - */ - context.graph.linkObjectIntoGraph(getTokenName(), mod, sa); if (!tok.hasMoreTokens()) { // No variables, we're done! - return true; + return sa; } String token = tok.nextToken(); @@ -138,14 +145,14 @@ Logging.errorPrint(getTokenName() + " tag confused by '.CLEAR' as a " + "middle token: " + value); - return false; + return null; } sa.addVariable(FormulaFactory.getFormulaFor(token)); if (!tok.hasMoreTokens()) { // No prereqs, so we're done - return true; + return sa; } token = tok.nextToken(); } @@ -157,7 +164,7 @@ { Logging.errorPrint(" (Did you put items after the " + "PRExxx tags in " + getTokenName() + ":?)"); - return false; + return null; } sa.addPrerequisite(prereq); if (!tok.hasMoreTokens()) @@ -171,7 +178,7 @@ // sa.setSASource("PCCLASS=" + obj.getKeyName() + "|" + level); // } - return true; + return sa; } public String[] unparse(LoadContext context, EquipmentModifier mod) Deleted: branches/cdom/code/src/java/plugin/lsttokens/pcclass/BabToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/BabToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/BabToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -1,22 +0,0 @@ -package plugin.lsttokens.pcclass; - -import pcgen.core.PCClass; -import pcgen.persistence.lst.PCClassLstToken; - -/** - * Class deals with BAB Token - */ -public class BabToken implements PCClassLstToken -{ - - public String getTokenName() - { - return "BAB"; - } - - public boolean parse(PCClass pcclass, String value, int level) - { - // pcclass.setAttackBonusType(value); - return false; - } -} Modified: branches/cdom/code/src/java/plugin/lsttokens/race/FavclassToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/FavclassToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/FavclassToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -21,15 +21,22 @@ */ package plugin.lsttokens.race; +import java.util.List; +import java.util.SortedSet; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.PCClass; import pcgen.core.Race; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.RaceLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; +import pcgen.util.Logging; /** * Class deals with FAVCLASS Token @@ -57,46 +64,61 @@ public boolean parseFavoredClass(LoadContext context, CDOMObject cdo, String value) { - /* - * FIXME This needs to be able to query the CDOMObject for its type... - */ - // Prerequisite prereq = getPrerequisite("!PRExxx:" - // + cdo.get(StringKey.NAME)); - // if (prereq == null) { - // Logging.errorPrint(" result of improper internal build in " - // + getTokenName() + ": " + value); - // return false; - // } - /* - * CONSIDER IS this sufficient for the PRE? - * - * Or is this a PREMULT - what exactly are the rules?!? :) - */ + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } + if (value.charAt(0) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with , : " + value); + return false; + } + if (value.charAt(value.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with , : " + value); + return false; + } + if (value.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator ,, : " + value); + return false; + } StringTokenizer tok = new StringTokenizer(value, Constants.COMMA); while (tok.hasMoreTokens()) { - CDOMReference<PCClass> fc; String tokString = tok.nextToken(); - if (Constants.LST_ANY.equalsIgnoreCase(tokString)) + CDOMReference<PCClass> cl = + TokenUtilities.getObjectReference(context, PCCLASS_CLASS, + tokString); + if (cl == null) { - // TODO Warn on lower case?? - fc = context.ref.getCDOMAllReference(PCCLASS_CLASS); + Logging.errorPrint(" ...error encountered in " + + getTokenName()); + return false; } - else - { - fc = context.ref.getCDOMReference(PCCLASS_CLASS, tokString); - } - // TODO FIXME need to uncomment this... - // context.addPrerequisiteToContent(prereq, fc, XPPenalty.class); + cdo.addToListFor(ListKey.FAVORED_CLASS, cl); } return true; } public String[] unparse(LoadContext context, Race race) { - // TODO Auto-generated method stub - return null; + List<CDOMReference<PCClass>> list = + race.getListFor(ListKey.FAVORED_CLASS); + if (list == null || list.isEmpty()) + { + return null; + } + SortedSet<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); + set.addAll(list); + return new String[]{ReferenceUtilities.joinLstFormat(set, + Constants.COMMA)}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -193,7 +193,7 @@ new TreeSet<CategorizedCDOMReference<Ability>>( TokenUtilities.CAT_REFERENCE_SORTER); - List<String> list = new ArrayList<String>(m.size()); + Set<String> list = new TreeSet<String>(); for (Set<Prerequisite> prereqs : m.getKeySet()) { @@ -210,10 +210,6 @@ sb.append(Constants.PIPE); } needBar = true; - /* - * FIXME This isn't entirely true, is it? I mean, how is the - * category handled with CategorizedSingleRef? - */ sb.append(ab.getLSTformat()); } if (prereqs != null && !prereqs.isEmpty()) Modified: branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceadvancementToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceadvancementToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceadvancementToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -21,15 +21,13 @@ */ package plugin.lsttokens.race; -import java.util.Set; +import java.util.Iterator; +import java.util.List; import java.util.StringTokenizer; import pcgen.cdom.base.Constants; -import pcgen.cdom.graph.PCGraphGrantsEdge; -import pcgen.cdom.graph.PCGraphEdge; -import pcgen.cdom.mode.Size; +import pcgen.cdom.enumeration.ListKey; import pcgen.core.Race; -import pcgen.core.prereq.Prerequisite; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.RaceLstToken; @@ -41,8 +39,6 @@ public class HitdiceadvancementToken extends AbstractToken implements RaceLstToken { - private static final Class<Size> SIZE_CLASS = Size.class; - @Override public String getTokenName() { @@ -87,94 +83,126 @@ public boolean parse(LoadContext context, Race race, String value) { - final StringTokenizer commaTok = - new StringTokenizer(value, Constants.COMMA); - - if (!commaTok.hasMoreTokens()) + if (value.length() == 0) { - Logging.errorPrint(getTokenName() + " requires Tokens"); + Logging.errorPrint(getTokenName() + " may not have empty argument"); return false; } - int base; - Size size; - try + if (value.indexOf(',') == -1) { - base = Integer.parseInt(commaTok.nextToken()); - /* - * BUG FIXME What is HitdiceadvancementToken is hit before SIZE?? - * - * Order of operations :( - */ - Set<PCGraphEdge> set = - context.graph.getChildLinksFromToken("SIZE", race, - SIZE_CLASS); - if (set.size() > 1) - { - return false; - } - PCGraphEdge edge = set.iterator().next(); - size = (Size) edge.getSinkNodes().get(0); + Logging.errorPrint(getTokenName() + + " must have more than one comma delimited argument"); + return false; } - catch (NumberFormatException nfe) + if (value.charAt(0) == ',') { + Logging.errorPrint(getTokenName() + + " arguments may not start with , : " + value); return false; } + if (value.charAt(value.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with , : " + value); + return false; + } + if (value.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator ,, : " + value); + return false; + } + + final StringTokenizer commaTok = + new StringTokenizer(value, Constants.COMMA); + + if (race.containsListFor(ListKey.HITDICE_ADVANCEMENT)) + { + Logging.errorPrint("Encountered second " + getTokenName() + + ": overwriting: " + + race.getListFor(ListKey.HITDICE_ADVANCEMENT)); + race.removeListFor(ListKey.HITDICE_ADVANCEMENT); + } + int last = 0; while (commaTok.hasMoreTokens()) { String tok = commaTok.nextToken(); - Prerequisite p; + int hd; if ("*".equals(tok)) { - // TODO Do I need this?!? - // race.setAdvancementUnlimited(true); - p = getPrerequisite("PREHD:" + base); + if (commaTok.hasMoreTokens()) + { + Logging.errorPrint("Found * in " + getTokenName() + + " but was not at end of list"); + return false; + } + hd = Integer.MAX_VALUE; } else { - int end; try { - end = Integer.parseInt(tok); + hd = Integer.parseInt(tok); + if (hd <= last) + { + Logging.errorPrint("Found " + hd + " in " + + getTokenName() + " but was <= zero " + + "or the previous value in the list: " + value); + return false; + } + last = hd; } catch (NumberFormatException nfe) { return false; } - p = getPrerequisite("PREHD:" + base + "-" + end); - base = end; } - size = size.getNextSize(); - PCGraphGrantsEdge edge = - context.graph.linkObjectIntoGraph(getTokenName(), race, - size); - edge.addPrerequisite(p); + race.addToListFor(ListKey.HITDICE_ADVANCEMENT, Integer.valueOf(hd)); } return true; } public String[] unparse(LoadContext context, Race race) { - Set<PCGraphEdge> edges = - context.graph.getChildLinksFromToken(getTokenName(), race, - Size.class); - if (edges == null || edges.isEmpty()) + List<Integer> list = race.getListFor(ListKey.HITDICE_ADVANCEMENT); + if (list == null || list.isEmpty()) { return null; } - // FIXME Actually, I need to sort the sizes by their order, - // and then extract data from the prereqs... - for (PCGraphEdge edge : edges) + StringBuilder sb = new StringBuilder(); + boolean needsComma = false; + int last = 0; + for (Iterator<Integer> it = list.iterator(); it.hasNext();) { - if (edge.getPrerequisiteCount() != 1) + if (needsComma) { - context.addWriteMessage("Size attached by " + getTokenName() - + " requires a Prerequisiste"); + sb.append(','); } - Prerequisite prereq = edge.getPrerequisiteList().get(0); - Size size = (Size) edge.getSinkNodes().get(0); - + needsComma = true; + Integer hd = it.next(); + if (hd.intValue() == Integer.MAX_VALUE) + { + if (it.hasNext()) + { + context.addWriteMessage("Integer MAX_VALUE found in " + + getTokenName() + " was not at the end of the array."); + return null; + } + sb.append('*'); + } + else + { + if (hd.intValue() <= last) + { + Logging.errorPrint("Found " + hd + " in " + getTokenName() + + " but was <= zero " + + "or the previous value in the list: " + list); + return null; + } + last = hd.intValue(); + sb.append(hd); + } } - // FIXME Auto-generated method stub - return null; + return new String[]{sb.toString()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/HitdieToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -155,10 +155,11 @@ int add = Integer.parseInt(lock.substring(2)); if (add <= 0) { - Logging.errorPrint(getTokenName() - + " was expecting a Positive " - + "Integer for adding Lock, was : " - + lock.substring(2)); + Logging + .errorPrint(getTokenName() + + " was expecting a Positive " + + "Integer for adding Lock, was : " + + lock.substring(2)); return false; } hdm = new HitDieFormula(new AddingFormula(add)); @@ -188,13 +189,17 @@ if (steps <= 0) { Logging.errorPrint("Invalid Step Count: " + steps + " in " - + getTokenName()); + + getTokenName() + " up (must be positive)"); return false; } - // TODO Check steps?? + if (steps >= 5) + { + Logging.errorPrint("Invalid Step Count: " + steps + " in " + + getTokenName() + " up (too large)"); + return false; + } - // FIXME This is passing null, but really needs to be limited!!! - hdm = new HitDieStep(steps, null); + hdm = new HitDieStep(steps, new HitDie(12)); } else if (lock.startsWith("%Hup")) { @@ -220,13 +225,17 @@ if (steps <= 0) { Logging.errorPrint("Invalid Step Count: " + steps + " in " - + getTokenName()); + + getTokenName() + " down (must be positive)"); return false; } - // TODO Check steps?? + if (steps >= 5) + { + Logging.errorPrint("Invalid Step Count: " + steps + " in " + + getTokenName() + " down (too large)"); + return false; + } - // FIXME This is passing null, but really needs to be limited!!! - hdm = new HitDieStep(-steps, null); + hdm = new HitDieStep(-steps, new HitDie(4)); } else if (lock.startsWith("%Hdown")) { Deleted: branches/cdom/code/src/java/plugin/lsttokens/race/InitToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/InitToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/InitToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -1,85 +0,0 @@ -/* - * Copyright 2006-2007 (C) Tom Parker <th...@us...> - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Current Ver: $Revision$ - * Last Editor: $Author$ - * Last Edited: $Date$ - */ -package plugin.lsttokens.race; - -import pcgen.cdom.enumeration.IntegerKey; -import pcgen.core.Race; -import pcgen.persistence.LoadContext; -import pcgen.persistence.lst.RaceLstToken; -import pcgen.util.Logging; - -/** - * Class deals with INIT Token - */ -public class InitToken implements RaceLstToken -{ - - public String getTokenName() - { - return "INIT"; - } - - public boolean parse(Race race, String value) - { - try - { - race.setInitMod(Integer.valueOf(value)); - return true; - } - catch (NumberFormatException nfe) - { - return false; - } - } - - public boolean parse(LoadContext context, Race race, String value) - { - try - { - race.put(IntegerKey.INITIATIVE, Integer.valueOf(value)); - return true; - } - catch (NumberFormatException nfe) - { - Logging.errorPrint(getTokenName() - + " expected an integer. Tag must be of the form: " - + getTokenName() + ":<int>"); - return false; - } - } - - public String[] unparse(LoadContext context, Race race) - { - Integer init = race.get(IntegerKey.INITIATIVE); - if (init == null) - { - return null; - } - if (init.intValue() < 0) - { - context - .addWriteMessage(getTokenName() + " must be an integer >= 0"); - return null; - } - return new String[]{init.toString()}; - } -} Modified: branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -137,13 +137,15 @@ { if (se.getNodeAt(1).equals(skill)) { - /* - * TODO FIXME Unlink isn't enough here, since this Token - * created the aggregator, it needs to delete it as - * well... - */ context.graph.unlinkChildNode(getTokenName(), agg, skill); + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken( + getTokenName(), agg); + if (links == null || links.isEmpty()) + { + context.graph.deleteAggregator(getTokenName(), agg); + } continue PIPEWHILE; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -140,11 +140,13 @@ { context.graph.unlinkChildNode(getTokenName(), agg, skill); - /* - * TODO FIXME Unlink may not be enough here, since this - * Token created the aggregator, it needs to delete it - * as well if all the connections are destroyed... - */ + Set<PCGraphEdge> links = + context.graph.getChildLinksFromToken( + getTokenName(), agg); + if (links == null || links.isEmpty()) + { + context.graph.deleteAggregator(getTokenName(), agg); + } continue PIPEWHILE; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/SizeToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/SizeToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/SizeToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -21,9 +21,9 @@ */ package plugin.lsttokens.race; -import java.util.Set; - -import pcgen.cdom.graph.PCGraphEdge; +import pcgen.base.formula.Resolver; +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.formula.FixedSizeResolver; import pcgen.cdom.mode.Size; import pcgen.core.Race; import pcgen.persistence.LoadContext; @@ -51,8 +51,8 @@ { try { - Size size = Size.valueOf(value); - context.graph.linkObjectIntoGraph(getTokenName(), race, size); + race + .put(ObjectKey.SIZE, new FixedSizeResolver(Size.valueOf(value))); return true; } catch (IllegalArgumentException e) @@ -65,19 +65,11 @@ public String[] unparse(LoadContext context, Race race) { - Set<PCGraphEdge> links = - context.graph.getChildLinksFromToken(getTokenName(), race, - Size.class); - if (links == null || links.isEmpty()) + Resolver<Size> res = race.get(ObjectKey.SIZE); + if (res == null) { return null; } - if (links.size() > 1) - { - context.addWriteMessage("Only 1 Size is allowed per Race"); - return null; - } - Size s = (Size) links.iterator().next().getSinkNodes().get(0); - return new String[]{s.toString()}; + return new String[]{res.toLSTFormat()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -27,6 +27,8 @@ import pcgen.cdom.base.FormulaFactory; import pcgen.cdom.base.Slot; import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.cdom.enumeration.AbilityNature; +import pcgen.cdom.enumeration.AssociationKey; import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.restriction.GroupRestriction; import pcgen.core.Ability; @@ -90,6 +92,12 @@ try { featCount = Integer.parseInt(value); + if (featCount <= 0) + { + Logging.errorPrint("Number in " + getTokenName() + + " must be greater than zero: " + value); + return false; + } } catch (NumberFormatException nfe) { @@ -117,8 +125,10 @@ slot.addSinkRestriction(new GroupRestriction<Ability>(ABILITY_CLASS, ref)); - // FIXME Slot needs to know AbilityNature.???? ?? - + slot.setAssociation(AssociationKey.ABILITY_CATEGORY, + AbilityCategory.FEAT); + slot + .setAssociation(AssociationKey.ABILITY_NATURE, AbilityNature.NORMAL); return true; } @@ -146,6 +156,22 @@ + slot.getSlotClass().getSimpleName()); return null; } + if (!AbilityCategory.FEAT.equals(slot + .getAssociation(AssociationKey.ABILITY_CATEGORY))) + { + context.addWriteMessage("Invalid Ability Category associated with " + + getTokenName() + ": Category cannot be " + + slot.getAssociation(AssociationKey.ABILITY_CATEGORY)); + return null; + } + if (!AbilityNature.NORMAL.equals(slot + .getAssociation(AssociationKey.ABILITY_NATURE))) + { + context.addWriteMessage("Invalid Ability Nature associated with " + + getTokenName() + ": Category cannot be " + + slot.getAssociation(AssociationKey.ABILITY_NATURE)); + return null; + } return new String[]{slot.toLSTform()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/spell/ItemToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/spell/ItemToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/spell/ItemToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -72,10 +72,10 @@ new UnresolvedTypeRestriction<Equipment>(Equipment.class, t, negate); /* - * CONSIDER Need to think about how this should work... this is really - * an ANCESTOR restriction here, since it is based off of the parent - * item (e.g. if it was [Weapon], and this was attached to an EqMod??? - * What happens?) + * CONSIDER FIXME Need to think about how this should work... this is + * really an ANCESTOR restriction here, since it is based off of the + * parent item (e.g. if it was [Weapon], and this was attached to an + * EqMod??? What happens?) */ spell.addSourceRestriction(tr); return true; Modified: branches/cdom/code/src/java/plugin/lsttokens/template/FavoredclassToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/FavoredclassToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/template/FavoredclassToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -21,17 +21,22 @@ */ package plugin.lsttokens.template; +import java.util.List; +import java.util.SortedSet; import java.util.StringTokenizer; +import java.util.TreeSet; import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.PCClass; import pcgen.core.PCTemplate; -import pcgen.core.prereq.Prerequisite; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.PCTemplateLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; /** @@ -62,44 +67,61 @@ public boolean parseFavoredClass(LoadContext context, CDOMObject cdo, String value) { - Prerequisite prereq = - getPrerequisite("!PRETEMPLATE:" + cdo.getKeyName()); - if (prereq == null) + if (value.length() == 0) { - Logging.errorPrint(" result of improper internal build in " - + getTokenName() + ": " + value); + Logging.errorPrint(getTokenName() + " may not have empty argument"); return false; } - /* - * CONSIDER IS this sufficient for the PRE? - * - * Or is this a PREMULT - what exactly are the rules?!? :) - */ + if (value.charAt(0) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with , : " + value); + return false; + } + if (value.charAt(value.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with , : " + value); + return false; + } + if (value.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator ,, : " + value); + return false; + } StringTokenizer tok = new StringTokenizer(value, Constants.COMMA); while (tok.hasMoreTokens()) { - CDOMReference<PCClass> fc; String tokString = tok.nextToken(); - if (Constants.LST_ANY.equalsIgnoreCase(tokString)) + CDOMReference<PCClass> cl = + TokenUtilities.getObjectReference(context, PCCLASS_CLASS, + tokString); + if (cl == null) { - // TODO Warn on lower case?? - fc = context.ref.getCDOMAllReference(PCCLASS_CLASS); + Logging.errorPrint(" ...error encountered in " + + getTokenName()); + return false; } - else - { - fc = context.ref.getCDOMReference(PCCLASS_CLASS, tokString); - } - // TODO FIXME need to uncomment this... - // context.addPrerequisiteToContent(prereq, fc, XPPenalty.class); + cdo.addToListFor(ListKey.FAVORED_CLASS, cl); } return true; } public String[] unparse(LoadContext context, PCTemplate pct) { - // TODO Auto-generated method stub - return null; + List<CDOMReference<PCClass>> list = + pct.getListFor(ListKey.FAVORED_CLASS); + if (list == null || list.isEmpty()) + { + return null; + } + SortedSet<CDOMReference<?>> set = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); + set.addAll(list); + return new String[]{ReferenceUtilities.joinLstFormat(set, + Constants.COMMA)}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -193,8 +193,7 @@ SortedSet<CDOMReference<?>> set = new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); - String[] array = new String[m.size()]; - int index = 0; + Set<String> list = new TreeSet<String>(); for (Set<Prerequisite> prereqs : m.getKeySet()) { @@ -225,8 +224,8 @@ ab + Constants.PIPE + StringUtil.join(prereqSet, Constants.PIPE); } - array[index++] = ab; + list.add(ab); } - return array; + return list.toArray(new String[list.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -153,10 +153,11 @@ int add = Integer.parseInt(lock.substring(2)); if (add <= 0) { - Logging.errorPrint(getTokenName() - + " was expecting a Positive " - + "Integer for adding Lock, was : " - + lock.substring(2)); + Logging + .errorPrint(getTokenName() + + " was expecting a Positive " + + "Integer for adding Lock, was : " + + lock.substring(2)); return false; } hdm = new HitDieFormula(new AddingFormula(add)); @@ -186,13 +187,17 @@ if (steps <= 0) { Logging.errorPrint("Invalid Step Count: " + steps + " in " - + getTokenName()); + + getTokenName() + " up (must be positive)"); return false; } - // TODO Check steps?? + if (steps >= 5) + { + Logging.errorPrint("Invalid Step Count: " + steps + " in " + + getTokenName() + " up (too large)"); + return false; + } - // FIXME This is passing null, but really needs to be limited!!! - hdm = new HitDieStep(steps, null); + hdm = new HitDieStep(steps, new HitDie(12)); } else if (lock.startsWith("%Hup")) { @@ -218,13 +223,17 @@ if (steps <= 0) { Logging.errorPrint("Invalid Step Count: " + steps + " in " - + getTokenName()); + + getTokenName() + " down (must be positive)"); return false; } - // TODO Check steps?? + if (steps >= 5) + { + Logging.errorPrint("Invalid Step Count: " + steps + " in " + + getTokenName() + " down (too large)"); + return false; + } - // FIXME This is passing null, but really needs to be limited!!! - hdm = new HitDieStep(-steps, null); + hdm = new HitDieStep(-steps, new HitDie(4)); } else if (lock.startsWith("%Hdown")) { Modified: branches/cdom/code/src/java/plugin/lsttokens/template/SizeToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/SizeToken.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/java/plugin/lsttokens/template/SizeToken.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -21,14 +21,15 @@ */ package plugin.lsttokens.template; -import java.util.Set; - -import pcgen.cdom.graph.PCGraphEdge; +import pcgen.base.formula.Resolver; +import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.formula.FixedSizeResolver; +import pcgen.cdom.formula.FormulaSizeResolver; import pcgen.cdom.mode.Size; import pcgen.core.PCTemplate; import pcgen.persistence.LoadContext; import pcgen.persistence.lst.PCTemplateLstToken; -import pcgen.util.Logging; /** * Class deals with SIZE Token @@ -49,39 +50,26 @@ public boolean parse(LoadContext context, PCTemplate template, String value) { + Resolver<Size> res; try { - /* - * FIXME This doesn't work, because SIZE can be a formula as well: - * e.g. max(AnimalSize,var("RACESIZE")) - */ - Size size = Size.valueOf(value); - context.graph.linkObjectIntoGraph(getTokenName(), template, size); - return true; + res = new FixedSizeResolver(Size.valueOf(value)); } catch (IllegalArgumentException e) { - Logging.errorPrint("Invalid Size in " + getTokenName() + ": " - + value); - return false; + res = new FormulaSizeResolver(FormulaFactory.getFormulaFor(value)); } + template.put(ObjectKey.SIZE, res); + return true; } - public String[] unparse(LoadContext context, PCTemplate pct) + public String[] unparse(LoadContext context, PCTemplate template) { - Set<PCGraphEdge> links = - context.graph.getChildLinksFromToken(getTokenName(), pct, - Size.class); - if (links == null || links.isEmpty()) + Resolver<Size> res = template.get(ObjectKey.SIZE); + if (res == null) { return null; } - if (links.size() > 1) - { - context.addWriteMessage("Only 1 Size is allowed per Template"); - return null; - } - Size s = (Size) links.iterator().next().getSinkNodes().get(0); - return new String[]{s.toString()}; + return new String[]{res.toLSTFormat()}; } } Modified: branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -19,12 +19,13 @@ import plugin.lsttokens.weaponprof.TokenWeaponProfTestSuite; @RunWith(Suite.class) -@Suite.SuiteClasses({TokenAbilityTestSuite.class, TokenAddTestSuite.class, - TokenAutoTestSuite.class, TokenDeityTestSuite.class, - TokenDomainTestSuite.class, TokenEquipmentTestSuite.class, - TokenEqModTestSuite.class, TokenRaceTestSuite.class, - TokenSkillTestSuite.class, TokenSpellTestSuite.class, - TokenTemplateTestSuite.class, TokenWeaponProfTestSuite.class}) +@Suite.SuiteClasses({TokenGlobalTestSuite.class, TokenAbilityTestSuite.class, + TokenAddTestSuite.class, TokenAutoTestSuite.class, + TokenDeityTestSuite.class, TokenDomainTestSuite.class, + TokenEquipmentTestSuite.class, TokenEqModTestSuite.class, + TokenRaceTestSuite.class, TokenSkillTestSuite.class, + TokenSpellTestSuite.class, TokenTemplateTestSuite.class, + TokenWeaponProfTestSuite.class}) public class AllTokenUnitTests extends TestSuite { // No contents, see annotations Modified: branches/cdom/code/src/utest/plugin/lsttokens/KeyLstTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/KeyLstTest.java 2007-04-07 05:29:36 UTC (rev 2692) +++ branches/cdom/code/src/utest/plugin/lsttokens/KeyLstTest.java 2007-04-07 20:16:45 UTC (rev 2693) @@ -17,14 +17,16 @@ */ package plugin.lsttokens; -import pcgen.cdom.enumeration.StringKey; +import org.junit.Test; + import pcgen.core.PCTemplate; +import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.GlobalLstToken; import pcgen.persi... [truncated message content] |
From: <th...@us...> - 2007-04-08 22:27:42
|
Revision: 2702 http://svn.sourceforge.net/pcgen/?rev=2702&view=rev Author: thpr Date: 2007-04-08 15:27:43 -0700 (Sun, 08 Apr 2007) Log Message: ----------- CDOM: Some PCClass Token Tests & Associated core changes Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/base/Slot.java branches/cdom/code/src/java/pcgen/persistence/lst/LstObjectFileLoader.java branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLoader.java branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractTokenTestCase.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/persistence/lst/LstLoader.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SkillListTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellBookTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellListTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellStatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellTypeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/StartSkillPtsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TemplateTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VFeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VisibleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/WeaponbonusTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XppenaltyTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XtraFeatsTokenTest.java Modified: branches/cdom/code/src/java/pcgen/cdom/base/Slot.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/Slot.java 2007-04-08 12:00:40 UTC (rev 2701) +++ branches/cdom/code/src/java/pcgen/cdom/base/Slot.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -91,7 +91,7 @@ { StringBuilder sb = new StringBuilder(); sb.append("Slot: ").append(slotCount.toString()); - sb.append("objects of ").append(slotClass.getSimpleName()); + sb.append(" objects of ").append(slotClass.getSimpleName()); if (hasSinkRestrictions()) { sb.append(" [").append(getSinkRestrictions().toString()) Added: branches/cdom/code/src/java/pcgen/persistence/lst/LstLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/LstLoader.java (rev 0) +++ branches/cdom/code/src/java/pcgen/persistence/lst/LstLoader.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,11 @@ +package pcgen.persistence.lst; + +import pcgen.core.PObject; +import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; + +public interface LstLoader<T extends PObject> +{ + public void parseLine(LoadContext context, T reference, String line, + CampaignSourceEntry sourceEntry) throws PersistenceLayerException; +} Modified: branches/cdom/code/src/java/pcgen/persistence/lst/LstObjectFileLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/LstObjectFileLoader.java 2007-04-08 12:00:40 UTC (rev 2701) +++ branches/cdom/code/src/java/pcgen/persistence/lst/LstObjectFileLoader.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -57,7 +57,7 @@ * @author AD9C15 */ public abstract class LstObjectFileLoader<T extends PObject> extends - LstFileLoader + LstFileLoader implements LstLoader<T> { /** The String that separates fields in the file. */ public static final String FIELD_SEPARATOR = "\t"; //$NON-NLS-1$ Modified: branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLoader.java 2007-04-08 12:00:40 UTC (rev 2701) +++ branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLoader.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -610,28 +610,44 @@ String value, CampaignSourceEntry source) throws PersistenceLayerException { - PCClassLstToken token = - TokenStore.inst().getToken(PCClassLstToken.class, key); + PCClassUniversalLstToken univtoken = + TokenStore.inst().getToken(PCClassUniversalLstToken.class, key); + PCClassClassLstToken classtoken = + TokenStore.inst().getToken(PCClassClassLstToken.class, key); - if (token == null) + if (classtoken == null) { - if (!PObjectLoader.parseTag(context, pcclass, key, value)) + if (univtoken == null) { - Logging.errorPrint("Illegal pcclass Token '" + key + "' for " - + pcclass.getDisplayName() + " in " + source.getURI() - + " of " + source.getCampaign() + "."); + if (!PObjectLoader.parseTag(context, pcclass, key, value)) + { + Logging + .errorPrint("Illegal pcclass Token '" + key + "' for " + + pcclass.getDisplayName() + " in " + + source.getURI() + " of " + source.getCampaign() + + "."); + } } + else + { + LstUtils.deprecationCheck(univtoken, pcclass, value); + if (!univtoken.parse(context, pcclass, value)) + { + Logging.errorPrint("Error parsing token " + key + + " in pcclass " + pcclass.getDisplayName() + ':' + + source.getURI() + ':' + value + "\""); + } + } } else { - LstUtils.deprecationCheck(token, pcclass, value); - // FIXME TODO Commented out for to avoid attempt at duplicate - // AbilityInfo load - // if (!token.parse(pcclass, value, -9)) { - // Logging.errorPrint("Error parsing token " + key - // + " in pcclass " + pcclass.getDisplayName() + ':' - // + source.getFile() + ':' + value + "\""); - // } + LstUtils.deprecationCheck(classtoken, pcclass, value); + if (!classtoken.parse(context, pcclass, value)) + { + Logging.errorPrint("Error parsing token " + key + + " in pcclass " + pcclass.getDisplayName() + ':' + + source.getURI() + ':' + value + "\""); + } } } Modified: branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java 2007-04-08 12:00:40 UTC (rev 2701) +++ branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -29,6 +29,7 @@ import plugin.lsttokens.domain.TokenDomainTestSuite; import plugin.lsttokens.equipment.TokenEquipmentTestSuite; import plugin.lsttokens.equipmentmodifier.TokenEqModTestSuite; +import plugin.lsttokens.pcclass.TokenPCClassTestSuite; import plugin.lsttokens.race.TokenRaceTestSuite; import plugin.lsttokens.skill.TokenSkillTestSuite; import plugin.lsttokens.spell.TokenSpellTestSuite; @@ -40,9 +41,9 @@ TokenAddTestSuite.class, TokenAutoTestSuite.class, TokenDeityTestSuite.class, TokenDomainTestSuite.class, TokenEquipmentTestSuite.class, TokenEqModTestSuite.class, - TokenRaceTestSuite.class, TokenSkillTestSuite.class, - TokenSpellTestSuite.class, TokenTemplateTestSuite.class, - TokenWeaponProfTestSuite.class}) + TokenPCClassTestSuite.class, TokenRaceTestSuite.class, + TokenSkillTestSuite.class, TokenSpellTestSuite.class, + TokenTemplateTestSuite.class, TokenWeaponProfTestSuite.class}) public class AllTokenUnitTests extends TestSuite { // No contents, see annotations Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SkillListTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SkillListTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SkillListTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.core.SkillList; +import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class SkillListTokenTest extends AbstractTokenTestCase<PCClass> +{ + static SkilllistToken token = new SkilllistToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<? extends PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Test + public void testInvalidInputString() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "String")); + } + + @Test + public void testInvalidInputUnbuilt() throws PersistenceLayerException + { + assertTrue(getToken().parse(primaryContext, primaryProf, "1|String")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testInvalidInputNoCount() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "|TestWP1|TestWP2")); + } + + @Test + public void testInvalidInputJoinedDot() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertTrue(getToken().parse(primaryContext, primaryProf, + "1|TestWP1.TestWP2")); + assertFalse(primaryContext.ref.validate()); + } + + // FIXME These are invalid due to RC being overly protective at the moment + // @Test + // public void testInvalidInputAll() + // { + // assertTrue(getToken().parse(primaryContext, primaryProf, + // "|ALL")); + // assertFalse(primaryContext.ref.validate()); + // } + // + // @Test + // public void testInvalidInputAny() + // { + // assertTrue(getToken().parse(primaryContext, primaryProf, + // "|ANY")); + // assertFalse(primaryContext.ref.validate()); + // } + // @Test + // public void testInvalidInputCheckType() + // { + // if (!isTypeLegal()) + // { + // assertTrue(token.parse(primaryContext, primaryProf, + // "|TYPE=TestType")); + // assertFalse(primaryContext.ref.validate()); + // } + // } + // + + @Test + public void testInvalidListEnd() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, "1|TestWP1|")); + } + + @Test + public void testInvalidListStart() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, "1||TestWP1")); + } + + @Test + public void testInvalidZeroCount() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, "0|TestWP1")); + } + + @Test + public void testInvalidNegativeCount() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "-1|TestWP1|TestWP2")); + } + + @Test + public void testInvalidListDoubleJoin() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "1|TestWP2||TestWP1")); + } + + @Test + public void testInvalidInputCheckMult() throws PersistenceLayerException + { + // Explicitly do NOT build TestWP2 + construct(primaryContext, "TestWP1"); + assertTrue(getToken().parse(primaryContext, primaryProf, + "1|TestWP1|TestWP2")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testValidInputs() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertTrue(getToken().parse(primaryContext, primaryProf, "1|TestWP1")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + "1|TestWP1|TestWP2")); + assertTrue(primaryContext.ref.validate()); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + "2|TestWP1|TestWP2")); + assertTrue(primaryContext.ref.validate()); + } + + @Test + public void testRoundRobinOne() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + runRoundRobin("1|TestWP1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinThree() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(primaryContext, "TestWP3"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + construct(secondaryContext, "TestWP3"); + runRoundRobin("2|TestWP1|TestWP2|TestWP3"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + protected void construct(LoadContext loadContext, String one) + { + loadContext.ref.constructCDOMObject(SkillList.class, one); + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellBookTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellBookTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellBookTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class SpellBookTokenTest extends AbstractTokenTestCase<PCClass> +{ + + static SpellbookToken token = new SpellbookToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Test + public void testInvalidInputString() throws PersistenceLayerException + { + internalTestInvalidInputString(null); + } + + @Test + public void testInvalidInputStringSet() throws PersistenceLayerException + { + assertTrue(token.parse(primaryContext, primaryProf, "YES")); + assertEquals(Boolean.TRUE, primaryProf.get(ObjectKey.SPELLBOOK)); + internalTestInvalidInputString(Boolean.TRUE); + } + + public void internalTestInvalidInputString(Object val) + throws PersistenceLayerException + { + assertEquals(val, primaryProf.get(ObjectKey.SPELLBOOK)); + assertFalse(token.parse(primaryContext, primaryProf, "String")); + assertEquals(val, primaryProf.get(ObjectKey.SPELLBOOK)); + assertFalse(token.parse(primaryContext, primaryProf, "TYPE=TestType")); + assertEquals(val, primaryProf.get(ObjectKey.SPELLBOOK)); + assertFalse(token.parse(primaryContext, primaryProf, "TYPE.TestType")); + assertEquals(val, primaryProf.get(ObjectKey.SPELLBOOK)); + assertFalse(token.parse(primaryContext, primaryProf, "ALL")); + assertEquals(val, primaryProf.get(ObjectKey.SPELLBOOK)); + } + + @Test + public void testValidInputs() throws PersistenceLayerException + { + assertTrue(token.parse(primaryContext, primaryProf, "YES")); + assertEquals(Boolean.TRUE, primaryProf.get(ObjectKey.SPELLBOOK)); + assertTrue(token.parse(primaryContext, primaryProf, "NO")); + assertEquals(Boolean.FALSE, primaryProf.get(ObjectKey.SPELLBOOK)); + // We're nice enough to be case insensitive here... + assertTrue(token.parse(primaryContext, primaryProf, "YeS")); + assertEquals(Boolean.TRUE, primaryProf.get(ObjectKey.SPELLBOOK)); + assertTrue(token.parse(primaryContext, primaryProf, "Yes")); + assertEquals(Boolean.TRUE, primaryProf.get(ObjectKey.SPELLBOOK)); + assertTrue(token.parse(primaryContext, primaryProf, "No")); + assertEquals(Boolean.FALSE, primaryProf.get(ObjectKey.SPELLBOOK)); + } + + @Test + public void testRoundRobinDisplay() throws PersistenceLayerException + { + runRoundRobin("YES"); + } + + @Test + public void testRoundRobinExport() throws PersistenceLayerException + { + runRoundRobin("NO"); + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellListTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellListTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellListTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.core.SpellList; +import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class SpellListTokenTest extends AbstractTokenTestCase<PCClass> +{ + static SpelllistToken token = new SpelllistToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<? extends PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Test + public void testInvalidInputString() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "String")); + } + + @Test + public void testInvalidInputUnbuilt() throws PersistenceLayerException + { + assertTrue(getToken().parse(primaryContext, primaryProf, "1|String")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testInvalidInputNoCount() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "|TestWP1|TestWP2")); + } + + @Test + public void testInvalidInputJoinedDot() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertTrue(getToken().parse(primaryContext, primaryProf, + "1|TestWP1.TestWP2")); + assertFalse(primaryContext.ref.validate()); + } + + // FIXME These are invalid due to RC being overly protective at the moment + // @Test + // public void testInvalidInputAll() + // { + // assertTrue(getToken().parse(primaryContext, primaryProf, + // "|ALL")); + // assertFalse(primaryContext.ref.validate()); + // } + // + // @Test + // public void testInvalidInputAny() + // { + // assertTrue(getToken().parse(primaryContext, primaryProf, + // "|ANY")); + // assertFalse(primaryContext.ref.validate()); + // } + // @Test + // public void testInvalidInputCheckType() + // { + // if (!isTypeLegal()) + // { + // assertTrue(token.parse(primaryContext, primaryProf, + // "|TYPE=TestType")); + // assertFalse(primaryContext.ref.validate()); + // } + // } + // + + @Test + public void testInvalidListEnd() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, "1|TestWP1|")); + } + + @Test + public void testInvalidListStart() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, "1||TestWP1")); + } + + @Test + public void testInvalidZeroCount() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + assertFalse(getToken().parse(primaryContext, primaryProf, "0|TestWP1")); + } + + @Test + public void testInvalidNegativeCount() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "-1|TestWP1|TestWP2")); + } + + @Test + public void testInvalidListDoubleJoin() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "1|TestWP2||TestWP1")); + } + + @Test + public void testInvalidInputCheckMult() throws PersistenceLayerException + { + // Explicitly do NOT build TestWP2 + construct(primaryContext, "TestWP1"); + assertTrue(getToken().parse(primaryContext, primaryProf, + "1|TestWP1|TestWP2")); + assertFalse(primaryContext.ref.validate()); + } + + @Test + public void testValidInputs() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + assertTrue(getToken().parse(primaryContext, primaryProf, "1|TestWP1")); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + "1|TestWP1|TestWP2")); + assertTrue(primaryContext.ref.validate()); + assertTrue(primaryContext.ref.validate()); + assertTrue(getToken().parse(primaryContext, primaryProf, + "2|TestWP1|TestWP2")); + assertTrue(primaryContext.ref.validate()); + } + + @Test + public void testRoundRobinOne() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + runRoundRobin("1|TestWP1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinThree() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(primaryContext, "TestWP3"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + construct(secondaryContext, "TestWP3"); + runRoundRobin("2|TestWP1|TestWP2|TestWP3"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + protected void construct(LoadContext loadContext, String one) + { + loadContext.ref.constructCDOMObject(SpellList.class, one); + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellStatTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellStatTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellStatTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.core.PCStat; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class SpellStatTokenTest extends AbstractTokenTestCase<PCClass> +{ + + static SpellstatToken token = new SpellstatToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + @Before + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + primaryContext.ref.constructCDOMObject(PCStat.class, "STR"); + secondaryContext.ref.constructCDOMObject(PCStat.class, "STR"); + primaryContext.ref.constructCDOMObject(PCStat.class, "INT"); + secondaryContext.ref.constructCDOMObject(PCStat.class, "INT"); + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Test + public void testInvalidNotAStat() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "NAN")); + } + + @Test + public void testInvalidMultipleStatComma() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "STR,INT")); + } + + @Test + public void testInvalidMultipleStatBar() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "STR|INT")); + } + + @Test + public void testInvalidMultipleStatDot() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "STR.INT")); + } + + @Test + public void testRoundRobinDisplay() throws PersistenceLayerException + { + runRoundRobin("STR"); + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellTypeTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellTypeTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellTypeTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.enumeration.Type; +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractTypeSafeTokenTestCase; + +public class SpellTypeTokenTest extends AbstractTypeSafeTokenTestCase<PCClass> +{ + + static SpelltypeToken token = new SpelltypeToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Override + public Object getConstant(String string) + { + return Type.getConstant(string); + } + + @Override + public ObjectKey<?> getObjectKey() + { + return ObjectKey.SPELL_TYPE; + } + + @Test + public void dummyTest() + { + // Just to get Eclipse to recognize this as a JUnit 4.0 Test Case + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/StartSkillPtsTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/StartSkillPtsTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/StartSkillPtsTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import pcgen.cdom.enumeration.FormulaKey; +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractFormulaTokenTestCase; + +public class StartSkillPtsTokenTest extends + AbstractFormulaTokenTestCase<PCClass> +{ + + static StartskillptsToken token = new StartskillptsToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Override + public FormulaKey getFormulaKey() + { + return FormulaKey.START_SKILL_POINTS; + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TemplateTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TemplateTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TemplateTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractListTokenTestCase; + +public class TemplateTokenTest extends + AbstractListTokenTestCase<PObject, PCTemplate> +{ + + static TemplateToken token = new TemplateToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader getLoader() + { + return loader; + } + + @Override + public CDOMToken<PObject> getToken() + { + return token; + } + + @Override + public char getJoinCharacter() + { + return '|'; + } + + @Override + public Class<PCTemplate> getTargetClass() + { + return PCTemplate.class; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Test + public void testInvalidEmptyChoose() + { + assertFalse(token.parse(primaryContext, primaryProf, "CHOOSE:")); + } + + @Test + public void testInvalidChooseListStart() + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + assertFalse(token.parse(primaryContext, primaryProf, "CHOOSE:|TestWP1")); + } + + @Test + public void testInvalidChooseDoubleJoin() + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP2"); + assertFalse(token.parse(primaryContext, primaryProf, + "CHOOSE:TestWP2||TestWP1")); + } + + @Test + public void testInvalidChooseListEnd() + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + assertFalse(token.parse(primaryContext, primaryProf, "CHOOSE:TestWP1|")); + } + + @Test + public void testInvalidEmptyAddChoice() + { + assertFalse(token.parse(primaryContext, primaryProf, "ADDCHOICE:")); + } + + @Test + public void testValidChooseInputs() + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP2"); + assertTrue(token.parse(primaryContext, primaryProf, "CHOOSE:TestWP1")); + assertTrue(primaryContext.ref.validate()); + assertTrue(token.parse(primaryContext, primaryProf, + "CHOOSE:TestWP1|TestWP2")); + assertTrue(primaryContext.ref.validate()); + } + + @Test + public void testRoundRobinChooseOne() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP2"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP2"); + runRoundRobin("CHOOSE:TestWP1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinChooseThree() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP2"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP3"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP2"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP3"); + runRoundRobin("CHOOSE:TestWP1|TestWP2|TestWP3"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinComplex() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP2"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP3"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP4"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP5"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP1"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP2"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP3"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP4"); + secondaryContext.ref.constructCDOMObject(getTargetClass(), "TestWP5"); + runRoundRobin("TestWP4|TestWP5", "CHOOSE:TestWP1|TestWP2|TestWP3"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +import junit.framework.TestSuite; + +@RunWith(Suite.class) +@Suite.SuiteClasses({SkillListTokenTest.class, SpellBookTokenTest.class, + SpellListTokenTest.class, SpellStatTokenTest.class, + SpellTypeTokenTest.class, StartSkillPtsTokenTest.class, + TemplateTokenTest.class, VFeatTokenTest.class, VisibleTokenTest.class, + WeaponbonusTokenTest.class, XppenaltyTokenTest.class, + XtraFeatsTokenTest.class}) +public class TokenPCClassTestSuite extends TestSuite +{ + // No contents, see annotations +} \ No newline at end of file Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VFeatTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VFeatTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VFeatTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.core.Ability; +import pcgen.core.PCClass; +import pcgen.core.PObject; +import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractListTokenTestCase; +import plugin.lsttokens.testsupport.TokenRegistration; +import plugin.pretokens.parser.PreClassParser; +import plugin.pretokens.parser.PreRaceParser; +import plugin.pretokens.writer.PreClassWriter; +import plugin.pretokens.writer.PreRaceWriter; + +public class VFeatTokenTest extends AbstractListTokenTestCase<PObject, Ability> +{ + static VfeatToken token = new VfeatToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + PreClassParser preclass = new PreClassParser(); + PreClassWriter preclasswriter = new PreClassWriter(); + PreRaceParser prerace = new PreRaceParser(); + PreRaceWriter preracewriter = new PreRaceWriter(); + + @Override + @Before + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + TokenRegistration.register(preclass); + TokenRegistration.register(preclasswriter); + TokenRegistration.register(prerace); + TokenRegistration.register(preracewriter); + } + + @Override + public char getJoinCharacter() + { + return '|'; + } + + @Override + public Class<Ability> getTargetClass() + { + return Ability.class; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader getLoader() + { + return loader; + } + + @Override + public CDOMToken<PObject> getToken() + { + return token; + } + + @Override + protected void construct(LoadContext loadContext, String one) + { + Ability obj = loadContext.ref.constructCDOMObject(Ability.class, one); + loadContext.ref.reassociateReference(AbilityCategory.FEAT, obj); + } + + @Test + public void testInvalidInputEmpty() + { + assertFalse(token.parse(primaryContext, primaryProf, "")); + } + + @Test + public void testInvalidInputEmbeddedPre() + { + construct(primaryContext, "TestWP1"); + assertFalse(token.parse(primaryContext, primaryProf, + "TestWP1|PRECLASS:1,Fighter=1|TestWP2")); + } + + @Test + public void testInvalidInputDoublePipePre() + { + construct(primaryContext, "TestWP1"); + assertFalse(token.parse(primaryContext, primaryProf, + "TestWP1||PRECLASS:1,Fighter=1")); + } + + @Test + public void testInvalidInputPostPrePipe() + { + construct(primaryContext, "TestWP1"); + assertFalse(token.parse(primaryContext, primaryProf, + "TestWP1|PRECLASS:1,Fighter=1|")); + } + + @Test + public void testRoundRobinPre() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(secondaryContext, "TestWP1"); + runRoundRobin("TestWP1|PRECLASS:1,Fighter=1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinTwoPre() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(secondaryContext, "TestWP1"); + runRoundRobin("TestWP1|!PRERACE:1,Human|PRECLASS:1,Fighter=1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinNotPre() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(secondaryContext, "TestWP1"); + runRoundRobin("TestWP1|!PRECLASS:1,Fighter=1"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + + @Test + public void testRoundRobinWWoPre() throws PersistenceLayerException + { + construct(primaryContext, "TestWP1"); + construct(primaryContext, "TestWP2"); + construct(secondaryContext, "TestWP1"); + construct(secondaryContext, "TestWP2"); + runRoundRobin("TestWP1|PRECLASS:1,Fighter=1", "TestWP2"); + assertTrue(primaryContext.ref.validate()); + assertTrue(secondaryContext.ref.validate()); + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VisibleTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VisibleTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VisibleTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import pcgen.util.enumeration.Visibility; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class VisibleTokenTest extends AbstractTokenTestCase<PCClass> +{ + + static VisibleToken token = new VisibleToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Test + public void testInvalidOutput() + { + assertTrue(primaryContext.getWriteMessageCount() == 0); + primaryProf.put(ObjectKey.VISIBILITY, Visibility.QUALIFY); + assertNull(token.unparse(primaryContext, primaryProf)); + assertFalse(primaryContext.getWriteMessageCount() == 0); + } + + @Test + public void testInvalidInputString() throws PersistenceLayerException + { + internalTestInvalidInputString(null); + } + + @Test + public void testInvalidInputStringSet() throws PersistenceLayerException + { + assertTrue(token.parse(primaryContext, primaryProf, "NO")); + assertEquals(Visibility.NO, primaryProf.get(ObjectKey.VISIBILITY)); + internalTestInvalidInputString(Visibility.NO); + } + + public void internalTestInvalidInputString(Object val) + throws PersistenceLayerException + { + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + assertFalse(token.parse(primaryContext, primaryProf, "Always")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + assertFalse(token.parse(primaryContext, primaryProf, "String")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + assertFalse(token.parse(primaryContext, primaryProf, "TYPE=TestType")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + assertFalse(token.parse(primaryContext, primaryProf, "TYPE.TestType")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + assertFalse(token.parse(primaryContext, primaryProf, "ALL")); + assertEquals(val, primaryProf.get(ObjectKey.VISIBILITY)); + // Note case sensitivity + assertFalse(token.parse(primaryContext, primaryProf, "Yes")); + } + + @Test + public void testValidInputs() throws PersistenceLayerException + { + // assertTrue(token.parse(primaryContext, primaryProf, "DISPLAY")); + // assertEquals(Visibility.DISPLAY, + // primaryProf.get(ObjectKey.VISIBILITY)); + // assertTrue(token.parse(primaryContext, primaryProf, "EXPORT")); + // assertEquals(Visibility.EXPORT, + // primaryProf.get(ObjectKey.VISIBILITY)); + assertTrue(token.parse(primaryContext, primaryProf, "YES")); + assertEquals(Visibility.YES, primaryProf.get(ObjectKey.VISIBILITY)); + assertTrue(token.parse(primaryContext, primaryProf, "NO")); + assertEquals(Visibility.NO, primaryProf.get(ObjectKey.VISIBILITY)); + } + + // + // @Test + // public void testRoundRobinDisplay() throws PersistenceLayerException + // { + // runRoundRobin("DISPLAY"); + // } + // + // @Test + // public void testRoundRobinExport() throws PersistenceLayerException + // { + // runRoundRobin("EXPORT"); + // } + + @Test + public void testRoundRobinYes() throws PersistenceLayerException + { + runRoundRobin("YES"); + } + + @Test + public void testRoundRobinNo() throws PersistenceLayerException + { + runRoundRobin("NO"); + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/WeaponbonusTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/WeaponbonusTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/WeaponbonusTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.core.WeaponProf; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractListTokenTestCase; + +public class WeaponbonusTokenTest extends + AbstractListTokenTestCase<PCClass, WeaponProf> +{ + + static WeaponbonusToken token = new WeaponbonusToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Override + public Class<WeaponProf> getTargetClass() + { + return WeaponProf.class; + } + + @Override + public boolean isTypeLegal() + { + return true; + } + + @Override + public char getJoinCharacter() + { + return '|'; + } + + @Test + public void dummyTest() + { + // Just to get Eclipse to recognize this as a JUnit 4.0 Test Case + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XppenaltyTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XppenaltyTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XppenaltyTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import pcgen.util.enumeration.DefaultTriState; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class XppenaltyTokenTest extends AbstractTokenTestCase<PCClass> +{ + + static XppenaltyToken token = new XppenaltyToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Test + public void testInvalidInputString() throws PersistenceLayerException + { + internalTestInvalidInputString(null); + } + + @Test + public void testInvalidInputStringSet() throws PersistenceLayerException + { + assertTrue(token.parse(primaryContext, primaryProf, "DEFAULT")); + assertEquals(DefaultTriState.DEFAULT, primaryProf + .get(ObjectKey.XP_PENALTY)); + internalTestInvalidInputString(DefaultTriState.DEFAULT); + } + + public void internalTestInvalidInputString(Object val) + throws PersistenceLayerException + { + assertEquals(val, primaryProf.get(ObjectKey.XP_PENALTY)); + assertFalse(token.parse(primaryContext, primaryProf, "Always")); + assertEquals(val, primaryProf.get(ObjectKey.XP_PENALTY)); + assertFalse(token.parse(primaryContext, primaryProf, "String")); + assertEquals(val, primaryProf.get(ObjectKey.XP_PENALTY)); + assertFalse(token.parse(primaryContext, primaryProf, "TYPE=TestType")); + assertEquals(val, primaryProf.get(ObjectKey.XP_PENALTY)); + assertFalse(token.parse(primaryContext, primaryProf, "TYPE.TestType")); + assertEquals(val, primaryProf.get(ObjectKey.XP_PENALTY)); + assertFalse(token.parse(primaryContext, primaryProf, "ALL")); + assertEquals(val, primaryProf.get(ObjectKey.XP_PENALTY)); + // Note case sensitivity + assertFalse(token.parse(primaryContext, primaryProf, "Yes")); + } + + @Test + public void testValidInputs() throws PersistenceLayerException + { + assertTrue(token.parse(primaryContext, primaryProf, "DEFAULT")); + assertEquals(DefaultTriState.DEFAULT, primaryProf + .get(ObjectKey.XP_PENALTY)); + assertTrue(token.parse(primaryContext, primaryProf, "YES")); + assertEquals(DefaultTriState.YES, primaryProf.get(ObjectKey.XP_PENALTY)); + assertTrue(token.parse(primaryContext, primaryProf, "NO")); + assertEquals(DefaultTriState.NO, primaryProf.get(ObjectKey.XP_PENALTY)); + } + + @Test + public void testRoundRobinDefault() throws PersistenceLayerException + { + runRoundRobin("DEFAULT"); + } + + @Test + public void testRoundRobinYes() throws PersistenceLayerException + { + runRoundRobin("YES"); + } + + @Test + public void testRoundRobinNo() throws PersistenceLayerException + { + runRoundRobin("NO"); + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XtraFeatsTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XtraFeatsTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XtraFeatsTokenTest.java 2007-04-08 22:27:43 UTC (rev 2702) @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lst... [truncated message content] |
From: <th...@us...> - 2007-04-12 00:08:34
|
Revision: 2723 http://svn.sourceforge.net/pcgen/?rev=2723&view=rev Author: thpr Date: 2007-04-11 17:08:35 -0700 (Wed, 11 Apr 2007) Log Message: ----------- CDOM: Some PCClass Token Tests & Associated core changes Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/content/LevelExchange.java branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLevelLoader.java branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLoader.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/AttackcycleToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/CastToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/DomainToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/ExchangelevelToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownspellsfromspecialtyToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/SpecialtyknownToken.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/skill/ClassesTokenTest.java Added Paths: ----------- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AbstractSpellCastingTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AttackCycleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/CastTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/DomainTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExClassTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExchangeLevelTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/HDTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownSpellsFromSpecialtyTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpecialtyKnownTokenTest.java Modified: branches/cdom/code/src/java/pcgen/cdom/content/LevelExchange.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/LevelExchange.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/pcgen/cdom/content/LevelExchange.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -32,12 +32,85 @@ private final int donatingLowerLevelBound; - public LevelExchange(CDOMSingleRef<PCClass> pcc, int minDonatingLvl, int maxDonated, - int donatingLowerBound) + public LevelExchange(CDOMSingleRef<PCClass> pcc, int minDonatingLvl, + int maxDonated, int donatingLowerBound) { + if (minDonatingLvl <= 0) + { + throw new IllegalArgumentException( + "Error: Min Donatign Level <= 0: " + + "Cannot Allow Donations to produce negative levels"); + } + if (maxDonated <= 0) + { + throw new IllegalArgumentException( + "Error: Max Donated Levels <= 0: " + + "Cannot Allow Donations to produce negative levels"); + } + if (donatingLowerBound < 0) + { + throw new IllegalArgumentException( + "Error: Max Remaining Levels < 0: " + + "Cannot Allow Donations to produce negative levels"); + } + if (donatingLowerBound < 0) + { + throw new IllegalArgumentException( + "Error: Min Remaining Levels < 0: " + + "Cannot Allow Donations to produce negative levels"); + } + if (minDonatingLvl - maxDonated > donatingLowerBound) + { + throw new IllegalArgumentException( + "Error: Donating Lower Bound cannot be reached"); + } exchangeClass = pcc; minDonatingLevel = minDonatingLvl; maxDonatedLevels = maxDonated; donatingLowerLevelBound = donatingLowerBound; } + + public int getDonatingLowerLevelBound() + { + return donatingLowerLevelBound; + } + + public CDOMSingleRef<PCClass> getExchangeClass() + { + return exchangeClass; + } + + public int getMaxDonatedLevels() + { + return maxDonatedLevels; + } + + public int getMinDonatingLevel() + { + return minDonatingLevel; + } + + public int hashCode() + { + return minDonatingLevel * 23 + maxDonatedLevels * 31 + + donatingLowerLevelBound; + } + + @Override + public boolean equals(Object o) + { + if (o == this) + { + return true; + } + if (!(o instanceof LevelExchange)) + { + return false; + } + LevelExchange other = (LevelExchange) o; + return minDonatingLevel == other.minDonatingLevel + && maxDonatedLevels == other.maxDonatedLevels + && donatingLowerLevelBound == other.donatingLowerLevelBound + && exchangeClass.equals(other.exchangeClass); + } } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLevelLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLevelLoader.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLevelLoader.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -2,54 +2,83 @@ import java.util.StringTokenizer; -import pcgen.cdom.inst.PCClassLevel; +import pcgen.core.PCClass; import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.SystemLoader; import pcgen.util.Logging; -public class PCClassLevelLoader { +public class PCClassLevelLoader +{ - public static void parseLine(LoadContext context, PCClassLevel target, - String lstLine, CampaignSourceEntry source) throws PersistenceLayerException { - final StringTokenizer colToken = new StringTokenizer(lstLine, - SystemLoader.TAB_DELIM); - //Throw away name: - colToken.nextToken(); - - while (colToken.hasMoreTokens()) { + public static void parseLine(LoadContext context, PCClass pcclass, + String lstLine, CampaignSourceEntry source, int level) + throws PersistenceLayerException + { + final StringTokenizer colToken = + new StringTokenizer(lstLine, SystemLoader.TAB_DELIM); + while (colToken.hasMoreTokens()) + { String colString = colToken.nextToken().trim(); int idxColon = colString.indexOf(':'); - if (idxColon == -1) { + if (idxColon == -1) + { Logging.errorPrint("Invalid Token - does not contain a colon: " - + colString); + + colString); return; - } else if (idxColon == 0) { + } + else if (idxColon == 0) + { Logging.errorPrint("Invalid Token - starts with a colon: " - + colString); + + colString); return; } String key = colString.substring(0, idxColon); - String value = (idxColon == colString.length() - 1) ? null : colString.substring(idxColon + 1); + String value = + (idxColon == colString.length() - 1) ? null : colString + .substring(idxColon + 1); - PCClassLstToken token = TokenStore.inst().getToken(PCClassLstToken.class, - key); + PCClassUniversalLstToken univtoken = + TokenStore.inst().getToken(PCClassUniversalLstToken.class, + key); + PCClassLevelLstToken levelToken = + TokenStore.inst().getToken(PCClassLevelLstToken.class, key); - if (token == null) { - if (!PObjectLoader.parseTag(context, target, key, value)) { - Logging.errorPrint("Illegal pcclass Token '" + key + "' for " - + target.getDisplayName() + " in " + source.getURI() - + " of " + source.getCampaign() + "."); + if (levelToken == null) + { + if (univtoken == null) + { + if (!PObjectLoader.parseTag(context, pcclass + .getClassLevel(level), key, value)) + { + Logging.errorPrint("Illegal pcclass Token '" + key + + "' for " + pcclass.getDisplayName() + " in " + + source.getURI() + " of " + source.getCampaign() + + "."); + } } - } else { - LstUtils.deprecationCheck(token, target, value); - if (!token.parse(target, value, target.getClassLevel())) { - Logging.errorPrint("Error parsing token " + key + " in pcclass " - + target.getDisplayName() + ':' + source.getURI() + ':' - + value + "\""); + else + { + LstUtils.deprecationCheck(univtoken, pcclass, value); + if (!univtoken.parse(context, pcclass.getClassLevel(level), + value)) + { + Logging.errorPrint("Error parsing token " + key + + " in pcclass " + pcclass.getDisplayName() + ':' + + source.getURI() + ':' + value + "\""); + } } } + else + { + LstUtils.deprecationCheck(levelToken, pcclass, value); + if (!levelToken.parse(context, pcclass, value, level)) + { + Logging.errorPrint("Error parsing token " + key + + " in pcclass " + pcclass.getDisplayName() + ':' + + source.getURI() + ':' + value + "\""); + } + } } } - } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLoader.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/pcgen/persistence/lst/PCClassLoader.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -26,7 +26,6 @@ import java.util.Map; import java.util.StringTokenizer; -import pcgen.cdom.inst.PCClassLevel; import pcgen.core.Globals; import pcgen.core.PCClass; import pcgen.core.PObject; @@ -106,10 +105,7 @@ try { int lvl = Integer.parseInt(firstToken); - // TODO FIXME Should this really be through LoadContext?? - PCClassLevel level = target.getClassLevel(lvl); - level.setName(target.getDisplayName() + "(" + lvl + ")"); - PCClassLevelLoader.parseLine(context, level, lstLine, source); + PCClassLevelLoader.parseLine(context, target, restOfLine, source, lvl); } catch (NumberFormatException nfe) { Modified: branches/cdom/code/src/java/plugin/lsttokens/pcclass/AttackcycleToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/AttackcycleToken.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/AttackcycleToken.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -60,6 +60,12 @@ while (aTok.hasMoreTokens()) { AttackType at = AttackType.getInstance(aTok.nextToken()); + if (AttackType.GRAPPLE.equals(at)) + { + Logging.errorPrint("Error: Cannot Set Attack Cycle " + + "for GRAPPLE Attack Type"); + return false; + } String cycle = aTok.nextToken(); pcclass.setAttackCycle(at, cycle); /* @@ -85,12 +91,29 @@ public boolean parse(LoadContext context, PCClass pcc, String value) throws PersistenceLayerException { - if (value.indexOf('|') == -1) + if (value.length() == 0) { - Logging.errorPrint("Invalid " + getTokenName() - + " encountered. Requires a | : " + value); + Logging.errorPrint(getTokenName() + " may not have empty argument"); return false; } + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } StringTokenizer aTok = new StringTokenizer(value, Constants.PIPE); if (aTok.countTokens() % 2 == 1) @@ -103,6 +126,12 @@ while (aTok.hasMoreTokens()) { AttackType at = AttackType.getInstance(aTok.nextToken()); + if (AttackType.GRAPPLE.equals(at)) + { + Logging.errorPrint("Error: Cannot Set Attack Cycle " + + "for GRAPPLE Attack Type"); + return false; + } String cycle = aTok.nextToken(); pcc.setAttackCycle(at, cycle); /* @@ -128,6 +157,10 @@ public String[] unparse(LoadContext context, PCClass pcc) { Map<AttackType, String> map = pcc.getAttackCycle(); + if (map == null || map.isEmpty()) + { + return null; + } Set<String> set = new TreeSet<String>(); for (Entry<AttackType, String> me : map.entrySet()) { Modified: branches/cdom/code/src/java/plugin/lsttokens/pcclass/CastToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/CastToken.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/CastToken.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -67,12 +67,49 @@ public boolean parse(LoadContext context, PCClass pcc, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } + if (value.charAt(0) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with , : " + value); + return false; + } + if (value.charAt(value.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with , : " + value); + return false; + } + if (value.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator ,, : " + value); + return false; + } StringTokenizer st = new StringTokenizer(value, Constants.COMMA); List<String> castList = new ArrayList<String>(st.countTokens()); while (st.hasMoreTokens()) { - castList.add(st.nextToken()); + String tok = st.nextToken(); + try + { + if (Integer.parseInt(tok) < 0) + { + Logging.errorPrint("Invalid Spell Count: " + tok + + " is less than zero"); + return false; + } + } + catch (NumberFormatException e) + { + // OK, it must be a formula... + } + castList.add(tok); } SpellProgressionInfo sp = pcc.getCDOMSpellProgression(); Modified: branches/cdom/code/src/java/plugin/lsttokens/pcclass/DomainToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/DomainToken.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/DomainToken.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -163,26 +163,27 @@ while (pipeTok.hasMoreTokens()) { + String tok = pipeTok.nextToken(); // Note: May contain PRExxx String domainKey; Prerequisite prereq = null; - int openBracketLoc = value.indexOf('['); + int openBracketLoc = tok.indexOf('['); if (openBracketLoc == -1) { - domainKey = value; + domainKey = tok; } else { - if (value.indexOf(']') != value.length() - 1) + if (tok.indexOf(']') != tok.length() - 1) { Logging.errorPrint("Invalid " + getTokenName() + " must end with ']' if it contains a PREREQ tag"); return false; } - domainKey = value.substring(0, openBracketLoc); + domainKey = tok.substring(0, openBracketLoc); String prereqString = - value.substring(openBracketLoc + 1, value.length() - 1); + tok.substring(openBracketLoc + 1, tok.length() - 1); if (prereqString.length() == 0) { Logging.errorPrint(getTokenName() @@ -208,9 +209,9 @@ public String[] unparse(LoadContext context, PObject po) { Set<PCGraphEdge> domainEdges = - context.graph.getParentLinksFromToken(getTokenName(), po, + context.graph.getChildLinksFromToken(getTokenName(), po, Domain.class); - if (domainEdges.isEmpty()) + if (domainEdges == null || domainEdges.isEmpty()) { return null; } @@ -253,6 +254,7 @@ sb.append(swriter.toString()); sb.append(']'); } + set.add(sb.toString()); } return new String[]{StringUtil.join(set, Constants.PIPE)}; } Modified: branches/cdom/code/src/java/plugin/lsttokens/pcclass/ExchangelevelToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/ExchangelevelToken.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/ExchangelevelToken.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -21,10 +21,12 @@ */ package plugin.lsttokens.pcclass; +import java.util.Set; import java.util.StringTokenizer; import pcgen.cdom.base.CDOMSimpleSingleRef; import pcgen.cdom.content.LevelExchange; +import pcgen.cdom.graph.PCGraphEdge; import pcgen.core.Constants; import pcgen.core.PCClass; import pcgen.persistence.LoadContext; @@ -93,11 +95,6 @@ try { mindl = Integer.parseInt(mindlString); - if (mindl <= 0) - { - Logging.errorPrint(getTokenName() + " must be an integer > 0"); - return false; - } } catch (NumberFormatException nfe) { @@ -110,11 +107,6 @@ try { maxdl = Integer.parseInt(maxdlString); - if (maxdl <= 0) - { - Logging.errorPrint(getTokenName() + " must be an integer > 0"); - return false; - } } catch (NumberFormatException nfe) { @@ -127,11 +119,6 @@ try { minrem = Integer.parseInt(minremString); - if (minrem <= 0) - { - Logging.errorPrint(getTokenName() + " must be an integer > 0"); - return false; - } } catch (NumberFormatException nfe) { @@ -139,14 +126,43 @@ + minremString); return false; } - LevelExchange le = new LevelExchange(cl, mindl, maxdl, minrem); - context.graph.linkObjectIntoGraph(getTokenName(), pcc, le); - return true; + try + { + LevelExchange le = new LevelExchange(cl, mindl, maxdl, minrem); + context.graph.linkObjectIntoGraph(getTokenName(), pcc, le); + return true; + } + catch (IllegalArgumentException e) + { + Logging.errorPrint("Error in " + getTokenName() + " " + + e.getMessage()); + Logging.errorPrint(" Token contents: " + value); + return false; + } } public String[] unparse(LoadContext context, PCClass pcc) { - // TODO Auto-generated method stub - return null; + Set<PCGraphEdge> edges = + context.graph.getChildLinksFromToken(getTokenName(), pcc, + LevelExchange.class); + if (edges.isEmpty()) + { + return null; + } + if (edges.size() > 1) + { + context.addWriteMessage("Invalid " + getTokenName() + + ": only one link is allowed"); + return null; + } + PCGraphEdge edge = edges.iterator().next(); + LevelExchange le = (LevelExchange) edge.getNodeAt(1); + StringBuilder sb = new StringBuilder(); + sb.append(le.getExchangeClass().getLSTformat()).append(Constants.PIPE); + sb.append(le.getMinDonatingLevel()).append(Constants.PIPE); + sb.append(le.getMaxDonatedLevels()).append(Constants.PIPE); + sb.append(le.getDonatingLowerLevelBound()); + return new String[]{sb.toString()}; } } Modified: branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownToken.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownToken.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -73,12 +73,49 @@ public boolean parse(LoadContext context, PCClass pcc, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } + if (value.charAt(0) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with , : " + value); + return false; + } + if (value.charAt(value.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with , : " + value); + return false; + } + if (value.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator ,, : " + value); + return false; + } StringTokenizer st = new StringTokenizer(value, Constants.COMMA); List<String> knownList = new ArrayList<String>(st.countTokens()); while (st.hasMoreTokens()) { - knownList.add(st.nextToken()); + String tok = st.nextToken(); + try + { + if (Integer.parseInt(tok) < 0) + { + Logging.errorPrint("Invalid Spell Count: " + tok + + " is less than zero"); + return false; + } + } + catch (NumberFormatException e) + { + // OK, it must be a formula... + } + knownList.add(tok); } SpellProgressionInfo sp = pcc.getCDOMSpellProgression(); Modified: branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownspellsfromspecialtyToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownspellsfromspecialtyToken.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownspellsfromspecialtyToken.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -87,7 +87,7 @@ if (ksfs.intValue() <= 0) { context - .addWriteMessage(getTokenName() + " must be an integer >= 0"); + .addWriteMessage(getTokenName() + " must be an integer > 0"); return null; } return new String[]{ksfs.toString()}; Modified: branches/cdom/code/src/java/plugin/lsttokens/pcclass/SpecialtyknownToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/SpecialtyknownToken.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/SpecialtyknownToken.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -32,6 +32,7 @@ import pcgen.persistence.LoadContext; import pcgen.persistence.lst.PCClassLevelLstToken; import pcgen.persistence.lst.PCClassLstToken; +import pcgen.util.Logging; /** * Class deals with SPECIALTYKNOWN Token @@ -62,12 +63,49 @@ public boolean parse(LoadContext context, PCClass pcc, String value, int level) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " may not have empty argument"); + return false; + } + if (value.charAt(0) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with , : " + value); + return false; + } + if (value.charAt(value.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with , : " + value); + return false; + } + if (value.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator ,, : " + value); + return false; + } StringTokenizer st = new StringTokenizer(value, Constants.COMMA); List<String> knownList = new ArrayList<String>(st.countTokens()); while (st.hasMoreTokens()) { - knownList.add(st.nextToken()); + String tok = st.nextToken(); + try + { + if (Integer.parseInt(tok) < 0) + { + Logging.errorPrint("Invalid Spell Count: " + tok + + " is less than zero"); + return false; + } + } + catch (NumberFormatException e) + { + // OK, it must be a formula... + } + knownList.add(tok); } SpellProgressionInfo sp = pcc.getCDOMSpellProgression(); Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AbstractSpellCastingTokenTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AbstractSpellCastingTokenTestCase.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AbstractSpellCastingTokenTestCase.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,190 @@ +package plugin.lsttokens.pcclass; + +import java.net.URI; +import java.net.URISyntaxException; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +import pcgen.cdom.graph.PCGenGraph; +import pcgen.core.Campaign; +import pcgen.core.PCClass; +import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CampaignSourceEntry; +import pcgen.persistence.lst.LstToken; +import pcgen.persistence.lst.PCClassLevelLoader; +import pcgen.persistence.lst.PCClassLevelLstToken; +import pcgen.persistence.lst.TokenStore; +import plugin.lsttokens.testsupport.TokenRegistration; + +public abstract class AbstractSpellCastingTokenTestCase extends TestCase +{ + protected PCGenGraph primaryGraph; + protected PCGenGraph secondaryGraph; + protected LoadContext primaryContext; + protected LoadContext secondaryContext; + protected PCClass primaryProf; + protected PCClass secondaryProf; + + private static boolean classSetUpFired = false; + protected static CampaignSourceEntry testCampaign; + + @BeforeClass + public static final void classSetUp() throws URISyntaxException + { + testCampaign = + new CampaignSourceEntry(new Campaign(), new URI( + "file:/Test%20Case")); + classSetUpFired = true; + } + + @Override + @Before + public void setUp() throws PersistenceLayerException, URISyntaxException + { + if (!classSetUpFired) + { + classSetUp(); + } + // Yea, this causes warnings... + TokenRegistration.register(getToken()); + primaryGraph = new PCGenGraph(); + secondaryGraph = new PCGenGraph(); + primaryContext = new LoadContext(primaryGraph); + secondaryContext = new LoadContext(secondaryGraph); + primaryProf = + primaryContext.ref.constructCDOMObject(getCDOMClass(), + "TestObj"); + secondaryProf = + secondaryContext.ref.constructCDOMObject(getCDOMClass(), + "TestObj"); + } + + public Class<? extends PCClass> getCDOMClass() + { + return PCClass.class; + } + + public static void addToken(LstToken tok) + { + TokenStore.inst().addToTokenMap(tok); + } + + public void runRoundRobin(String... str) throws PersistenceLayerException + { + // Default is not to write out anything + assertNull(getToken().unparse(primaryContext, primaryProf, 1)); + assertNull(getToken().unparse(primaryContext, primaryProf, 2)); + assertNull(getToken().unparse(primaryContext, primaryProf, 2)); + // Ensure the graphs are the same at the start + assertEquals(primaryGraph, secondaryGraph); + + // Set value + for (String s : str) + { + assertTrue(getToken().parse(primaryContext, primaryProf, s, 2)); + } + // Doesn't pollute other levels + assertNull(getToken().unparse(primaryContext, primaryProf, 1)); + // Get back the appropriate token: + String[] unparsed = getToken().unparse(primaryContext, primaryProf, 2); + + assertEquals(str.length, unparsed.length); + + for (int i = 0; i < str.length; i++) + { + assertEquals("Expected " + i + " item to be equal", str[i], + unparsed[i]); + } + + // And works for subsequent levels + unparsed = getToken().unparse(primaryContext, primaryProf, 3); + + assertEquals(str.length, unparsed.length); + + for (int i = 0; i < str.length; i++) + { + assertEquals("Expected SL " + i + " item to be equal", str[i], + unparsed[i]); + } + + // Do round Robin + StringBuilder unparsedBuilt = new StringBuilder(); + for (String s : unparsed) + { + unparsedBuilt.append(getToken().getTokenName()).append(':').append( + s).append('\t'); + } + PCClassLevelLoader.parseLine(secondaryContext, secondaryProf, + unparsedBuilt.toString(), testCampaign, 2); + + // Ensure the objects are the same + assertEquals(primaryProf, secondaryProf); + + // Ensure the graphs are the same + assertEquals(primaryGraph, secondaryGraph); + + // And that it comes back out the same again + // Doesn't pollute other levels + assertNull(getToken().unparse(secondaryContext, secondaryProf, 1)); + String[] sUnparsed = + getToken().unparse(secondaryContext, secondaryProf, 2); + assertEquals(unparsed.length, sUnparsed.length); + + for (int i = 0; i < unparsed.length; i++) + { + assertEquals("Expected " + i + " item to be equal", unparsed[i], + sUnparsed[i]); + } + } + + public abstract PCClassLevelLstToken getToken(); + + @Test + public void testInvalidListEmpty() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "", 2)); + } + + @Test + public void testInvalidListEnd() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "1,", 2)); + } + + @Test + public void testInvalidListStart() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, ",1", 2)); + } + + @Test + public void testInvalidListDoubleJoin() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "1,,2", 2)); + } + + @Test + public void testInvalidListNegativeNumber() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "1,-2", 2)); + } + + @Test + public void testRoundRobinSimple() throws PersistenceLayerException + { + runRoundRobin("3"); + } + + @Test + public void testRoundRobinList() throws PersistenceLayerException + { + runRoundRobin("3,2,1"); + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AttackCycleTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AttackCycleTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AttackCycleTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class AttackCycleTokenTest extends AbstractTokenTestCase<PCClass> +{ + + static AttackcycleToken token = new AttackcycleToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Test + public void testInvalidInputEmpty() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "")); + } + + @Test + public void testInvalidInputNoCycle() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "BAB")); + } + + @Test + public void testInvalidInputEmptyCycle() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "BAB|")); + } + + @Test + public void testInvalidInputEmptyType() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "|4")); + } + + @Test + public void testInvalidInputOpenStart() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "|BAB|3")); + } + + @Test + public void testInvalidInputOpenEnd() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "BAB|4|")); + } + + @Test + public void testInvalidInputDoublePipeTypeOne() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "BAB||5")); + } + + @Test + public void testInvalidInputDoublePipeTypeTwo() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "BAB|5||UAB|5")); + } + + @Test + public void testInvalidInputDoublePipeTypeThree() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "BAB|5|UAB||4")); + } + + @Test + public void testInvalidInputGAB() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "GAB|5")); + } + + @Test + public void testInvalidInputGABSecond() throws PersistenceLayerException + { + assertFalse(getToken() + .parse(primaryContext, primaryProf, "BAB|4|GAB|5")); + } + + @Test + public void testRoundRobinBab() throws PersistenceLayerException + { + runRoundRobin("BAB|3"); + } + + @Test + public void testRoundRobinRab() throws PersistenceLayerException + { + runRoundRobin("RAB|4"); + } + + @Test + public void testRoundRobinUab() throws PersistenceLayerException + { + runRoundRobin("UAB|5"); + } + + @Test + public void testRoundRobinMixed() throws PersistenceLayerException + { + runRoundRobin("BAB|3|RAB|4|UAB|5"); + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/CastTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/CastTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/CastTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,15 @@ +package plugin.lsttokens.pcclass; + +import pcgen.persistence.lst.PCClassLevelLstToken; + +public class CastTokenTest extends AbstractSpellCastingTokenTestCase +{ + static CastToken token = new CastToken(); + + @Override + public PCClassLevelLstToken getToken() + { + return token; + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/DomainTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/DomainTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/DomainTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.Domain; +import pcgen.core.PCClass; +import pcgen.core.PObject; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractListTokenTestCase; + +public class DomainTokenTest extends AbstractListTokenTestCase<PObject, Domain> +{ + + static DomainToken token = new DomainToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader getLoader() + { + return loader; + } + + @Override + public CDOMToken<PObject> getToken() + { + return token; + } + + @Override + public Class<Domain> getTargetClass() + { + return Domain.class; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Override + public char getJoinCharacter() + { + return '|'; + } + + @Test + public void dummyTest() + { + // Just to get Eclipse to recognize this as a JUnit 4.0 Test Case + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExClassTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExClassTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExClassTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.core.PObject; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class ExClassTokenTest extends AbstractTokenTestCase<PObject> +{ + + static DomainToken token = new DomainToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader getLoader() + { + return loader; + } + + @Override + public CDOMToken<PObject> getToken() + { + return token; + } + + @Test + public void testRoundRobinBase() throws PersistenceLayerException + { + runRoundRobin("Rheinhessen"); + } + + @Test + public void testRoundRobinWithSpace() throws PersistenceLayerException + { + runRoundRobin("Finger Lakes"); + } + + @Test + public void testRoundRobinNonEnglishAndN() throws PersistenceLayerException + { + runRoundRobin("Nieder\xF6sterreich"); + } + + @Test + public void testRoundRobinHyphen() throws PersistenceLayerException + { + runRoundRobin("Languedoc-Roussillon"); + } + + @Test + public void testRoundRobinY() throws PersistenceLayerException + { + runRoundRobin("Yarra Valley"); + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExchangeLevelTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExchangeLevelTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExchangeLevelTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,229 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractTokenTestCase; + +public class ExchangeLevelTokenTest extends AbstractTokenTestCase<PCClass> +{ + + static ExchangelevelToken token = new ExchangelevelToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + public Class<PCClass> getTargetClass() + { + return PCClass.class; + } + + @Test + public void testInvalidInputEmpty() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "")); + } + + @Test + public void testInvalidInputNoLevels() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, "Paladin")); + } + + @Test + public void testInvalidInputEmptyMin() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin||5|3")); + } + + @Test + public void testInvalidInputEmptyMax() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|5||3")); + } + + @Test + public void testInvalidInputEmptyRem() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|6|5|")); + } + + @Test + public void testInvalidInputNotEnoughPipes() + throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken() + .parse(primaryContext, primaryProf, "Paladin|6|5")); + } + + @Test + public void testInvalidInputTooManyPipes() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|6|5|4|3")); + } + + @Test + public void testInvalidInputEmptyClass() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, "|4|3|2")); + } + + @Test + public void testInvalidInputOpenStart() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "|Paladin|6|5|4")); + } + + @Test + public void testInvalidInputOpenEnd() throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|6|5|4|")); + } + + @Test + public void testInvalidInputDoublePipeTypeOne() + throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin||6|5|4")); + } + + @Test + public void testInvalidInputDoublePipeTypeTwo() + throws PersistenceLayerException + { + primaryContext.ref.constructCDOMObject(getTargetClass(), "Paladin"); + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|6||5|4")); + } + + @Test + public void testInvalidInputDoublePipeTypeThree() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|6|5||4")); + } + + @Test + public void testInvalidInputRemTooLow() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|5|2|1")); + } + + @Test + public void testInvalidInputNegativeMax() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|-5|2|1")); + } + + @Test + public void testInvalidInputZeroMax() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|0|2|1")); + } + + @Test + public void testInvalidInputNegativeDonate() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|5|-2|1")); + } + + @Test + public void testInvalidInputZeroDonate() throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|5|0|1")); + } + + @Test + public void testInvalidInputNegativeRemaining() + throws PersistenceLayerException + { + assertFalse(getToken().parse(primaryContext, primaryProf, + "Paladin|4|5|-1")); + } + + @Test + public void testRoundRobinSimple() throws PersistenceLayerException + { + runRoundRobin("Paladin|11|10|1"); + } + + @Test + public void testRoundRobinZeroRem() throws PersistenceLayerException + { + runRoundRobin("Paladin|10|10|0"); + } + + @Test + public void testRoundRobinHighMax() throws PersistenceLayerException + { + runRoundRobin("Paladin|5|10|1"); + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/HDTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/HDTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/HDTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.cdom.enumeration.IntegerKey; +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractIntegerTokenTestCase; + +public class HDTokenTest extends + AbstractIntegerTokenTestCase<PCClass> +{ + + static HdToken token = new HdToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Override + public IntegerKey getIntegerKey() + { + return IntegerKey.HIT_DIE; + } + + @Override + public boolean isNegativeAllowed() + { + return false; + } + + @Override + public boolean isZeroAllowed() + { + return false; + } + + @Override + public boolean isPositiveAllowed() + { + return true; + } + + @Test + public void dummyTest() + { + // Just to get Eclipse to recognize this as a JUnit 4.0 Test Case + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownSpellsFromSpecialtyTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownSpellsFromSpecialtyTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownSpellsFromSpecialtyTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens.pcclass; + +import java.net.URISyntaxException; + +import org.junit.Test; + +import pcgen.cdom.enumeration.IntegerKey; +import pcgen.core.PCClass; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.CDOMToken; +import pcgen.persistence.lst.LstLoader; +import plugin.lsttokens.testsupport.AbstractIntegerTokenTestCase; + +public class KnownSpellsFromSpecialtyTokenTest extends + AbstractIntegerTokenTestCase<PCClass> +{ + + static KnownspellsfromspecialtyToken token = + new KnownspellsfromspecialtyToken(); + static PCClassLoaderFacade loader = new PCClassLoaderFacade(); + + @Override + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + prefix = "CLASS:"; + } + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public LstLoader<PCClass> getLoader() + { + return loader; + } + + @Override + public CDOMToken<PCClass> getToken() + { + return token; + } + + @Override + public IntegerKey getIntegerKey() + { + return IntegerKey.KNOWN_SPELLS_FROM_SPECIALTY; + } + + @Override + public boolean isNegativeAllowed() + { + return false; + } + + @Override + public boolean isZeroAllowed() + { + return false; + } + + @Override + public boolean isPositiveAllowed() + { + return true; + } + + @Test + public void dummyTest() + { + // Just to get Eclipse to recognize this as a JUnit 4.0 Test Case + } +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,15 @@ +package plugin.lsttokens.pcclass; + +import pcgen.persistence.lst.PCClassLevelLstToken; + +public class KnownTokenTest extends AbstractSpellCastingTokenTestCase +{ + static KnownToken token = new KnownToken(); + + @Override + public PCClassLevelLstToken getToken() + { + return token; + } + +} Added: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpecialtyKnownTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpecialtyKnownTokenTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpecialtyKnownTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -0,0 +1,15 @@ +package plugin.lsttokens.pcclass; + +import pcgen.persistence.lst.PCClassLevelLstToken; + +public class SpecialtyKnownTokenTest extends AbstractSpellCastingTokenTestCase +{ + static SpecialtyknownToken token = new SpecialtyknownToken(); + + @Override + public PCClassLevelLstToken getToken() + { + return token; + } + +} Modified: branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -24,13 +24,17 @@ @RunWith(Suite.class) @Suite.SuiteClasses({AbbTokenTest.class, AddDomainsTokenTest.class, - BonusSpellStatTokenTest.class, CRFormulaTokenTest.class, - DeityTokenTest.class, FeatAutoTokenTest.class, IsMonsterTokenTest.class, - ItemCreateTokenTest.class, LangbonusTokenTest.class, - LevelsPerFeatTokenTest.class, MaxLevelTokenTest.class, - MemorizeTokenTest.class, ModToSkillsTokenTest.class, - MonNonSkillTHDTokenTest.class, MonSkillTokenTest.class, - SkillListTokenTest.class, SpellBookTokenTest.class, + AttackCycleTokenTest.class, BonusSpellStatTokenTest.class, + CastTokenTest.class, CRFormulaTokenTest.class, DeityTokenTest.class, + DomainTokenTest.class, ExchangeLevelTokenTest.class, + ExClassTokenTest.class, FeatAutoTokenTest.class, HDTokenTest.class, + IsMonsterTokenTest.class, ItemCreateTokenTest.class, + KnownSpellsFromSpecialtyTokenTest.class, KnownTokenTest.class, + LangbonusTokenTest.class, LevelsPerFeatTokenTest.class, + MaxLevelTokenTest.class, MemorizeTokenTest.class, + ModToSkillsTokenTest.class, MonNonSkillTHDTokenTest.class, + MonSkillTokenTest.class, SkillListTokenTest.class, + SpecialtyKnownTokenTest.class, SpellBookTokenTest.class, SpellListTokenTest.class, SpellStatTokenTest.class, SpellTypeTokenTest.class, StartSkillPtsTokenTest.class, TemplateTokenTest.class, VFeatTokenTest.class, VisibleTokenTest.class, Modified: branches/cdom/code/src/utest/plugin/lsttokens/skill/ClassesTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/skill/ClassesTokenTest.java 2007-04-11 21:43:45 UTC (rev 2722) +++ branches/cdom/code/src/utest/plugin/lsttokens/skill/ClassesTokenTest.java 2007-04-12 00:08:35 UTC (rev 2723) @@ -23,8 +23,8 @@ import org.junit.BeforeClass; import org.junit.Test; -import pcgen.core.PCClass; import pcgen.core.Skill; +import pcgen.core.SkillList; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.CDOMToken; import pcgen.persistence.lst.LstObjectFileLoader; @@ -135,7 +135,7 @@ public void testInvalidInputNotClassCompound() throws PersistenceLayerException { - primaryContext.ref.constructCDOMObject(PCClass.class, "Wizard"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Wizard"); assertTrue(getToken().parse(primaryContext, primaryProf, "Wizard|Sorcerer")); assertFalse(primaryContext.ref.validate()); @@ -144,7 +144,7 @@ // @Test(expected = IllegalArgumentException.class) public void testInvalidInputAllPlus() throws PersistenceLayerException { - primaryContext.ref.constructCDOMObject(PCClass.class, "Wizard"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Wizard"); try { assertFalse(getToken().parse(primaryContext, primaryProf, @@ -161,7 +161,7 @@ public void testInvalidInputNegativeAllPlus() throws PersistenceLayerException { - primaryContext.ref.constructCDOMObject(PCClass.class, "Wizard"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Wizard"); try { assertFalse(getToken().parse(primaryContext, primaryProf, @@ -194,7 +194,7 @@ public void testRoundRobinSimple() throws PersistenceLayerException { assertEquals(0, primaryContext.getWriteMessageCount()); - primaryContext.ref.constructCDOMObject(PCClass.class, "Wizard"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Wizard"); runRoundRobin("Wizard"); assertTrue(primaryContext.ref.validate()); assertEquals(0, primaryContext.getWriteMessageCount()); @@ -204,7 +204,7 @@ public void testRoundRobinNegated() throws PersistenceLayerException { assertEquals(0, primaryContext.getWriteMessageCount()); - primaryContext.ref.constructCDOMObject(PCClass.class, "Wizard"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Wizard"); runRoundRobin("!Wizard"); assertTrue(primaryContext.ref.validate()); assertEquals(0, primaryContext.getWriteMessageCount()); @@ -214,8 +214,8 @@ public void testRoundRobinPipe() throws PersistenceLayerException { assertEquals(0, primaryContext.getWriteMessageCount()); - primaryContext.ref.constructCDOMObject(PCClass.class, "Wizard"); - primaryContext.ref.constructCDOMObject(PCClass.class, "Sorcerer"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Wizard"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Sorcerer"); runRoundRobin("Sorcerer|Wizard"); assertTrue(primaryContext.ref.validate()); assertEquals(0, primaryContext.getWriteMessageCount()); @@ -225,10 +225,15 @@ public void testRoundRobinNegatedPipe() throws PersistenceLayerException { assertEquals(0, primaryContext.getWriteMessageCount()); - primaryContext.ref.constructCDOMObject(PCClass.class, "Wizard"); - primaryContext.ref.constructCDOMObject(PCClass.class, "Sorcerer"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Wizard"); + primaryContext.ref.constructCDOMObject(getTargetClass(), "Sorcerer"); runRoundRobin("!Sorcerer|!Wizard"); assertTrue(primaryContext.ref.validate()); assertEquals(0, primaryContext.getWriteMessageCount()); } + + private Class<SkillList> getTargetClass() + { + return SkillList.class; + } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-04-22 17:12:04
|
Revision: 2768 http://svn.sourceforge.net/pcgen/?rev=2768&view=rev Author: thpr Date: 2007-04-22 10:12:04 -0700 (Sun, 22 Apr 2007) Log Message: ----------- CDOM: More Token Tests & Associated core changes Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java branches/cdom/code/src/java/pcgen/cdom/base/ConcretePrereqObject.java branches/cdom/code/src/java/pcgen/cdom/base/FormulaFactory.java branches/cdom/code/src/java/pcgen/cdom/enumeration/AbilityCategory.java branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java branches/cdom/code/src/java/pcgen/cdom/enumeration/MapKey.java branches/cdom/code/src/java/pcgen/cdom/enumeration/Type.java branches/cdom/code/src/java/pcgen/cdom/graph/AbstractPCGraphEdge.java branches/cdom/code/src/java/pcgen/cdom/graph/PCGraphGrantsEdge.java branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java branches/cdom/code/src/java/pcgen/cdom/inst/PCClassLevel.java branches/cdom/code/src/java/pcgen/core/Description.java branches/cdom/code/src/java/pcgen/core/SpellProhibitor.java branches/cdom/code/src/java/pcgen/core/prereq/Prerequisite.java branches/cdom/code/src/java/pcgen/persistence/CategorizedReferenceContext.java branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java branches/cdom/code/src/java/pcgen/persistence/SimpleReferenceContext.java branches/cdom/code/src/java/pcgen/util/StringPClassUtil.java branches/cdom/code/src/java/pcgen/util/enumeration/ProhibitedSpellType.java branches/cdom/code/src/java/plugin/lsttokens/DefineLst.java branches/cdom/code/src/java/plugin/lsttokens/DescLst.java branches/cdom/code/src/java/plugin/lsttokens/QualifyToken.java branches/cdom/code/src/java/plugin/lsttokens/SaLst.java branches/cdom/code/src/java/plugin/lsttokens/SpelllevelLst.java branches/cdom/code/src/java/plugin/lsttokens/SpellsLst.java branches/cdom/code/src/java/plugin/lsttokens/ability/AddspelllevelToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/BenefitToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/CategoryToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/CostToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/MultToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/StackToken.java branches/cdom/code/src/java/plugin/lsttokens/ability/VisibleToken.java branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/EquipToken.java branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/SpropToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/AddprofToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/ArmortypeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipmentmodifier/SpropToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownspellsToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/ProhibitedToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/ProhibitspellToken.java branches/cdom/code/src/utest/plugin/lsttokens/SaLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/ability/TokenAbilityTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/auto/ArmorProfTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/auto/ShieldProfTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/auto/TokenAutoTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/auto/WeaponProfTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/domain/FeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/TokenEqModTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AbstractSpellCastingTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExClassTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/FeatAutoTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellTypeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VFeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/FeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/RaceTypeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/FeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/RaceTypeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/RegionTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/SubraceTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/SubregionTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractFormulaTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractGlobalFormulaTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractTextPropertyTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractTypeSafeTokenTestCase.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/cdom/content/KnownSpellIdentifier.java branches/cdom/code/src/java/pcgen/cdom/enumeration/EquipmentNature.java branches/cdom/code/src/java/pcgen/cdom/enumeration/VariableKey.java branches/cdom/code/src/java/pcgen/cdom/modifier/ChangeArmorType.java branches/cdom/code/src/java/pcgen/persistence/ReferenceManufacturer.java branches/cdom/code/src/utest/plugin/lsttokens/DefineLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/DescLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/QualifyTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/SpellLevelLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/SpellsLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/AddspelllevelTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/BenefitTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/CategoryTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/CostTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/MultTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/StackTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/VisibleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/auto/AbstractAutoTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/auto/EquipTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/ArmortypeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AbstractPCClassLevelTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/HitDieTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownspellsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ProhibitedTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ProhibitspellTokenTest.java Removed Paths: ------------- branches/cdom/code/src/utest/plugin/lsttokens/auto/AbstractProfTokenTestCase.java Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMObject.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -19,6 +19,7 @@ import java.util.ArrayList; import java.util.HashMap; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -30,6 +31,7 @@ import pcgen.cdom.enumeration.MapKey; import pcgen.cdom.enumeration.ObjectKey; import pcgen.cdom.enumeration.StringKey; +import pcgen.cdom.enumeration.VariableKey; import pcgen.cdom.util.ListKeyMapToList; import pcgen.cdom.util.MapKeyMapToList; import pcgen.core.SourceEntry; @@ -56,6 +58,10 @@ new HashMap<FormulaKey, Formula>(); /** A map to hold items keyed by Strings for the object */ + private final Map<VariableKey, Formula> variableChar = + new HashMap<VariableKey, Formula>(); + + /** A map to hold items keyed by Strings for the object */ private final Map<ObjectKey<?>, Object> objectChar = new HashMap<ObjectKey<?>, Object>(); @@ -137,6 +143,31 @@ return formulaChar.remove(arg0); } + public final boolean containsKey(VariableKey arg0) + { + return variableChar.containsKey(arg0); + } + + public final Formula get(VariableKey arg0) + { + return variableChar.get(arg0); + } + + public final Set<VariableKey> getVariableKeys() + { + return new HashSet<VariableKey>(variableChar.keySet()); + } + + public final Formula put(VariableKey arg0, Formula arg1) + { + return variableChar.put(arg0, arg1); + } + + public final Formula remove(VariableKey arg0) + { + return variableChar.remove(arg0); + } + public final boolean containsKey(ObjectKey<?> arg0) { return objectChar.containsKey(arg0); @@ -321,6 +352,10 @@ { return false; } + if (!variableChar.equals(cdo.variableChar)) + { + return false; + } if (!objectChar.equals(cdo.objectChar)) { return false; Modified: branches/cdom/code/src/java/pcgen/cdom/base/ConcretePrereqObject.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/ConcretePrereqObject.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/base/ConcretePrereqObject.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -514,4 +514,30 @@ return sourceRes == null ? null : Collections .unmodifiableList(sourceRes); } + + + public boolean equalsPrereqObject(PrereqObject other) + { + if (this == other) + { + return true; + } + boolean otherHas = other.hasPrerequisites(); + if (!hasPrerequisites()) + { + return !otherHas; + } + if (!otherHas) + { + return false; + } + List<Prerequisite> otherPRL = other.getPrerequisiteList(); + if (otherPRL.size() != thePrereqs.size()) + { + return false; + } + ArrayList<Prerequisite> removed = new ArrayList<Prerequisite>(thePrereqs); + removed.removeAll(otherPRL); + return removed.isEmpty(); + } } Modified: branches/cdom/code/src/java/pcgen/cdom/base/FormulaFactory.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/FormulaFactory.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/base/FormulaFactory.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -29,6 +29,10 @@ public static Formula getFormulaFor(String s) { + if (s.length() == 0) + { + throw new IllegalArgumentException("Formula cannot be empty"); + } return new JEPFormula(s); } Added: branches/cdom/code/src/java/pcgen/cdom/content/KnownSpellIdentifier.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/KnownSpellIdentifier.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/content/KnownSpellIdentifier.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -0,0 +1,92 @@ +/* + * SpellProhibitor.java + * Copyright 2005 (c) Tom Parker <th...@so...> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Created on November 3, 2006 + * + * Current Ver: $Revision: 1522 $ + * Last Editor: $Author: thpr $ + * Last Edited: $Date: 2006-10-24 18:40:09 -0400 (Tue, 24 Oct 2006) $ + * + */ +package pcgen.cdom.content; + +import pcgen.cdom.base.CDOMReference; +import pcgen.cdom.base.ConcretePrereqObject; +import pcgen.core.spell.Spell; + +public class KnownSpellIdentifier extends ConcretePrereqObject +{ + + private final CDOMReference<Spell> ref; + + private final Integer spellLevel; + + public KnownSpellIdentifier(CDOMReference<Spell> sr, Integer levelLimit) + { + if (sr == null) + { + throw new IllegalArgumentException("Spell Reference cannot be null"); + } + ref = sr; + spellLevel = levelLimit; + } + + public boolean matchesFilter(Spell s, int testSpellLevel) + { + // TODO Need to implement this method + return false; + } + + public CDOMReference<Spell> getLimit() + { + return ref; + } + + public Integer getSpellLevel() + { + return spellLevel; + } + + @Override + public int hashCode() + { + return spellLevel == null ? ref.hashCode() : spellLevel.intValue() + * ref.hashCode(); + } + + @Override + public boolean equals(Object o) + { + if (o == this) + { + return true; + } + if (!(o instanceof KnownSpellIdentifier)) + { + return false; + } + KnownSpellIdentifier other = (KnownSpellIdentifier) o; + if (spellLevel == null) + { + return other.spellLevel == null && ref.equals(other.ref); + } + return ((spellLevel == null && other.spellLevel == null) || spellLevel + .equals(other.spellLevel)) + && ref.equals(other.ref); + } +} Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/AbilityCategory.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/AbilityCategory.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/AbilityCategory.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -1,42 +1,177 @@ /* - * Copyright 2007 (C) Tom Parker <th...@us...> + * Copyright (c) 2006 Tom Parker <th...@us...> * - * This library is free software; you can redistribute it and/or modify it under + * This program is free software; you can redistribute it and/or modify it under * the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 2.1 of the License, or (at your option) * any later version. * - * This library is distributed in the hope that it will be useful, but WITHOUT + * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * * You should have received a copy of the GNU Lesser General Public License * along with this library; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ package pcgen.cdom.enumeration; +import java.util.Collection; +import java.util.Collections; + +import pcgen.base.enumeration.TypeSafeConstant; +import pcgen.base.util.CaseInsensitiveMap; import pcgen.cdom.base.Category; import pcgen.core.Ability; -public enum AbilityCategory implements Category<Ability> { +/** + * @author Tom Parker (thpr [at] yahoo.com) + * + * This Class is a Type Safe Constant. + */ +public final class AbilityCategory implements TypeSafeConstant, Category<Ability> +{ - FEAT, - Mutation, - Salient_Divine_Ability; + public static AbilityCategory FEAT = getConstant("FEAT"); + public static AbilityCategory Mutation = getConstant("Mutation"); + public static AbilityCategory Salient_Divine_Ability = + getConstant("Salient_Divine_Ability"); - public static AbilityCategory getAblilityCategory(String s) { - AbilityCategory ac; - try { - ac = valueOf(s); - } catch (IllegalArgumentException iae) { - try { - ac = valueOf(s.replace(' ', '_')); - } catch (IllegalArgumentException ex) { - throw iae; + /** + * This Map contains the mappings from Strings to the Type Safe Constant + */ + private static CaseInsensitiveMap<AbilityCategory> typeMap; + + /** + * This is used to provide a unique ordinal to each constant in this class + */ + private static int ordinalCount = 0; + + /** + * The name of this Constant + */ + private final String fieldName; + + /** + * The ordinal of this Constant + */ + private final transient int ordinal; + + private AbilityCategory(String name) + { + ordinal = ordinalCount++; + fieldName = name; + } + + /** + * Converts this Constant to a String (returns the name of this Constant) + * + * @return The string representatin (name) of this Constant + */ + @Override + public String toString() + { + return fieldName; + } + + /** + * Gets the ordinal of this Constant + */ + public int getOrdinal() + { + return ordinal; + } + + /** + * Returns the constant for the given String (the search for the constant is + * case insensitive). If the constant does not already exist, a new Constant + * is created with the given String as the name of the Constant. + * + * @param s + * The name of the constant to be returned + * @return The Constant for the given name + */ + public static AbilityCategory getConstant(String s) + { + if (typeMap == null) + { + typeMap = new CaseInsensitiveMap<AbilityCategory>(); + } + AbilityCategory o = typeMap.get(s); + if (o == null) + { + /* + * TODO FIXME Should .,| or other stuff be banned here? (probably) + */ + if (s.length() == 0) + { + throw new IllegalArgumentException( + "Type Name cannot be zero length"); } + o = new AbilityCategory(s); + typeMap.put(s, o); } - return ac; + return o; } + + /** + * Returns the constant for the given String (the search for the constant is + * case insensitive). If the constant does not already exist, an + * IllegalArgumentException is thrown. + * + * @param s + * The name of the constant to be returned + * @return The Constant for the given name + */ + public static AbilityCategory valueOf(String s) + { + if (typeMap == null) + { + typeMap = new CaseInsensitiveMap<AbilityCategory>(); + } + AbilityCategory o = typeMap.get(s); + if (o == null) + { + throw new IllegalArgumentException(s); + } + return o; + } + + /** + * Returns a Collection of all of the Constants in this Class. + * + * This collection maintains a reference to the Constants in this Class, so + * if a new Constant is created, the Collection returned by this method will + * be modified. (Beware of ConcurrentModificationExceptions) + * + * @return a Collection of all of the Constants in this Class. + */ + public static Collection<AbilityCategory> getAllConstants() + { + if (typeMap == null) + { + return null; + } + return Collections.unmodifiableCollection(typeMap.values()); + } + + /** + * Clears all of the Constants in this Class (forgetting the mapping from + * the String to the Constant). + */ + /* + * CONSIDER Need to consider the ramifications of this on TypeSafeMap, since + * this does not (and really cannot) reset the ordinal count... Does this + * method need to be renamed, such that it is clearConstantMap? - Tom + * Parker, Feb 28, 2007 + */ + public static void clearConstants() + { + if (typeMap != null) + { + typeMap.clear(); + } + } + } Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -60,6 +60,12 @@ public static final AssociationKey<AbilityCategory> ABILITY_CATEGORY = new AssociationKey<AbilityCategory>(); + public static final AssociationKey<EquipmentNature> EQUIPMENT_NATURE = new AssociationKey<EquipmentNature>(); + + public static final AssociationKey<Integer> QUANTITY = new AssociationKey<Integer>(); + + public static final AssociationKey<String> TYPE = new AssociationKey<String>(); + private static CaseInsensitiveMap<AssociationKey<?>> map = null; private AssociationKey() { Added: branches/cdom/code/src/java/pcgen/cdom/enumeration/EquipmentNature.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/EquipmentNature.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/EquipmentNature.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -0,0 +1,27 @@ +/* + * Copyright 2007 (C) Tom Parker <th...@us...> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +package pcgen.cdom.enumeration; + +public enum EquipmentNature +{ + /** Equipment is Normal */ + NORMAL, + /** Equipment is Automatic */ + AUTOMATIC; + +} Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/MapKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/MapKey.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/MapKey.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -29,6 +29,8 @@ import java.util.Map; import pcgen.base.util.CaseInsensitiveMap; +import pcgen.cdom.base.CDOMReference; +import pcgen.core.PObject; /** * @author Tom Parker <th...@so...> @@ -41,8 +43,8 @@ public static final MapKey<String, String> QUALITY = new MapKey<String, String>(); - public static final MapKey<Class, Object> QUALIFY = - new MapKey<Class, Object>(); + public static final MapKey<Class<? extends PObject>, CDOMReference<?>> QUALIFY = + new MapKey<Class<? extends PObject>, CDOMReference<?>>(); public static final MapKey<AttackType, Integer> ATTACK_CYCLE = new MapKey<AttackType, Integer>(); Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/Type.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/Type.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/Type.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -94,6 +94,13 @@ Type o = typeMap.get(s); if (o == null) { + /* + * TODO FIXME Should .,| or other stuff be banned here? (probably) + */ + if (s.length() == 0) + { + throw new IllegalArgumentException("Type Name cannot be zero length"); + } o = new Type(s); typeMap.put(s, o); } Added: branches/cdom/code/src/java/pcgen/cdom/enumeration/VariableKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/VariableKey.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/VariableKey.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2006 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package pcgen.cdom.enumeration; + +import java.util.Collection; +import java.util.Collections; + +import pcgen.base.enumeration.TypeSafeConstant; +import pcgen.base.util.CaseInsensitiveMap; + +/** + * @author Tom Parker (thpr [at] yahoo.com) + * + * This Class is a Type Safe Constant. + */ +public final class VariableKey implements TypeSafeConstant +{ + + /** + * This Map contains the mappings from Strings to the Type Safe Constant + */ + private static CaseInsensitiveMap<VariableKey> typeMap; + + /** + * This is used to provide a unique ordinal to each constant in this class + */ + private static int ordinalCount = 0; + + /** + * The name of this Constant + */ + private final String fieldName; + + /** + * The ordinal of this Constant + */ + private final transient int ordinal; + + private VariableKey(String name) + { + ordinal = ordinalCount++; + fieldName = name; + } + + /** + * Converts this Constant to a String (returns the name of this Constant) + * + * @return The string representatin (name) of this Constant + */ + @Override + public String toString() + { + return fieldName; + } + + /** + * Gets the ordinal of this Constant + */ + public int getOrdinal() + { + return ordinal; + } + + /** + * Returns the constant for the given String (the search for the constant is + * case insensitive). If the constant does not already exist, a new Constant + * is created with the given String as the name of the Constant. + * + * @param s + * The name of the constant to be returned + * @return The Constant for the given name + */ + public static VariableKey getConstant(String s) + { + if (typeMap == null) + { + typeMap = new CaseInsensitiveMap<VariableKey>(); + } + VariableKey o = typeMap.get(s); + if (o == null) + { + o = new VariableKey(s); + typeMap.put(s, o); + } + return o; + } + + /** + * Returns the constant for the given String (the search for the constant is + * case insensitive). If the constant does not already exist, an + * IllegalArgumentException is thrown. + * + * @param s + * The name of the constant to be returned + * @return The Constant for the given name + */ + public static VariableKey valueOf(String s) + { + if (typeMap == null) + { + typeMap = new CaseInsensitiveMap<VariableKey>(); + } + VariableKey o = typeMap.get(s); + if (o == null) + { + throw new IllegalArgumentException(s); + } + return o; + } + + /** + * Returns a Collection of all of the Constants in this Class. + * + * This collection maintains a reference to the Constants in this Class, so + * if a new Constant is created, the Collection returned by this method will + * be modified. (Beware of ConcurrentModificationExceptions) + * + * @return a Collection of all of the Constants in this Class. + */ + public static Collection<VariableKey> getAllConstants() + { + if (typeMap == null) + { + return null; + } + return Collections.unmodifiableCollection(typeMap.values()); + } + + /** + * Clears all of the Constants in this Class (forgetting the mapping from + * the String to the Constant). + */ + /* + * CONSIDER Need to consider the ramifications of this on TypeSafeMap, since + * this does not (and really cannot) reset the ordinal count... Does this + * method need to be renamed, such that it is clearConstantMap? - Tom + * Parker, Feb 28, 2007 + */ + public static void clearConstants() + { + if (typeMap != null) + { + typeMap.clear(); + } + } + +} Modified: branches/cdom/code/src/java/pcgen/cdom/graph/AbstractPCGraphEdge.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/graph/AbstractPCGraphEdge.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/graph/AbstractPCGraphEdge.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -206,7 +206,15 @@ return this == other || firstNode.equals(other.firstNode) && secondNode.equals(other.secondNode) + && equalsPrereqObject(other) && ((associationMap == null && other.associationMap == null) || (associationMap != null && associationMap .equals(other.associationMap))); } + + @Override + public String toString() + { + return firstNode.toString() + "->" + secondNode.toString() + " " + + associationMap + " " + getPreReqList(); + } } Modified: branches/cdom/code/src/java/pcgen/cdom/graph/PCGraphGrantsEdge.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/graph/PCGraphGrantsEdge.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/graph/PCGraphGrantsEdge.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -71,4 +71,10 @@ return source.equals(other.source) && super.equalsAbstractPCGraphEdge(other); } + + @Override + public String toString() + { + return getClass().getSimpleName() + ": " + super.toString(); + } } Modified: branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/inst/Aggregator.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -57,6 +57,6 @@ return other.aggSourceToken.equals(aggSourceToken) && other.aggregatorOwner.equals(aggregatorOwner) && other.aggregatorSource.equals(aggregatorSource) - && this.isCDOMEqual(other); + && isCDOMEqual(other) && equalsPrereqObject(other); } } Modified: branches/cdom/code/src/java/pcgen/cdom/inst/PCClassLevel.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/inst/PCClassLevel.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/cdom/inst/PCClassLevel.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -17,9 +17,9 @@ */ package pcgen.cdom.inst; -import pcgen.core.PCClass; +import pcgen.core.PObject; -public final class PCClassLevel extends PCClass +public final class PCClassLevel extends PObject { private final Object classSource; Added: branches/cdom/code/src/java/pcgen/cdom/modifier/ChangeArmorType.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/modifier/ChangeArmorType.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/modifier/ChangeArmorType.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -0,0 +1,86 @@ +/* + * Copyright 2007 (C) Tom Parker <th...@us...> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +package pcgen.cdom.modifier; + +import pcgen.cdom.base.ConcretePrereqObject; +import pcgen.cdom.enumeration.Type; + +public class ChangeArmorType extends ConcretePrereqObject implements + Modifier<Type> +{ + + private final Type source; + private final Type result; + + public ChangeArmorType(Type sourceType, Type resultType) + { + if (sourceType == null) + { + throw new IllegalArgumentException( + "Source Type for ChangeArmorType cannot be null"); + } + if (resultType == null) + { + throw new IllegalArgumentException( + "Resulting Type for ChangeArmorType cannot be null"); + } + result = resultType; + source = sourceType; + } + + public Type applyModifier(Type obj) + { + return source.equals(obj) ? result : obj; + } + + public Class<Type> getModifiedClass() + { + return Type.class; + } + + public Type getSourceType() + { + return source; + } + + public Type getResultType() + { + return result; + } + + @Override + public int hashCode() + { + return 31 * source.hashCode() + result.hashCode(); + } + + @Override + public boolean equals(Object o) + { + if (o == this) + { + return true; + } + if (!(o instanceof ChangeArmorType)) + { + return false; + } + ChangeArmorType other = (ChangeArmorType) o; + return source.equals(other.source) && result.equals(other.result); + } +} Modified: branches/cdom/code/src/java/pcgen/core/Description.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/Description.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/core/Description.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -31,14 +31,16 @@ /** * This class represents a generic description field. * - * <p>The class supports the description object having one or more prerequisites - * as well as performing variable substitution on the string itself. + * <p> + * The class supports the description object having one or more prerequisites as + * well as performing variable substitution on the string itself. * - * <p>Variable substitution is performed by replacing a placeholder indicated - * by %# with the #th variable in the variable list. For example, the string - * <br /><code>"This is %1 variable %3 %2"</code> - * <br />would be replaced with the string "This is a variable substitution - * string" if the variable list was "a","string", + * <p> + * Variable substitution is performed by replacing a placeholder indicated by %# + * with the #th variable in the variable list. For example, the string <br /> + * <code>"This is %1 variable %3 %2"</code> <br /> + * would be replaced with the string "This is a variable substitution + * string" if the variable list was "a","string", * "substitution". * * @author boomer70 <boo...@ya...> @@ -50,52 +52,56 @@ private List<String> theComponents = new ArrayList<String>(); private List<String> theVariables = null; private PObject theOwner = null; - + private static final String VAR_NAME = "%NAME"; //$NON-NLS-1$ private static final String VAR_CHOICE = "%CHOICE"; //$NON-NLS-1$ private static final String VAR_LIST = "%LIST"; //$NON-NLS-1$ - + private static final String VAR_MARKER = "$$VAR:"; //$NON-NLS-1$ - + /** * Default constructor. * - * @param aString The description string. + * @param aString + * The description string. */ - public Description( final String aString ) + public Description(final String aString) { int currentInd = 0; int percentInd = -1; - while ( (percentInd = aString.indexOf('%', currentInd)) != -1 ) + while ((percentInd = aString.indexOf('%', currentInd)) != -1) { final String preText = aString.substring(currentInd, percentInd); - if ( preText.length() > 0 ) + if (preText.length() > 0) { theComponents.add(preText); } - if ( percentInd == aString.length() - 1) + if (percentInd == aString.length() - 1) { theComponents.add("%"); //$NON-NLS-1$ return; } - if ( aString.charAt(percentInd + 1) == '{' ) + if (aString.charAt(percentInd + 1) == '{') { - // This is a bracketed placeholder. The replacement parameter + // This is a bracketed placeholder. The replacement parameter // is contained within the {} currentInd = aString.indexOf('}', percentInd + 1) + 1; - final String replacement = aString.substring(percentInd + 1, currentInd); + final String replacement = + aString.substring(percentInd + 1, currentInd); // For the time being we will only support numerics here. try { Integer.parseInt(replacement); } - catch (NumberFormatException nfe ) + catch (NumberFormatException nfe) { - Logging.errorPrintLocalised("Errors.Description.InvalidVariableReplacement", replacement); //$NON-NLS-1$ + Logging + .errorPrintLocalised( + "Errors.Description.InvalidVariableReplacement", replacement); //$NON-NLS-1$ } theComponents.add(VAR_MARKER + replacement); } - else if ( aString.charAt(percentInd + 1) == '%' ) + else if (aString.charAt(percentInd + 1) == '%') { // This is an escape sequence so we can actually print a % currentInd = percentInd + 2; @@ -103,10 +109,10 @@ } else { - // In this case we have an unbracketed placeholder. We will + // In this case we have an unbracketed placeholder. We will // walk the string until such time as we no longer have a number currentInd = percentInd + 1; - while ( currentInd < aString.length() ) + while (currentInd < aString.length()) { final char val = aString.charAt(currentInd); try @@ -119,46 +125,49 @@ break; } } - if ( currentInd > percentInd + 1 ) + if (currentInd > percentInd + 1) { - theComponents.add(VAR_MARKER + aString.substring(percentInd+1, currentInd)); + theComponents.add(VAR_MARKER + + aString.substring(percentInd + 1, currentInd)); } else { // We broke out of the variable finding loop without finding - // even a single integer. Assume we have a DESC field that + // even a single integer. Assume we have a DESC field that // is using a % unescaped. - theComponents.add(aString.substring(percentInd, percentInd+1)); + theComponents.add(aString.substring(percentInd, + percentInd + 1)); } } } theComponents.add(aString.substring(currentInd)); } - + /** * Adds a variable to use in variable substitution. * * @param aVariable */ - public void addVariable( final String aVariable ) + public void addVariable(final String aVariable) { - if ( theVariables == null ) + if (theVariables == null) { theVariables = new ArrayList<String>(); } - theVariables.add( aVariable ); + theVariables.add(aVariable); } - + /** * Sets the owner of this description. * - * @param anOwner The <tt>PObject</tt> this description is associated with. + * @param anOwner + * The <tt>PObject</tt> this description is associated with. */ - public void setOwner( final PObject anOwner ) + public void setOwner(final PObject anOwner) { theOwner = anOwner; } - + /** * Gets the owner of this description. * @@ -168,53 +177,58 @@ { return theOwner; } - + /** - * Gets the description string after having tested all prereqs and + * Gets the description string after having tested all prereqs and * substituting all variables. * - * @param aPC The PlayerCharacter used to evaluate formulas. + * @param aPC + * The PlayerCharacter used to evaluate formulas. * * @return The fully substituted description string. */ - public String getDescription( final PlayerCharacter aPC ) + public String getDescription(final PlayerCharacter aPC) { final StringBuffer buf = new StringBuffer(); - + if (this.qualifies(aPC)) { - for ( final String comp : theComponents ) + for (final String comp : theComponents) { - if ( comp.startsWith(VAR_MARKER) ) + if (comp.startsWith(VAR_MARKER)) { - final int ind = Integer.parseInt(comp.substring(VAR_MARKER.length())); - if ( theVariables == null || ind > theVariables.size() ) + final int ind = + Integer.parseInt(comp + .substring(VAR_MARKER.length())); + if (theVariables == null || ind > theVariables.size()) { buf.append(Constants.EMPTY_STRING); continue; } final String var = theVariables.get(ind - 1); - if ( var.equals(VAR_NAME) ) + if (var.equals(VAR_NAME)) { - if ( theOwner != null ) + if (theOwner != null) { buf.append(theOwner.getDisplayName()); } } - else if ( var.equals(VAR_CHOICE) ) + else if (var.equals(VAR_CHOICE)) { - if ( theOwner != null && theOwner.getAssociatedCount() > 0 ) + if (theOwner != null + && theOwner.getAssociatedCount() > 0) { buf.append(theOwner.getAssociated(0)); } } - else if ( var.equals(VAR_LIST) ) + else if (var.equals(VAR_LIST)) { - if ( theOwner != null ) + if (theOwner != null) { - for ( int i = 0; i < theOwner.getAssociatedCount(true); i++ ) + for (int i = 0; i < theOwner + .getAssociatedCount(true); i++) { - if ( i > 0 ) + if (i > 0) { buf.append(Constants.COMMA); } @@ -222,13 +236,14 @@ } } } - else if ( var.startsWith("\"") ) //$NON-NLS-1$ + else if (var.startsWith("\"")) //$NON-NLS-1$ { buf.append(var.substring(1, var.length() - 1)); } else { - buf.append(aPC.getVariableValue(var, "Description").intValue()); //$NON-NLS-1$ + buf.append(aPC + .getVariableValue(var, "Description").intValue()); //$NON-NLS-1$ } } else @@ -239,7 +254,7 @@ } return buf.toString(); } - + /** * Gets the Description tag in PCC format. * @@ -249,12 +264,13 @@ public String getPCCText() { final StringBuffer buf = new StringBuffer(); - - for ( final String str : theComponents ) + + for (final String str : theComponents) { - if ( str.startsWith(VAR_MARKER) ) + if (str.startsWith(VAR_MARKER)) { - final int ind = Integer.parseInt(str.substring(VAR_MARKER.length())); + final int ind = + Integer.parseInt(str.substring(VAR_MARKER.length())); buf.append('%' + String.valueOf(ind)); } else @@ -262,16 +278,47 @@ buf.append(str); } } - if ( theVariables != null ) + if (theVariables != null) { - for ( final String var : theVariables ) + for (final String var : theVariables) { buf.append(Constants.PIPE); buf.append(var); } } - + buf.append(super.getPCCText()); return buf.toString(); } + + @Override + public int hashCode() + { + return theComponents.size() + 7 * getPrerequisiteCount() + 31 + * (theVariables == null ? 0 : theVariables.size()); + } + + @Override + public boolean equals(Object o) + { + if (o == this) + { + return true; + } + if (!(o instanceof Description)) + { + return false; + } + Description other = (Description) o; + if (theVariables == null) + { + if (other.theVariables != null) + { + return false; + } + } + return theComponents.equals(other.theComponents) + && (theVariables == null || theVariables.equals(other.theVariables)) + && equalsPrereqObject(other); + } } Modified: branches/cdom/code/src/java/pcgen/core/SpellProhibitor.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/SpellProhibitor.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/core/SpellProhibitor.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -29,23 +29,24 @@ import pcgen.core.spell.Spell; import pcgen.util.enumeration.ProhibitedSpellType; -import java.util.ArrayList; -import java.util.List; +import java.util.Set; +import java.util.TreeSet; /** * @author stefan - * - * TODO To change the template for this generated type comment go to - * Window - Preferences - Java - Code Style - Code Templates + * + * TODO To change the template for this generated type comment go to Window - + * Preferences - Java - Code Style - Code Templates */ -public class SpellProhibitor extends ConcretePrereqObject { +public class SpellProhibitor extends ConcretePrereqObject +{ private ProhibitedSpellType type = null; - private List<String> valueList = null; + private Set<String> valueSet = null; public SpellProhibitor() { - //Empty Construtor + // Empty Construtor } public ProhibitedSpellType getType() @@ -53,25 +54,25 @@ return type; } - public List<String> getValueList() + public Set<String> getValueSet() { - return valueList; + return valueSet; } - public void setType(ProhibitedSpellType prohibitedType) + public void setType(ProhibitedSpellType prohibitedType) { type = prohibitedType; } public void addValue(String value) { - if (valueList == null) + if (valueSet == null) { - valueList = new ArrayList<String>(); + valueSet = new TreeSet<String>(); } - valueList.add(value); + valueSet.add(value); } - + public boolean isProhibited(Spell s, PlayerCharacter aPC) { /* @@ -80,21 +81,21 @@ * Alignment type */ if (type.equals(ProhibitedSpellType.ALIGNMENT) - && !Globals.checkRule(RuleConstants.PROHIBITSPELLS)) + && !Globals.checkRule(RuleConstants.PROHIBITSPELLS)) { return false; } - + if (!qualifies(aPC)) { return false; } - + int hits = 0; - + for (String typeDesc : type.getCheckList(s)) { - for (String prohib : valueList) + for (String prohib : valueSet) { if (prohib.equalsIgnoreCase(typeDesc)) { @@ -102,7 +103,34 @@ } } } - - return hits == type.getRequiredCount(valueList); + + return hits == type.getRequiredCount(valueSet); } + + @Override + public int hashCode() + { + return type.hashCode() ^ valueSet.size(); + } + + @Override + public boolean equals(Object o) + { + if (this == o) + { + return true; + } + if (!(o instanceof SpellProhibitor)) + { + return false; + } + SpellProhibitor other = (SpellProhibitor) o; + if ((type == null && other.type == null) + || (type != null && type.equals(other.type))) + { + return (other.valueSet == null && valueSet == null) + || valueSet != null && valueSet.equals(other.valueSet); + } + return false; + } } Modified: branches/cdom/code/src/java/pcgen/core/prereq/Prerequisite.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/prereq/Prerequisite.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/core/prereq/Prerequisite.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -29,7 +29,7 @@ /** * @author fr...@pu... - * + * */ public class Prerequisite implements Cloneable { @@ -43,17 +43,21 @@ private List<Prerequisite> prerequisites = new ArrayList<Prerequisite>(); private PrerequisiteOperator operator = PrerequisiteOperator.GTEQ; private String operand = "1"; //$NON-NLS-1$ - /** Indicates that the total of skill ranks, class levels etc should be - * added together when checking for a value. + /** + * Indicates that the total of skill ranks, class levels etc should be added + * together when checking for a value. */ private boolean totalValues; - /** Indicates that the number of qualifying objects should be tallied - * when checking for a value. + /** + * Indicates that the number of qualifying objects should be tallied when + * checking for a value. */ private boolean countMultiples; private boolean overrideQualify = false; - private int levelQualifier = -1; // used for classes only - classlevel at which this prereq is checked - private String categoryName; // used for abilities only - category to restrict matches to. + private int levelQualifier = -1; // used for classes only - classlevel at + // which this prereq is checked + private String categoryName; // used for abilities only - category to + // restrict matches to. public Prerequisite() { @@ -71,7 +75,7 @@ this.levelQualifier = that.levelQualifier; if (that.prerequisites != null) { - for ( Prerequisite otherReq : that.prerequisites ) + for (Prerequisite otherReq : that.prerequisites) { this.addPrerequisite(new Prerequisite(otherReq)); } @@ -85,13 +89,16 @@ { return totalValues; } + /** - * @param totalValues The totalValues to set. + * @param totalValues + * The totalValues to set. */ public final void setTotalValues(final boolean totalValues) { this.totalValues = totalValues; } + /** * @param countMultiples * The countMultiples to set. @@ -164,7 +171,8 @@ } /** - * @param operator The operator to set. + * @param operator + * The operator to set. */ public void setOperator(final PrerequisiteOperator operator) { @@ -213,7 +221,7 @@ /* * (non-Javadoc) - * + * * @see java.lang.Object#toString() */ @Override @@ -235,9 +243,10 @@ if (countMultiples) { - buf.append(PropertyFactory.getString("Prerequisite.count-multiples")); //$NON-NLS-1$ + buf.append(PropertyFactory + .getString("Prerequisite.count-multiples")); //$NON-NLS-1$ } - + if (totalValues) { buf.append(PropertyFactory.getString("Prerequisite.total-values")); //$NON-NLS-1$ @@ -282,14 +291,15 @@ if (isOverrideQualify()) { - buf.append(PropertyFactory.getString("Prerequisite.override-qualify")); //$NON-NLS-1$ + buf.append(PropertyFactory + .getString("Prerequisite.override-qualify")); //$NON-NLS-1$ } buf.append(">\n"); //$NON-NLS-1$ if (prerequisites.size() > 0) { - for ( Prerequisite prereq : prerequisites ) + for (Prerequisite prereq : prerequisites) { buf.append(prereq.toString()); } @@ -321,7 +331,7 @@ /* * (non-Javadoc) - * + * * @see java.lang.Object#clone() */ @Override @@ -332,30 +342,33 @@ if (prerequisites != null) { copy.prerequisites = new ArrayList<Prerequisite>(); - for ( Prerequisite subreq : prerequisites ) + for (Prerequisite subreq : prerequisites) { copy.prerequisites.add(subreq.clone()); } } - // All of these aer either immutable, or primitive, neither of which need cloning - // private String kind; - // private String key=null; - // private String subKey=null; - // private PrerequisiteOperator operator= new PrerequisiteOperator(PrerequisiteOperator.GTEQ); - // private String operand="1"; //$NON-NLS-1$ - // private boolean countMultiples; - // private boolean overrideQualify=false; + // All of these aer either immutable, or primitive, neither of which + // need cloning + // private String kind; + // private String key=null; + // private String subKey=null; + // private PrerequisiteOperator operator= new + // PrerequisiteOperator(PrerequisiteOperator.GTEQ); + // private String operand="1"; //$NON-NLS-1$ + // private boolean countMultiples; + // private boolean overrideQualify=false; return copy; } /** - * This method will expand the given token in the "value" of this Prerequisite, it will also expand the token in - * any sub Prerequisites - * + * This method will expand the given token in the "value" of this + * Prerequisite, it will also expand the token in any sub Prerequisites + * * @param token - * The string representing the token to be replaces (i.e. "%CHOICE") + * The string representing the token to be replaces (i.e. + * "%CHOICE") * @param tokenValue * The String representing the new value to be used (i.e. "+2") */ @@ -366,7 +379,7 @@ if (prerequisites != null) { - for ( Prerequisite subreq : prerequisites ) + for (Prerequisite subreq : prerequisites) { subreq.expandToken(token, tokenValue); } @@ -374,10 +387,11 @@ } /** - * Retrieve the description of the prerequisite. This can either be - * in long form 'skill TUMBLE gteq 5' or in short form 'TUMBLE'. - * - * @param shortForm True if the abbreviated form should be used. + * Retrieve the description of the prerequisite. This can either be in long + * form 'skill TUMBLE gteq 5' or in short form 'TUMBLE'. + * + * @param shortForm + * True if the abbreviated form should be used. * @return The description of the prerequisite */ public String getDescription(final boolean shortForm) @@ -387,7 +401,7 @@ if (levelQualifier > 0 && !shortForm) { buf.append("at level "); - buf.append(levelQualifier+":"); + buf.append(levelQualifier + ":"); buf.append(' '); //$NON-NLS-1$ } @@ -395,7 +409,7 @@ if (categoryName != null && !shortForm) { buf.append("of category "); - buf.append(categoryName+":"); + buf.append(categoryName + ":"); buf.append(' '); //$NON-NLS-1$ } @@ -440,7 +454,7 @@ if (prerequisites.size() > 0 && !shortForm) { buf.append(" ("); //$NON-NLS-1$ - for ( Prerequisite subreq : prerequisites ) + for (Prerequisite subreq : prerequisites) { buf.append(subreq.getDescription(shortForm)); } @@ -469,11 +483,95 @@ } /** - * @param categoryName the categoryName to set + * @param categoryName + * the categoryName to set */ public void setCategoryName(String categoryName) { this.categoryName = categoryName; } + @Override + public int hashCode() + { + return kind.hashCode() ^ key.hashCode(); + } + + @Override + public boolean equals(Object o) + { + if (o == this) + { + return true; + } + if (!(o instanceof Prerequisite)) + { + return false; + } + Prerequisite other = (Prerequisite) o; + if (kind == null) + { + if (other.kind != null) + { + return false; + } + } + if (key == null) + { + if (other.key != null) + { + return false; + } + } + if (subKey == null) + { + if (other.subKey != null) + { + return false; + } + } + if (categoryName == null) + { + if (other.categoryName != null) + { + return false; + } + } + boolean iHave = prerequisites != null && !prerequisites.isEmpty(); + boolean otherHas = + other.prerequisites != null && !other.prerequisites.isEmpty(); + if (iHave) + { + if (!otherHas) + { + return false; + } + List<Prerequisite> otherPRL = other.prerequisites; + if (otherPRL.size() != prerequisites.size()) + { + return false; + } + ArrayList<Prerequisite> removed = + new ArrayList<Prerequisite>(prerequisites); + removed.removeAll(otherPRL); + if (!removed.isEmpty()) + { + return false; + } + } + else if (otherHas) + { + return false; + } + return totalValues == other.totalValues + && countMultiples == other.countMultiples + && overrideQualify == other.overrideQualify + && levelQualifier == other.levelQualifier + && operator == other.operator + && (kind == null || kind.equals(other.kind)) + && (key == null || key.equals(other.key)) + && (subKey == null || subKey.equals(other.subKey)) + && operand.equals(other.operand) + && (categoryName == null || categoryName.equals(other.categoryName)); + } } Modified: branches/cdom/code/src/java/pcgen/persistence/CategorizedReferenceContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/CategorizedReferenceContext.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/persistence/CategorizedReferenceContext.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -25,6 +25,7 @@ import pcgen.base.util.TripleKeyMapToInstanceList; import pcgen.cdom.base.CDOMCategorizedSingleRef; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.CategorizedCDOMObject; import pcgen.cdom.base.Category; import pcgen.core.Ability; @@ -133,7 +134,8 @@ Category<T> cat = obj.getCDOMCategory(); if (active.get(cl, cat, oldKey).equals(obj)) { - List<CategorizedCDOMObject> list = duplicates.getListFor(cl, cat, oldKey); + List<CategorizedCDOMObject> list = + duplicates.getListFor(cl, cat, oldKey); if (list == null) { // No replacement @@ -141,7 +143,8 @@ } else { - CategorizedCDOMObject newActive = duplicates.getItemFor(cl, cat, oldKey, 0); + CategorizedCDOMObject newActive = + duplicates.getItemFor(cl, cat, oldKey, 0); duplicates.removeFromListFor(cl, cat, oldKey, newActive); active.put(cl, cat, oldKey, newActive); } @@ -158,7 +161,8 @@ Category<T> cat, T obj) { Category<T> oldCat = obj.getCDOMCategory(); - if (oldCat == null && cat == null || oldCat != null && oldCat.equals(cat)) + if (oldCat == null && cat == null || oldCat != null + && oldCat.equals(cat)) { Logging.errorPrint("Worthless Category change encountered: " + obj.getDisplayName() + " " + oldCat); @@ -167,7 +171,8 @@ String key = obj.getKeyName(); if (active.get(cl, oldCat, key).equals(obj)) { - List<CategorizedCDOMObject> list = duplicates.getListFor(cl, oldCat, key); + List<CategorizedCDOMObject> list = + duplicates.getListFor(cl, oldCat, key); if (list == null) { // No replacement @@ -175,7 +180,8 @@ } else { - CategorizedCDOMObject newActive = duplicates.getItemFor(cl, oldCat, key, 0); + CategorizedCDOMObject newActive = + duplicates.getItemFor(cl, oldCat, key, 0); duplicates.removeFromListFor(cl, oldCat, key, newActive); active.put(cl, oldCat, key, newActive); } @@ -318,7 +324,8 @@ { List<CategorizedCDOMObject> list = duplicates.getListFor(key1, key2, second); - CategorizedCDOMObject good = active.get(key1, key2, second); + CategorizedCDOMObject good = + active.get(key1, key2, second); for (int i = 0; i < list.size(); i++) { CategorizedCDOMObject dupe = list.get(i); @@ -408,4 +415,26 @@ active.clear(); referenced.clear(); } + + public <T extends PObject & CategorizedCDOMObject<T>> ReferenceManufacturer<T> getReferenceManufacturer( + final Class<T> c, final Category<T> cat) + { + if (!Ability.class.equals(c)) + { + throw new IllegalArgumentException(c.getSimpleName() + + " is not a Categorized Class"); + } + return new ReferenceManufacturer<T>() + { + public CDOMReference<T> getReference(String key) + { + return getCDOMReference(c, cat, key); + } + + public Class<T> getCDOMClass() + { + return c; + } + }; + } } Modified: branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java 2007-04-22 14:14:58 UTC (rev 2767) +++ branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java 2007-04-22 17:12:04 UTC (rev 2768) @@ -24,7 +24,6 @@ import pcgen.cdom.base.CategorizedCDOMObject; import pcgen.cdom.base.Category; import pcgen.core.PObject; -import pcgen.core.WeaponProf; import pcgen.util.StringPClassUtil; public class ReferenceContext @@ -87,7 +86,8 @@ } } - public <T extends CDOMObject> void constructIfNecessary(Class<T> cl, String value) + public <T extends CDOMObject> void constructIfNecessary(Class<T> cl, + String value) { simple.constructIfNecessary(cl, value); } @@ -107,7 +107,8 @@ { if (CategorizedCDOMObject.class.isAssignableFrom(obj.getClass())) { - categorized.reassociateReference(value, (CategorizedCDOMObject) obj); + categorized + .reassociateReference(value, (CategorizedCDOMObject) obj); } else { @@ -145,19 +146,32 @@ categorized.reassociateReference(cat, obj); } - public <T extends PObject> T cloneConstructedCDOMObject(Class<T> cl, T orig, String newKey) + public <T extends PObject> T cloneConstructedCDOMObject(Class<T> cl, + T orig, String newKey) { if (CategorizedCDOMObject.class.isAssignableFrom(cl)) { Class catCl = (Class) cl; CategorizedCDOMObject cco = (CategorizedCDOMObj... [truncated message content] |
From: <th...@us...> - 2007-04-24 23:00:11
|
Revision: 2774 http://svn.sourceforge.net/pcgen/?rev=2774&view=rev Author: thpr Date: 2007-04-24 16:00:11 -0700 (Tue, 24 Apr 2007) Log Message: ----------- CDOM: Re-Implement CompanionList (now a 3rd Party Token) & add unit tests for it Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/content/KnownSpellIdentifier.java branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java branches/cdom/code/src/java/pcgen/cdom/enumeration/VariableKey.java branches/cdom/code/src/java/pcgen/cdom/restriction/FollowerRestriction.java branches/cdom/code/src/java/pcgen/persistence/ReferenceManufacturer.java branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/core/CompanionList.java branches/cdom/code/src/utest/plugin/lsttokens/CompanionListLstTest.java Removed Paths: ------------- branches/cdom/code/src/java/pcgen/cdom/content/CompanionList.java branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MfeatToken.java Deleted: branches/cdom/code/src/java/pcgen/cdom/content/CompanionList.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/CompanionList.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/pcgen/cdom/content/CompanionList.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -1,98 +0,0 @@ -/* - * Copyright 2007 (C) Tom Parker <th...@us...> - * - * This library is free software; you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) - * any later version. - * - * This library is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS - * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more - * details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ -package pcgen.cdom.content; - -import java.util.Collection; -import java.util.HashSet; -import java.util.Set; - -import pcgen.cdom.base.CDOMReference; -import pcgen.cdom.base.ConcretePrereqObject; -import pcgen.core.Race; - -public class CompanionList extends ConcretePrereqObject -{ - - private final Set<CDOMReference<Race>> companionList; - - private final String companionType; - - private int followerAdj = 0; - - public CompanionList(String type, Collection<CDOMReference<Race>> raceList) - { - if (type == null) - { - throw new IllegalArgumentException( - "CompanionList requires a non-null type"); - } - if (raceList == null) - { - throw new IllegalArgumentException( - "CompanionList requires a non-null list"); - } - if (raceList.size() == 0) - { - throw new IllegalArgumentException( - "CompanionList requires a non-empty list"); - } - companionType = type; - companionList = new HashSet<CDOMReference<Race>>(); - for (CDOMReference<Race> cr : raceList) - { - if (cr == null) - { - throw new IllegalArgumentException( - "CompanionList prohibites null entries in list"); - } - companionList.add(cr); - } - } - - public void setAdjustment(int followerAdjustment) - { - followerAdj = followerAdjustment; - } - - public String getFollowerType() - { - return companionType; - } - - public boolean containsRace(Race r) - { - for (CDOMReference<Race> ref : companionList) - { - if (ref.contains(r)) - { - return true; - } - } - return false; - } - - public int getAdjustment() - { - return followerAdj; - } - - public Set<CDOMReference<Race>> getCompanionSet() - { - return new HashSet<CDOMReference<Race>>(companionList); - } -} Modified: branches/cdom/code/src/java/pcgen/cdom/content/KnownSpellIdentifier.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/KnownSpellIdentifier.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/pcgen/cdom/content/KnownSpellIdentifier.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -1,27 +1,19 @@ /* - * SpellProhibitor.java - * Copyright 2005 (c) Tom Parker <th...@so...> - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Created on November 3, 2006 - * - * Current Ver: $Revision: 1522 $ - * Last Editor: $Author: thpr $ - * Last Edited: $Date: 2006-10-24 18:40:09 -0400 (Tue, 24 Oct 2006) $ - * + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ package pcgen.cdom.content; Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -66,6 +66,8 @@ public static final AssociationKey<String> TYPE = new AssociationKey<String>(); + public static final AssociationKey<Integer> FOLLOWER_ADJUSTMENT = new AssociationKey<Integer>(); + private static CaseInsensitiveMap<AssociationKey<?>> map = null; private AssociationKey() { Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/VariableKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/VariableKey.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/VariableKey.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006 Tom Parker <th...@us...> + * Copyright (c) 2007 Tom Parker <th...@us...> * * This program is free software; you can redistribute it and/or modify it under * the terms of the GNU Lesser General Public License as published by the Free Modified: branches/cdom/code/src/java/pcgen/cdom/restriction/FollowerRestriction.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/restriction/FollowerRestriction.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/pcgen/cdom/restriction/FollowerRestriction.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -17,18 +17,19 @@ */ package pcgen.cdom.restriction; +import pcgen.cdom.base.CDOMSingleRef; import pcgen.cdom.base.Restriction; -import pcgen.cdom.content.CompanionList; +import pcgen.core.CompanionList; import pcgen.core.character.Follower; public class FollowerRestriction implements Restriction<Follower> { - private final CompanionList compList; + private final CDOMSingleRef<CompanionList> compList; private final Class<Follower> targetClass = Follower.class; - public FollowerRestriction(CompanionList cl) + public FollowerRestriction(CDOMSingleRef<CompanionList> cl) { compList = cl; } @@ -40,7 +41,13 @@ // CONSIDER This is an Error, or is false sufficient? return false; } - return compList.containsRace(pro.getRaceObject()); + CompanionList cl = compList.resolvesTo(); + /* + * TODO FIXME This probably needs to receive a reference to the active PC? + * That is actually rather ugly, but since CompanionList is now a "list" + * in the Graph, that is probably what needs to happen... + */ + return false; //compList.containsRace(pro.getRaceObject()); } public Class<Follower> getRestrictedClass() Added: branches/cdom/code/src/java/pcgen/core/CompanionList.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/CompanionList.java (rev 0) +++ branches/cdom/code/src/java/pcgen/core/CompanionList.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -0,0 +1,7 @@ +package pcgen.core; + +public class CompanionList extends PObject { + + // No additional Functionality :) + +} Modified: branches/cdom/code/src/java/pcgen/persistence/ReferenceManufacturer.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/ReferenceManufacturer.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/pcgen/persistence/ReferenceManufacturer.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -1,3 +1,20 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package pcgen.persistence; import pcgen.cdom.base.CDOMReference; Modified: branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -29,13 +29,18 @@ import java.util.Set; import java.util.StringTokenizer; import java.util.HashSet; +import java.util.TreeSet; +import pcgen.base.util.TripleKeyMapToList; import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; -import pcgen.cdom.content.CompanionList; +import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.graph.PCGraphAllowsEdge; import pcgen.cdom.graph.PCGraphEdge; -import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.cdom.inst.Aggregator; +import pcgen.cdom.util.ReferenceUtilities; +import pcgen.core.CompanionList; import pcgen.core.FollowerOption; import pcgen.core.PObject; import pcgen.core.Race; @@ -47,6 +52,7 @@ import pcgen.persistence.lst.LstUtils; import pcgen.persistence.lst.output.prereq.PrerequisiteWriter; import pcgen.persistence.lst.prereq.PreParserFactory; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.Logging; import pcgen.util.PropertyFactory; @@ -219,26 +225,71 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) throws PersistenceLayerException { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " arguments may not be empty"); + return false; + } + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } StringTokenizer tok = new StringTokenizer(value, LstUtils.PIPE); String companionType = tok.nextToken(); if (!tok.hasMoreTokens()) { - throw new PersistenceLayerException(PropertyFactory - .getFormattedString("Errors.LstTokens.InvalidTokenFormat", //$NON-NLS-1$ - getTokenName(), value)); + Logging.errorPrint(getTokenName() + + " requires more than just a Type: " + value); + return false; } String list = tok.nextToken(); + + if (list.charAt(0) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with , : " + value); + return false; + } + if (list.charAt(list.length() - 1) == ',') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with , : " + value); + return false; + } + if (list.indexOf(",,") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator ,, : " + value); + return false; + } + StringTokenizer subTok = new StringTokenizer(list, LstUtils.COMMA); Set<CDOMReference<Race>> races = new HashSet<CDOMReference<Race>>(); + boolean foundAny = false; while (subTok.hasMoreTokens()) { String tokString = subTok.nextToken(); if (Constants.LST_ANY.equalsIgnoreCase(tokString)) { + foundAny = true; races.add(context.ref.getCDOMAllReference(Race.class)); } else @@ -246,8 +297,15 @@ races.add(context.ref.getCDOMReference(Race.class, tokString)); } } + if (foundAny && races.size() > 1) + { + Logging + .errorPrint("Non-sensical Race List includes Any and specific races: " + + value); + return false; + } - int followerAdjustment = 0; + Integer followerAdjustment = null; final List<Prerequisite> prereqs = new ArrayList<Prerequisite>(); // The remainder of the elements are optional. @@ -256,19 +314,19 @@ String optArg = tok.nextToken(); if (optArg.startsWith(FOLLOWERADJUSTMENT)) { - if (followerAdjustment != 0) + if (followerAdjustment != null) { Logging.errorPrint(getTokenName() + " Error: Multiple " + FOLLOWERADJUSTMENT + " tags specified."); return false; } - //FIXME Check = + // FIXME Check = String adj = optArg.substring(FOLLOWERADJUSTMENT.length() + 1); try { - followerAdjustment = Integer.parseInt(adj); + followerAdjustment = Integer.valueOf(adj); } catch (NumberFormatException nfe) { @@ -285,55 +343,113 @@ } else { - Logging.debugPrint(getTokenName() - + ": Unknown optional argument: " //$NON-NLS-1$ - + optArg); + Logging + .errorPrint(getTokenName() + + ": Unknown argument (was expecting FOLLOWERALIGN: or PRExxx): " + + optArg); + return false; } } - CompanionList cl = new CompanionList(companionType, races); - if (followerAdjustment != 0) + + CDOMReference<CompanionList> ref = + context.ref + .getCDOMReference(CompanionList.class, companionType); + + Aggregator agg = new Aggregator(obj, ref, getTokenName()); + agg.addPrerequisites(prereqs); + /* + * This is intentionally Holds, as the context for traversal must only + * be the ref (linked by the Activation Edge). So we need an edge to the + * Activator to get it copied into the PC, but since this is a 3rd party + * Token, the Race should never grant anything hung off the aggregator. + */ + context.graph.linkHoldsIntoGraph(getTokenName(), obj, agg); + context.graph.linkActivationIntoGraph(getTokenName(), ref, agg); + for (CDOMReference<Race> race : races) { - cl.setAdjustment(followerAdjustment); + PCGraphAllowsEdge edge = + context.graph.linkAllowIntoGraph(getTokenName(), agg, race); + if (followerAdjustment != null) + { + edge.setAssociation(AssociationKey.FOLLOWER_ADJUSTMENT, + followerAdjustment); + } } - PCGraphGrantsEdge edge = - context.graph.linkObjectIntoGraph(getTokenName(), obj, cl); - for (Prerequisite prereq : prereqs) - { - edge.addPrerequisite(prereq); - } return true; } public String[] unparse(LoadContext context, CDOMObject obj) { - Set<PCGraphEdge> edgeList = + Set<PCGraphEdge> edgeSet = context.graph.getChildLinksFromToken(getTokenName(), obj, - CompanionList.class); - if (edgeList == null || edgeList.isEmpty()) + Aggregator.class); + if (edgeSet == null || edgeSet.isEmpty()) { return null; } - PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); - List<String> list = new ArrayList<String>(); - for (PCGraphEdge edge : edgeList) + + TripleKeyMapToList<Set<Prerequisite>, CDOMReference<CompanionList>, Integer, CDOMReference<Race>> m = + new TripleKeyMapToList<Set<Prerequisite>, CDOMReference<CompanionList>, Integer, CDOMReference<Race>>(); + for (PCGraphEdge edge : edgeSet) { - List<Prerequisite> prereqs = edge.getPrerequisiteList(); - CompanionList cl = (CompanionList) edge.getNodeAt(1); - int followerAdjustment = cl.getAdjustment(); - StringBuilder sb = new StringBuilder(); - sb.append(cl.getFollowerType()); - for (CDOMReference<Race> race : cl.getCompanionSet()) + Aggregator agg = (Aggregator) edge.getNodeAt(1); + Set<PCGraphEdge> childSet = + context.graph.getChildLinksFromToken(getTokenName(), agg, + Race.class); + if (childSet == null || childSet.isEmpty()) { - sb.append(Constants.PIPE).append(race.getLSTformat()); + context + .addWriteMessage("Empty Child Set not valid for Aggregator in " + + getTokenName()); + return null; } - if (followerAdjustment != 0) + + Set<PCGraphEdge> parentSet = + context.graph.getParentLinksFromToken(getTokenName(), agg, + CompanionList.class); + if (parentSet == null || parentSet.isEmpty()) { - sb.append(Constants.PIPE).append(FOLLOWERADJUSTMENT).append( - Constants.COLON); - sb.append(followerAdjustment); + context + .addWriteMessage("Empty Parent Set not valid for Aggregator in " + + getTokenName()); + return null; } + if (parentSet.size() != 1) + { + context + .addWriteMessage("Parent Set with more than one entry not valid for Aggregator in " + + getTokenName()); + return null; + } + CDOMReference<CompanionList> parent = + (CDOMReference<CompanionList>) parentSet.iterator().next() + .getNodeAt(0); + + Set<Prerequisite> prereqs = + new HashSet<Prerequisite>(agg.getPreReqList()); + + for (PCGraphEdge child : childSet) + { + Integer fa = + child + .getAssociation(AssociationKey.FOLLOWER_ADJUSTMENT); + CDOMReference<Race> race = + (CDOMReference<Race>) child.getNodeAt(1); + m.addToListFor(prereqs, parent, fa, race); + } + } + + PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); + Set<String> set = new TreeSet<String>(); + Set<CDOMReference<?>> refSet = + new TreeSet<CDOMReference<?>>(TokenUtilities.REFERENCE_SORTER); + StringBuilder sb = new StringBuilder(); + for (Set<Prerequisite> prereqs : m.getKeySet()) + { + String prereqString = ""; if (prereqs != null && !prereqs.isEmpty()) { + sb.setLength(0); for (Prerequisite p : prereqs) { StringWriter swriter = new StringWriter(); @@ -349,9 +465,32 @@ } sb.append(Constants.PIPE).append(swriter.toString()); } + prereqString = sb.toString(); } - list.add(sb.toString()); + + for (CDOMReference<CompanionList> cl : m + .getSecondaryKeySet(prereqs)) + { + for (Integer fa : m.getTertiaryKeySet(prereqs, cl)) + { + sb.setLength(0); + sb.append(cl.getLSTformat()); + sb.append(Constants.PIPE); + refSet.clear(); + refSet.addAll(m.getListFor(prereqs, cl, fa)); + sb.append(ReferenceUtilities.joinLstFormat(refSet, + Constants.COMMA)); + if (fa != null) + { + sb.append(Constants.PIPE); + sb.append("FOLLOWERADJUSTMENT:"); + sb.append(fa); + } + sb.append(prereqString); + set.add(sb.toString()); + } + } } - return list.toArray(new String[list.size()]); + return set.toArray(new String[set.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -26,14 +26,14 @@ import pcgen.base.formula.Formula; import pcgen.base.util.Logging; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CDOMReference; +import pcgen.cdom.base.CDOMSimpleSingleRef; import pcgen.cdom.base.Constants; import pcgen.cdom.base.FormulaFactory; import pcgen.cdom.base.Restriction; import pcgen.cdom.base.Slot; -import pcgen.cdom.content.CompanionList; import pcgen.cdom.graph.PCGraphEdge; -import pcgen.cdom.restriction.CompoundRestriction; -import pcgen.cdom.restriction.FollowerRestriction; +import pcgen.core.CompanionList; import pcgen.core.PObject; import pcgen.core.character.Follower; import pcgen.persistence.LoadContext; @@ -139,49 +139,15 @@ } String followerNumber = tok.nextToken(); Formula num = FormulaFactory.getFormulaFor(followerNumber); - /* - * BUG FIXME This is a problem, because it is possible that the - * CompanionList is NOT YET PRESENT in the Graph... :P - * - * So I think I need to fetch a Reference, and then officially build the - * CompanionList through the Context later on? That seems like a PAIN... - * - * Actually, even that doesn't work, because there could be more than - * one... so a reference doesn't do any good Therefore, this is a - * deferred search of a Graph? I'm not a huge fan of that either. - */ - Set<PCGraphEdge> linkSet = - context.graph.getChildLinks(obj, CompanionList.class); - boolean found = false; - CompoundRestriction<Follower> cr = - new CompoundRestriction<Follower>(Follower.class, 1); - for (PCGraphEdge edge : linkSet) - { - CompanionList cl = (CompanionList) edge.getNodeAt(1); - /* - * CONSIDER Should this be case sensitive or not? - */ - if (cl.getFollowerType().equalsIgnoreCase(followerType)) - { - cr.addRestriction(new FollowerRestriction(cl)); - found = true; - // Can't break, there may be more than one - } - } - if (found) - { - Slot<Follower> slot = - context.graph.addSlotIntoGraph(getTokenName(), obj, - Follower.class, num); - slot.addSinkRestriction(cr); - } - else - { - Logging - .errorPrint("Unable to find COMPANIONLIST for Follower Type: " - + followerType); - } - return found; + CDOMReference<CompanionList> ref = + context.ref.getCDOMReference(CompanionList.class, followerType); + + Slot<Follower> slot = + context.graph.addSlotIntoGraph(getTokenName(), obj, + Follower.class, num); + slot.addSinkRestriction(cr); + + return true; } public String[] unparse(LoadContext context, CDOMObject obj) Deleted: branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/plugin/lsttokens/MoveaLst.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -1,80 +0,0 @@ -/* - * Copyright 2006-2007 (C) Tom Parker <th...@us...> - * Copyright 2005-2006 (C) Devon Jones - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Current Ver: $Revision$ - * Last Editor: $Author$ - * Last Edited: $Date$ - */ -package plugin.lsttokens; - -import java.util.Set; -import java.util.TreeSet; - -import pcgen.cdom.base.CDOMObject; -import pcgen.cdom.graph.PCGraphEdge; -import pcgen.core.Movement; -import pcgen.core.PObject; -import pcgen.persistence.LoadContext; -import pcgen.persistence.lst.GlobalLstToken; - -/** - * @author djones4 - * - */ -public class MoveaLst implements GlobalLstToken -{ - - public String getTokenName() - { - return "MOVEA"; - } - - public boolean parse(PObject obj, String value, int anInt) - { - Movement cm = Movement.getOldMovementFrom(value); - cm.setMoveRatesFlag(1); - obj.setMovement(cm, anInt); - return true; - } - - public boolean parse(LoadContext context, CDOMObject obj, String value) - { - Movement cm = Movement.getMovementFrom(value); - cm.setMoveRatesFlag(1); - context.graph.linkObjectIntoGraph(getTokenName(), obj, cm); - return true; - } - - public String[] unparse(LoadContext context, CDOMObject obj) - { - Set<PCGraphEdge> edgeList = - context.graph.getChildLinksFromToken(getTokenName(), obj, - Movement.class); - if (edgeList == null || edgeList.isEmpty()) - { - return null; - } - Set<String> set = new TreeSet<String>(); - for (PCGraphEdge edge : edgeList) - { - Movement m = (Movement) edge.getSinkNodes().get(0); - set.add(m.toLSTString()); - } - return set.toArray(new String[set.size()]); - } -} Deleted: branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceToken.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/plugin/lsttokens/race/HitdiceToken.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -1,72 +0,0 @@ -/* - * Copyright 2006-2007 (C) Tom Parker <th...@us...> - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Current Ver: $Revision$ - * Last Editor: $Author$ - * Last Edited: $Date$ - */ -package plugin.lsttokens.race; - -import java.util.StringTokenizer; - -import pcgen.core.Race; -import pcgen.persistence.LoadContext; -import pcgen.persistence.lst.RaceLstToken; - -/** - * Class deals with HITDICE Token - */ -public class HitdiceToken implements RaceLstToken -{ - - public String getTokenName() - { - return "HITDICE"; - } - - public boolean parse(Race race, String value) - { - try - { - final StringTokenizer hitdice = new StringTokenizer(value, ","); - - if (hitdice.countTokens() != 2) - { - return false; - } - race.setHitDice(Integer.parseInt(hitdice.nextToken())); - race.setHitDiceSize(Integer.parseInt(hitdice.nextToken())); - return true; - } - catch (NumberFormatException nfe) - { - return false; - } - } - - public boolean parse(LoadContext context, Race race, String value) - { - // This is a hack to cover the monster changes - return true; - } - - public String[] unparse(LoadContext context, Race race) - { - // Well, this is a hack too :) - return null; - } -} Deleted: branches/cdom/code/src/java/plugin/lsttokens/race/MfeatToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/race/MfeatToken.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/java/plugin/lsttokens/race/MfeatToken.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -1,58 +0,0 @@ -/* - * Copyright 2006-2007 (C) Tom Parker <th...@us...> - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * Current Ver: $Revision$ - * Last Editor: $Author$ - * Last Edited: $Date$ - */ -package plugin.lsttokens.race; - -import pcgen.core.Race; -import pcgen.persistence.LoadContext; -import pcgen.persistence.PersistenceLayerException; -import pcgen.persistence.lst.RaceLstToken; - -/** - * Class deals with MFEAT Token - */ -public class MfeatToken implements RaceLstToken -{ - - public String getTokenName() - { - return "MFEAT"; - } - - public boolean parse(Race race, String value) - { - race.setMFeatList(value); - return true; - } - - public boolean parse(LoadContext context, Race race, String value) - throws PersistenceLayerException - { - // This is a HACK to patch the monster stuff in 5.11 - return true; - } - - public String[] unparse(LoadContext context, Race race) - { - // Well, so this is a hack too :) - return null; - } -} Added: branches/cdom/code/src/utest/plugin/lsttokens/CompanionListLstTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/CompanionListLstTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/CompanionListLstTest.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -0,0 +1,282 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens; + +import java.net.URISyntaxException; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.core.PCTemplate; +import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.GlobalLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; +import plugin.lsttokens.testsupport.AbstractGlobalTokenTestCase; +import plugin.lsttokens.testsupport.TokenRegistration; +import plugin.pretokens.parser.PreClassParser; +import plugin.pretokens.parser.PreRaceParser; +import plugin.pretokens.writer.PreClassWriter; +import plugin.pretokens.writer.PreRaceWriter; + +public class CompanionListLstTest extends AbstractGlobalTokenTestCase +{ + + static GlobalLstToken token = new CompanionListLst(); + static PCTemplateLoader loader = new PCTemplateLoader(); + + PreClassParser preclass = new PreClassParser(); + PreClassWriter preclasswriter = new PreClassWriter(); + PreRaceParser prerace = new PreRaceParser(); + PreRaceWriter preracewriter = new PreRaceWriter(); + + @Override + @Before + public void setUp() throws PersistenceLayerException, URISyntaxException + { + super.setUp(); + TokenRegistration.register(preclass); + TokenRegistration.register(preclasswriter); + TokenRegistration.register(prerace); + TokenRegistration.register(preracewriter); + } + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + @Override + public GlobalLstToken getToken() + { + return token; + } + + @Test + public void testInvalidEmpty() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "")); + } + + @Test + public void testInvalidListNameOnly() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "Familiar")); + } + + @Test + public void testInvalidListNameBarOnly() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "Familiar|")); + } + + @Test + public void testInvalidEmptyListName() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "|Lion")); + } + + @Test + public void testInvalidTypeRaceBarOnly() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "Familiar|Lion|")); + } + + @Test + public void testInvalidRaceCommaStarting() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "Familiar|,Lion")); + } + + @Test + public void testInvalidRaceCommaEnding() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "Familiar|Lion,")); + } + + @Test + public void testInvalidRaceDoubleComma() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Lion,,Tiger")); + } + + @Test + public void testInvalidRacePipe() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Lion|Tiger")); + } + + @Test + public void testInvalidSpellEmbeddedPre() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Lion|PRERACE:1,Human|Tiger")); + } + + @Test + public void testInvalidNonSensicalAnyLast() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Tiger,Any")); + } + + @Test + public void testInvalidNonSensicalAnyFirst() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Any,Lion")); + } + + @Test + public void testInvalidEmbeddedFA() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|FOLLOWERADJUSTMENT:-4|Lion")); + } + + @Test + public void testInvalidOnlyFOLLOWERADJUSTMENT() + throws PersistenceLayerException + { + boolean parse = + token.parse(primaryContext, primaryProf, + "Familiar|FOLLOWERADJUSTMENT:-3"); + if (parse) + { + assertFalse(primaryContext.ref.validate()); + } + } + + @Test + public void testInvalidMultipleFOLLOWERADJUSTMENT() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Lion|FOLLOWERADJUSTMENT:-2|FOLLOWERADJUSTMENT:-3")); + } + + @Test + public void testInvalidOnlyFOLLOWERADJUSTMENTBar() + throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|FOLLOWERADJUSTMENT:-3|")); + } + + @Test + public void testInvalidEmptyTimes() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, "Familiar||Lion")); + } + + @Test + public void testInvalidBadFA() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Lion|FOLLOWERADJUSTMENT:")); + } + + @Test + public void testInvalidFANaN() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Lion|FOLLOWERADJUSTMENT:-T")); + } + + @Test + public void testInvalidFADecimal() throws PersistenceLayerException + { + assertFalse(token.parse(primaryContext, primaryProf, + "Familiar|Lion|FOLLOWERADJUSTMENT:-4.5")); + } + + @Test + public void testInvalidOnlyPre() throws PersistenceLayerException + { + try + { + boolean parse = + token.parse(primaryContext, primaryProf, + "Familiar|FOLLOWERADJUSTMENT:-3|PRERACE:1,Human"); + if (parse) + { + assertFalse(primaryContext.ref.validate()); + } + } + catch (IllegalArgumentException iae) + { + // This is ok too + } + } + + @Test + public void testRoundRobinJustRace() throws PersistenceLayerException + { + runRoundRobin("Familiar|Lion"); + } + + @Test + public void testRoundRobinTwoRace() throws PersistenceLayerException + { + runRoundRobin("Familiar|Lion,Tiger"); + } + + @Test + public void testRoundRobinFA() throws PersistenceLayerException + { + runRoundRobin("Familiar|Lion|FOLLOWERADJUSTMENT:-4"); + } + + @Test + public void testRoundRobinTwoFA() throws PersistenceLayerException + { + runRoundRobin("Familiar|Lion|FOLLOWERADJUSTMENT:-4", + "Familiar|Tiger|FOLLOWERADJUSTMENT:-5"); + } + + @Test + public void testRoundRobinTwoType() throws PersistenceLayerException + { + runRoundRobin("Companion|Lion|FOLLOWERADJUSTMENT:-5", + "Familiar|Tiger|FOLLOWERADJUSTMENT:-5"); + } + + @Test + public void testRoundRobinComplex() throws PersistenceLayerException + { + runRoundRobin("Familiar|Lion,Tiger|FOLLOWERADJUSTMENT:-3|!PRECLASS:1,Cleric=1|PRERACE:1,Human"); + } + + @Test + public void testRoundRobinTwoPRE() throws PersistenceLayerException + { + runRoundRobin("Familiar|Lion|FOLLOWERADJUSTMENT:-5", + "Familiar|Tiger|FOLLOWERADJUSTMENT:-5|PRERACE:1,Human"); + } +} \ No newline at end of file Modified: branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java 2007-04-23 08:39:39 UTC (rev 2773) +++ branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java 2007-04-24 23:00:11 UTC (rev 2774) @@ -23,16 +23,17 @@ import junit.framework.TestSuite; @RunWith(Suite.class) -@Suite.SuiteClasses({CCSkillLstTest.class, CSkillLstTest.class, - DefineLstTest.class, DescispiLstTest.class, DescLstTest.class, - DrLstTest.class, KeyLstTest.class, KitLstTest.class, LangAutoLstTest.class, - MoveLstTest.class, NameispiLstTest.class, OutputNameLstTest.class, - QualifyTokenTest.class, RegionLstTest.class, SaLstTest.class, - SourceDateLstTest.class, SourceLongLstTest.class, SourcePageLstTest.class, - SourceShortLstTest.class, SourceWebLstTest.class, SpellLevelLstTest.class, - SpellsLstTest.class, SrLstTest.class, TempdescLstTest.class, - TemplateLstTest.class, TypeLstTest.class, UdamLstTest.class, - UmultLstTest.class, UnencumberedmoveLstTest.class, VisionLstTest.class}) +@Suite.SuiteClasses({CCSkillLstTest.class, CompanionListLstTest.class, + CSkillLstTest.class, DefineLstTest.class, DescispiLstTest.class, + DescLstTest.class, DrLstTest.class, KeyLstTest.class, KitLstTest.class, + LangAutoLstTest.class, MoveLstTest.class, NameispiLstTest.class, + OutputNameLstTest.class, QualifyTokenTest.class, RegionLstTest.class, + SaLstTest.class, SourceDateLstTest.class, SourceLongLstTest.class, + SourcePageLstTest.class, SourceShortLstTest.class, SourceWebLstTest.class, + SpellLevelLstTest.class, SpellsLstTest.class, SrLstTest.class, + TempdescLstTest.class, TemplateLstTest.class, TypeLstTest.class, + UdamLstTest.class, UmultLstTest.class, UnencumberedmoveLstTest.class, + VisionLstTest.class}) public class TokenGlobalTestSuite extends TestSuite { // No contents, see annotations This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-04-28 19:17:30
|
Revision: 2815 http://svn.sourceforge.net/pcgen/?rev=2815&view=rev Author: thpr Date: 2007-04-28 12:17:29 -0700 (Sat, 28 Apr 2007) Log Message: ----------- CDOM: More Token Tests & Associated core changes Modified Paths: -------------- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractListMapGraph.java branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java branches/cdom/code/src/java/pcgen/base/graph/core/Graph.java branches/cdom/code/src/java/pcgen/base/graph/core/SimpleListGraph.java branches/cdom/code/src/java/pcgen/cdom/base/CDOMAllRef.java branches/cdom/code/src/java/pcgen/cdom/base/CDOMCategorizedSingleRef.java branches/cdom/code/src/java/pcgen/cdom/base/CDOMCompoundReference.java branches/cdom/code/src/java/pcgen/cdom/base/CDOMReference.java branches/cdom/code/src/java/pcgen/cdom/base/CDOMSimpleSingleRef.java branches/cdom/code/src/java/pcgen/cdom/base/CDOMTypeRef.java branches/cdom/code/src/java/pcgen/cdom/modifier/ChangeProf.java branches/cdom/code/src/java/pcgen/persistence/GraphContext.java branches/cdom/code/src/java/pcgen/persistence/GroupReferenceContext.java branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java branches/cdom/code/src/java/pcgen/persistence/lst/TokenStore.java branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java branches/cdom/code/src/java/plugin/lsttokens/AbilityLst.java branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java branches/cdom/code/src/java/plugin/lsttokens/ChangeprofLst.java branches/cdom/code/src/java/plugin/lsttokens/CompanionListLst.java branches/cdom/code/src/java/plugin/lsttokens/CskillLst.java branches/cdom/code/src/java/plugin/lsttokens/FollowersLst.java branches/cdom/code/src/java/plugin/lsttokens/LangautoLst.java branches/cdom/code/src/java/plugin/lsttokens/RemoveLst.java branches/cdom/code/src/java/plugin/lsttokens/SpellsLst.java branches/cdom/code/src/java/plugin/lsttokens/TemplateLst.java branches/cdom/code/src/java/plugin/lsttokens/TypeLst.java branches/cdom/code/src/java/plugin/lsttokens/VisionLst.java branches/cdom/code/src/java/plugin/lsttokens/add/AbilityToken.java branches/cdom/code/src/java/plugin/lsttokens/add/ClassSkillsToken.java branches/cdom/code/src/java/plugin/lsttokens/add/EquipToken.java branches/cdom/code/src/java/plugin/lsttokens/add/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/add/LanguageToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SkillToken.java branches/cdom/code/src/java/plugin/lsttokens/add/SpellCasterToken.java branches/cdom/code/src/java/plugin/lsttokens/add/VFeatToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/ArmorProfToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/EquipToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/ShieldProfToken.java branches/cdom/code/src/java/plugin/lsttokens/auto/WeaponProfToken.java branches/cdom/code/src/java/plugin/lsttokens/deity/DomainsToken.java branches/cdom/code/src/java/plugin/lsttokens/domain/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AltcritmultToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AlteqmodToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/AlttypeToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/CritmultToken.java branches/cdom/code/src/java/plugin/lsttokens/equipment/EqmodToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/FeatautoToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/IsmonsterToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/KnownspellsToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/LangbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/SkilllistToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/SpelllistToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/VfeatToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/WeaponbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/XtrafeatsToken.java branches/cdom/code/src/java/plugin/lsttokens/race/FavclassToken.java branches/cdom/code/src/java/plugin/lsttokens/race/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/race/LangbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MonccskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/MoncskillToken.java branches/cdom/code/src/java/plugin/lsttokens/race/StartfeatsToken.java branches/cdom/code/src/java/plugin/lsttokens/race/WeaponbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/skill/ClassesToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/ClassesToken.java branches/cdom/code/src/java/plugin/lsttokens/spell/DomainsToken.java branches/cdom/code/src/java/plugin/lsttokens/template/FavoredclassToken.java branches/cdom/code/src/java/plugin/lsttokens/template/FeatToken.java branches/cdom/code/src/java/plugin/lsttokens/template/LangbonusToken.java branches/cdom/code/src/java/plugin/lsttokens/template/WeaponbonusToken.java branches/cdom/code/src/utest/pcgen/base/graph/core/TransparentTestStorageStrategy.java branches/cdom/code/src/utest/plugin/lsttokens/AllTokenUnitTests.java branches/cdom/code/src/utest/plugin/lsttokens/CCSkillLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/CSkillLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/CompanionListLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/DefineLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/DescLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/DescispiLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/DrLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/KitLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/LangAutoLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/MoveLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/NameispiLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/QualifyTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/SaLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/SpellLevelLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/SpellsLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/TemplateLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/UdamLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/UnencumberedmoveLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/VisionLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/CategoryTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/MultTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/StackTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/ability/VisibleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/add/AbilityTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/add/AbstractAddTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/add/SATokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/add/SpellLevelTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/auto/AbstractAutoTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/deity/AlignTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/deity/DeityWeapTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/deity/DomainsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/domain/FeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/AbstractCritMultTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/AbstractCritRangeTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/AbstractEqModTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/ContainsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/ModsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/QualityTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/SPropTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/SizeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/WeildTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipment/WtTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/ArmortypeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/AssignToAllTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/ChargesTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/CostdoubleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/FormatcatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/NameoptTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/SPropTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/equipmentmodifier/VisibleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AbstractPCClassLevelTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AbstractSpellCastingTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AddDomainsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/AttackCycleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/BonusSpellStatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/DeityTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/DomainTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExClassTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ExchangeLevelTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/FeatAutoTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/HitDieTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/IsMonsterTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/KnownspellsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/LangbonusTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/MaxLevelTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/MemorizeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ModToSkillsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ProhibitedTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/ProhibitspellTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SkillListTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellBookTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellListTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/SpellStatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TokenPCClassTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VFeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/VisibleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/WeaponbonusTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XppenaltyTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/XtraFeatsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/CRTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/FaceTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/FavoredClassTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/FeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/HitDiceAdvancementTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/HitDieTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/LangbonusTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/MonCCSkillTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/MonCSkillTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/MonsterClassTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/SizeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/StartFeatsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/TokenRaceTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/race/WeaponbonusTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/skill/ACheckTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/skill/ClassesTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/skill/ExclusiveTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/skill/KeystatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/skill/UseuntrainedTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/skill/VisibleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/spell/ClassesTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/spell/CostTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/spell/DomainsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/spell/StatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/AddLevelTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/BonusFeatsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/BonusSkillPointsTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/CRTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/FaceTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/FavoredClassTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/FeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/GenderLockTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/HDTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/HitDieTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/LangbonusTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/LevelTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/RaceSubtypeTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/RemovableTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/RepeatLevelTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/TokenTemplateTestSuite.java branches/cdom/code/src/utest/plugin/lsttokens/template/VisibleTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/WeaponbonusTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractBigDecimalTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractFormulaTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractGlobalFormulaTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractGlobalIntegerTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractGlobalListTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractGlobalTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractGlobalTypeSafeListTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractIntegerTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractItemTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractListTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractTextPropertyTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/testsupport/AbstractTypeSafeListTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/weaponprof/HandsTokenTest.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/cdom/content/Remover.java branches/cdom/code/src/java/pcgen/core/LanguageList.java branches/cdom/code/src/java/pcgen/core/PCTemplateList.java branches/cdom/code/src/java/pcgen/core/WeaponProfList.java branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLoader.java branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLstToken.java branches/cdom/code/src/java/plugin/lsttokens/remove/ branches/cdom/code/src/java/plugin/lsttokens/remove/FeatToken.java branches/cdom/code/src/utest/plugin/lsttokens/AbilityLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/ChangeProfLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/remove/ branches/cdom/code/src/utest/plugin/lsttokens/remove/AbstractRemoveTokenTestCase.java branches/cdom/code/src/utest/plugin/lsttokens/remove/FeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/remove/TokenRemoveTestSuite.java Removed Paths: ------------- branches/cdom/code/src/java/plugin/lsttokens/pcclass/TemplateToken.java branches/cdom/code/src/java/plugin/lsttokens/template/TemplateToken.java branches/cdom/code/src/utest/plugin/lsttokens/pcclass/TemplateTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/race/MFeatTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/template/TemplateTokenTest.java Modified: branches/cdom/code/src/java/pcgen/base/graph/core/AbstractListMapGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractListMapGraph.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/base/graph/core/AbstractListMapGraph.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -461,4 +461,15 @@ // This is really simple, but it works... and prevents a deep hash return nodeList.size() + edgeList.size() * 23; } + + /** + * Returns true if this Graph is empty (has no Nodes and no Edges); false + * otherwise. + * + * @return true if this Graph is empty; false otherwise + */ + public boolean isEmpty() + { + return nodeList.isEmpty() && edgeList.isEmpty(); + } } \ No newline at end of file Modified: branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/base/graph/core/AbstractSetMapGraph.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -456,4 +456,15 @@ // This is really simple, but it works... and prevents a deep hash return nodeMap.size() + edgeSet.size() * 23; } + + /** + * Returns true if this Graph is empty (has no Nodes and no Edges); false + * otherwise. + * + * @return true if this Graph is empty; false otherwise + */ + public boolean isEmpty() + { + return nodeMap.isEmpty() && edgeSet.isEmpty(); + } } \ No newline at end of file Modified: branches/cdom/code/src/java/pcgen/base/graph/core/Graph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/Graph.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/base/graph/core/Graph.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -207,4 +207,12 @@ * Edges to this Graph; false otherwise */ public boolean equals(Object o); + + /** + * Returns true if this Graph is empty (has no Nodes and no Edges); false + * otherwise. + * + * @return true if this Graph is empty; false otherwise + */ + public boolean isEmpty(); } \ No newline at end of file Modified: branches/cdom/code/src/java/pcgen/base/graph/core/SimpleListGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/graph/core/SimpleListGraph.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/base/graph/core/SimpleListGraph.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -363,4 +363,15 @@ // This is really simple, but it works... and prevents a deep hash return nodeList.size() + edgeList.size() * 23; } + + /** + * Returns true if this Graph is empty (has no Nodes and no Edges); false + * otherwise. + * + * @return true if this Graph is empty; false otherwise + */ + public boolean isEmpty() + { + return nodeList.isEmpty() && edgeList.isEmpty(); + } } \ No newline at end of file Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMAllRef.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMAllRef.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMAllRef.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -36,6 +36,12 @@ } @Override + public String getPrimitiveFormat() + { + return "ALL"; + } + + @Override public boolean contains(T obj) { if (referencedList == null) Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMCategorizedSingleRef.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMCategorizedSingleRef.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMCategorizedSingleRef.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -45,6 +45,12 @@ } @Override + public String getPrimitiveFormat() + { + return getName(); + } + + @Override public String getLSTformat() { return getName(); Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMCompoundReference.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMCompoundReference.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMCompoundReference.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -57,6 +57,23 @@ } @Override + public String getPrimitiveFormat() + { + StringBuilder sb = new StringBuilder(); + boolean needComma = false; + for (CDOMReference<?> ref : references) + { + if (needComma) + { + sb.append(','); + } + needComma = true; + sb.append(ref.getPrimitiveFormat()); + } + return sb.toString(); + } + + @Override public String getLSTformat() { return ReferenceUtilities.joinLstFormat(references, Constants.COMMA); Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMReference.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMReference.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMReference.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -52,5 +52,7 @@ + name; } + public abstract String getPrimitiveFormat(); + public abstract String getLSTformat(); } Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMSimpleSingleRef.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMSimpleSingleRef.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMSimpleSingleRef.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -51,6 +51,12 @@ } @Override + public String getPrimitiveFormat() + { + return getName(); + } + + @Override public String getLSTformat() { return getName(); Modified: branches/cdom/code/src/java/pcgen/cdom/base/CDOMTypeRef.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/CDOMTypeRef.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/cdom/base/CDOMTypeRef.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -38,9 +38,15 @@ } @Override + public String getPrimitiveFormat() + { + return StringUtil.join(types, "."); + } + + @Override public String getLSTformat() { - return "TYPE=" + StringUtil.join(types, "."); + return "TYPE=" + getPrimitiveFormat(); } @Override Added: branches/cdom/code/src/java/pcgen/cdom/content/Remover.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/Remover.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/content/Remover.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -0,0 +1,134 @@ +package pcgen.cdom.content; + +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; + +import pcgen.base.formula.Formula; +import pcgen.cdom.base.ConcretePrereqObject; +import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.PrereqObject; +import pcgen.cdom.base.Restriction; +import pcgen.cdom.enumeration.AssociationKey; + +public class Remover<T extends PrereqObject> extends ConcretePrereqObject +{ + private final Class<T> cl; + private final Formula removeCount; + + public Remover(Class<T> removedClass) + { + if (removedClass == null) + { + throw new IllegalArgumentException(); + } + cl = removedClass; + removeCount = FormulaFactory.getFormulaFor("1"); + } + + public Remover(Class<T> removedClass, Formula count) + { + if (removedClass == null) + { + throw new IllegalArgumentException(); + } + cl = removedClass; + removeCount = count; + } + + public Class<T> getRemovedClass() + { + return cl; + } + + public boolean isValid(PrereqObject o) + { + if (!cl.isAssignableFrom(o.getClass())) + { + return false; + } + if (!hasSinkRestrictions()) + { + return true; + } + for (Restriction r : getSinkRestrictions()) + { + if (!r.qualifies(o)) + { + return false; + } + } + return true; + } + + public String toLSTform() + { + return removeCount.toString(); + } + + @Override + public String toString() + { + StringBuilder sb = new StringBuilder(); + sb.append("Slot: ").append(removeCount.toString()); + sb.append(" objects of ").append(cl.getSimpleName()); + if (hasSinkRestrictions()) + { + sb.append(" [").append(getSinkRestrictions().toString()) + .append(']'); + } + return sb.toString(); + } + + @Override + public int hashCode() + { + return removeCount.hashCode() ^ cl.hashCode(); + } + + @Override + public boolean equals(Object o) + { + if (o == this) + { + return true; + } + if (!(o instanceof Remover)) + { + return false; + } + Remover<?> otherRemover = (Remover) o; + return cl.equals(otherRemover.cl) + && removeCount.equals(otherRemover.removeCount); + } + + /* + * CONSIDER Use AssociationSupport? - Tom Parker Apr 7 07 + */ + private Map<AssociationKey<?>, Object> associationMap; + + public <AKT> void setAssociation(AssociationKey<AKT> key, AKT value) + { + if (associationMap == null) + { + associationMap = new HashMap<AssociationKey<?>, Object>(); + } + associationMap.put(key, value); + } + + public <AKT> AKT getAssociation(AssociationKey<AKT> key) + { + return (AKT) (associationMap == null ? null : associationMap.get(key)); + } + + public Collection<AssociationKey<?>> getAssociationKeys() + { + return new HashSet<AssociationKey<?>>(associationMap.keySet()); + } + + public boolean hasAssociations() + { + return associationMap != null && !associationMap.isEmpty(); + } +} Modified: branches/cdom/code/src/java/pcgen/cdom/modifier/ChangeProf.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/modifier/ChangeProf.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/cdom/modifier/ChangeProf.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -72,4 +72,25 @@ { return result; } + + @Override + public int hashCode() + { + return 31 * source.hashCode() + result.hashCode(); + } + + @Override + public boolean equals(Object o) + { + if (o == this) + { + return true; + } + if (!(o instanceof ChangeProf)) + { + return false; + } + ChangeProf other = (ChangeProf) o; + return source.equals(other.source) && result.equals(other.result); + } } Added: branches/cdom/code/src/java/pcgen/core/LanguageList.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/LanguageList.java (rev 0) +++ branches/cdom/code/src/java/pcgen/core/LanguageList.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -0,0 +1,7 @@ +package pcgen.core; + +public class LanguageList extends PObject { + + // No additional Functionality :) + +} Added: branches/cdom/code/src/java/pcgen/core/PCTemplateList.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/PCTemplateList.java (rev 0) +++ branches/cdom/code/src/java/pcgen/core/PCTemplateList.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -0,0 +1,7 @@ +package pcgen.core; + +public class PCTemplateList extends PObject { + + // No additional Functionality :) + +} Added: branches/cdom/code/src/java/pcgen/core/WeaponProfList.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/WeaponProfList.java (rev 0) +++ branches/cdom/code/src/java/pcgen/core/WeaponProfList.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -0,0 +1,7 @@ +package pcgen.core; + +public class WeaponProfList extends PObject { + + // No additional Functionality :) + +} Modified: branches/cdom/code/src/java/pcgen/persistence/GraphContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/GraphContext.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/persistence/GraphContext.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -210,21 +210,20 @@ Class<? extends PrereqObject> cl) { List<PCGraphEdge> outwardEdgeList = graph.getOutwardEdgeList(obj); - if (outwardEdgeList == null) + if (outwardEdgeList != null) { - return; - } - for (PCGraphEdge edge : outwardEdgeList) - { - if (edge.getSourceToken().equals(tokenName)) + for (PCGraphEdge edge : outwardEdgeList) { - for (PrereqObject node : edge.getAdjacentNodes()) + if (edge.getSourceToken().equals(tokenName)) { - if (edge.getNodeInterfaceType(node) == DirectionalEdge.SINK - && node.getClass().equals(cl)) + for (PrereqObject node : edge.getAdjacentNodes()) { - graph.removeEdge(edge); - break; + if (edge.getNodeInterfaceType(node) == DirectionalEdge.SINK + && node.getClass().equals(cl)) + { + graph.removeEdge(edge); + break; + } } } } @@ -234,17 +233,21 @@ public void unlinkChildNode(String tokenName, CDOMObject obj, PrereqObject child) { - for (PCGraphEdge edge : graph.getOutwardEdgeList(obj)) + List<PCGraphEdge> outwardEdgeList = graph.getOutwardEdgeList(obj); + if (outwardEdgeList != null) { - if (edge.getSourceToken().equals(tokenName)) + for (PCGraphEdge edge : outwardEdgeList) { - for (PrereqObject node : edge.getAdjacentNodes()) + if (edge.getSourceToken().equals(tokenName)) { - if (edge.getNodeInterfaceType(node) == DirectionalEdge.SINK - && node.equals(child)) + for (PrereqObject node : edge.getAdjacentNodes()) { - graph.removeEdge(edge); - break; + if (edge.getNodeInterfaceType(node) == DirectionalEdge.SINK + && node.equals(child)) + { + graph.removeEdge(edge); + break; + } } } } @@ -253,16 +256,20 @@ public void unlinkChildNodes(String tokenName, PrereqObject obj) { - for (PCGraphEdge edge : graph.getOutwardEdgeList(obj)) + List<PCGraphEdge> outwardEdgeList = graph.getOutwardEdgeList(obj); + if (outwardEdgeList != null) { - if (edge.getSourceToken().equals(tokenName)) + for (PCGraphEdge edge : outwardEdgeList) { - for (PrereqObject node : edge.getAdjacentNodes()) + if (edge.getSourceToken().equals(tokenName)) { - if (edge.getNodeInterfaceType(node) == DirectionalEdge.SINK) + for (PrereqObject node : edge.getAdjacentNodes()) { - graph.removeEdge(edge); - break; + if (edge.getNodeInterfaceType(node) == DirectionalEdge.SINK) + { + graph.removeEdge(edge); + break; + } } } } @@ -271,16 +278,20 @@ public void unlinkParentNodes(String tokenName, PrereqObject pro) { - for (PCGraphEdge edge : graph.getInwardEdgeList(pro)) + List<PCGraphEdge> inwardEdgeList = graph.getInwardEdgeList(pro); + if (inwardEdgeList != null) { - if (edge.getSourceToken().equals(tokenName)) + for (PCGraphEdge edge : inwardEdgeList) { - for (PrereqObject node : edge.getAdjacentNodes()) + if (edge.getSourceToken().equals(tokenName)) { - if (edge.getNodeInterfaceType(node) == DirectionalEdge.SOURCE) + for (PrereqObject node : edge.getAdjacentNodes()) { - graph.removeEdge(edge); - break; + if (edge.getNodeInterfaceType(node) == DirectionalEdge.SOURCE) + { + graph.removeEdge(edge); + break; + } } } } Modified: branches/cdom/code/src/java/pcgen/persistence/GroupReferenceContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/GroupReferenceContext.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/persistence/GroupReferenceContext.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -38,7 +38,7 @@ public <T extends PObject> CDOMGroupRef<T> getCDOMAllReference(Class<T> c) { - CDOMGroupRef obj = allReferences.get(c); + CDOMGroupRef<T> obj = allReferences.get(c); if (obj == null) { obj = new CDOMAllRef<T>(c); @@ -53,6 +53,10 @@ public <T extends PObject> CDOMGroupRef<T> getCDOMTypeReference(Class<T> c, String... val) { + if (val.length == 0) + { + throw new IllegalArgumentException(); + } for (String s : val) { if (s.length() == 0) @@ -60,6 +64,16 @@ throw new IllegalArgumentException( "Cannot build Reference with empty type"); } + else if (s.indexOf('.') != -1) + { + throw new IllegalArgumentException( + "Cannot build Reference with type conaining a period"); + } + else if (s.indexOf('=') != -1) + { + throw new IllegalArgumentException( + "Cannot build Reference with type conaining an equals"); + } } Arrays.sort(val); Map<String[], CDOMGroupRef> trm = typeReferences.get(c); @@ -81,7 +95,7 @@ } } // Didn't find the appropriate key, create new - CDOMGroupRef cgr = new CDOMTypeRef(c, val); + CDOMGroupRef<T> cgr = new CDOMTypeRef<T>(c, val); trm.put(val, cgr); return cgr; } @@ -99,6 +113,16 @@ throw new IllegalArgumentException( "Cannot build Reference with empty type"); } + else if (s.indexOf('.') != -1) + { + throw new IllegalArgumentException( + "Cannot build Reference with type conaining a period"); + } + else if (s.indexOf('=') != -1) + { + throw new IllegalArgumentException( + "Cannot build Reference with type conaining an equals"); + } } Arrays.sort(val); Map<String[], CDOMGroupRef> trm = categoryTypeRef.get(c, cat); @@ -147,5 +171,4 @@ allReferences.clear(); typeReferences.clear(); } - } Modified: branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/persistence/ReferenceContext.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -51,13 +51,13 @@ return simple.validate() && categorized.validate(); } - public <T extends PObject & CategorizedCDOMObject<T>> CDOMGroupRef<T> getCategorizedCDOMAllReference( + public <T extends PObject & CategorizedCDOMObject<T>> CDOMGroupRef<T> getCDOMAllReference( Class<T> c, Category<T> cat) { return group.getCategorizedCDOMAllReference(c, cat); } - public <T extends PObject & CategorizedCDOMObject<T>> CDOMGroupRef<T> getCategorizedCDOMTypeReference( + public <T extends PObject & CategorizedCDOMObject<T>> CDOMGroupRef<T> getCDOMTypeReference( Class<T> c, Category<T> cat, String... val) { return group.getCategorizedCDOMTypeReference(c, cat, val); @@ -173,5 +173,4 @@ { return categorized.getReferenceManufacturer(c, cat); } - } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/persistence/lst/AddLoader.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -76,8 +76,8 @@ } else { - // FIXME Consume for now - too frequent! - // Logging.errorPrint("Illegal ADD info '" + value + "'"); + Logging.errorPrint("Illegal ADD info '" + value + "'"); + return false; } return true; } Added: branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLoader.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLoader.java (rev 0) +++ branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLoader.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -0,0 +1,125 @@ +/* + * Copyright 2007 (C) Thomas Parker <th...@us...> + * may be derived from a Loader file + * Copyright 2001 (C) Bryan McRoberts <mer...@ya...> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +package pcgen.persistence.lst; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import pcgen.base.util.Logging; +import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.Constants; +import pcgen.core.PObject; +import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; + +public final class RemoveLoader +{ + + private RemoveLoader() + { + super(); + } + + public static boolean parseLine(LoadContext context, PObject obj, + String value) throws PersistenceLayerException + { + Map<String, LstToken> tokenMap = + TokenStore.inst().getTokenMap(RemoveLstToken.class); + + int pipeLoc = value.indexOf(Constants.PIPE); + if (pipeLoc == -1) + { + Logging.errorPrint("REMOVE requires a SubToken"); + return false; + } + String key = value.substring(0, pipeLoc); + RemoveLstToken token = (RemoveLstToken) tokenMap.get(key); + + if (token != null) + { + LstUtils.deprecationCheck(token, obj, value); + if (!token.parse(context, obj, value.substring(pipeLoc + 1))) + { + Logging.errorPrint("Error parsing REMOVE in " + + obj.getDisplayName() + ':' + value); + return false; + } + } + else + { + Logging.errorPrint("Illegal REMOVE info '" + value + "'"); + return false; + } + return true; + } + + /** + * This method is static so it can be used by the REMOVE Token. + * + * @param target + * @param lstLine + * @param source + * @throws PersistenceLayerException + */ + public static boolean parseLine(PObject target, String key, String value, + int level) + { + Map<String, LstToken> tokenMap = + TokenStore.inst().getTokenMap(RemoveLstToken.class); + RemoveLstToken token = (RemoveLstToken) tokenMap.get(key); + if (token != null) + { + LstUtils.deprecationCheck(token, target, value); + if (!token.parse(target, value, level)) + { + Logging + .errorPrint("Error parsing REMOVE: " + key + ":" + value); + return false; + } + return true; + } + else + { + Logging + .errorPrint("Error parsing REMOVE, invalid SubToken: " + key); + return false; + } + } + + public static String[] unparse(LoadContext context, CDOMObject obj) + { + List<String> list = new ArrayList<String>(); + for (LstToken token : TokenStore.inst().getTokenMap( + RemoveLstToken.class).values()) + { + String[] s = + ((RemoveLstToken) token).unparse(context, (PObject) obj); + if (s != null) + { + for (String aString : s) + { + list.add(token.getTokenName() + "|" + aString); + } + } + } + return list.size() == 0 ? null : list.toArray(new String[list.size()]); + } +} Added: branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLstToken.java (rev 0) +++ branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLstToken.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -0,0 +1,30 @@ +/* + * Copyright 2007 (C) Thomas Parker <th...@us...> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +package pcgen.persistence.lst; + +import pcgen.core.PObject; + +/** + * <code>AutoLstToken</code> + * + * @author Thomas Parker <th...@us...> + */ +public interface RemoveLstToken extends CDOMToken<PObject> +{ + public boolean parse(PObject target, String value, int level); +} Modified: branches/cdom/code/src/java/pcgen/persistence/lst/TokenStore.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/TokenStore.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/persistence/lst/TokenStore.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -122,6 +122,7 @@ //subtokens tokenTypeList.add(AutoLstToken.class); tokenTypeList.add(AddLstToken.class); + tokenTypeList.add(RemoveLstToken.class); } /** Modified: branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/pcgen/persistence/lst/utils/TokenUtilities.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -107,19 +107,6 @@ // Can't instantiate utility classes } - public static <T extends PObject> CDOMReference<T> getObjectReference( - LoadContext context, Class<T> cl, String s) - { - if (Constants.LST_ALL.equals(s)) - { - return context.ref.getCDOMAllReference(cl); - } - else - { - return getTypeOrPrimitive(context, cl, s); - } - } - public static <T extends PObject> CDOMReference<T> getTypeOrPrimitive( LoadContext context, Class<T> cl, String s) { @@ -171,14 +158,10 @@ return dr; } - public static <T extends PObject & CategorizedCDOMObject<T>> CDOMReference<T> getObjectReference( + public static <T extends PObject & CategorizedCDOMObject<T>> CDOMReference<T> getTypeOrPrimitive( LoadContext context, Class<T> cl, Category<T> cat, String s) { - if (Constants.LST_ALL.equals(s)) - { - return context.ref.getCategorizedCDOMAllReference(cl, cat); - } - else if (s.startsWith(Constants.LST_TYPE_OLD) + if (s.startsWith(Constants.LST_TYPE_OLD) || s.startsWith(Constants.LST_TYPE)) { String subStr = s.substring(5); @@ -207,7 +190,7 @@ return null; } } - return context.ref.getCategorizedCDOMTypeReference(cl, cat, types); + return context.ref.getCDOMTypeReference(cl, cat, types); } else { Modified: branches/cdom/code/src/java/plugin/lsttokens/AbilityLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/AbilityLst.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/plugin/lsttokens/AbilityLst.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -23,23 +23,25 @@ */ package plugin.lsttokens; -import java.io.StringWriter; import java.util.ArrayList; -import java.util.HashSet; import java.util.List; import java.util.Set; +import java.util.SortedSet; import java.util.StringTokenizer; +import java.util.TreeSet; +import pcgen.base.util.DoubleKeyMapToList; import pcgen.base.util.Logging; -import pcgen.base.util.TripleKeyMapToList; import pcgen.cdom.base.CDOMCategorizedSingleRef; import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CategorizedCDOMReference; +import pcgen.cdom.base.Category; +import pcgen.cdom.enumeration.AbilityCategory; import pcgen.cdom.enumeration.AbilityNature; import pcgen.cdom.enumeration.AssociationKey; import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.graph.PCGraphGrantsEdge; import pcgen.core.Ability; -import pcgen.core.AbilityCategory; import pcgen.core.Constants; import pcgen.core.PCClass; import pcgen.core.PObject; @@ -50,8 +52,8 @@ import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.GlobalLstToken; -import pcgen.persistence.lst.output.prereq.PrerequisiteWriter; import pcgen.persistence.lst.prereq.PreParserFactory; +import pcgen.persistence.lst.utils.TokenUtilities; import pcgen.util.PropertyFactory; /** @@ -116,7 +118,7 @@ final StringTokenizer tok = new StringTokenizer(aValue, Constants.PIPE); final String cat = tok.nextToken(); - final AbilityCategory category = + final pcgen.core.AbilityCategory category = SettingsHandler.getGame().getAbilityCategory(cat); if (category == null) { @@ -197,94 +199,86 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { - StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); - - if (!tok.hasMoreTokens()) + if (value.length() == 0) { + Logging.errorPrint(getTokenName() + " may not have empty argument"); return false; } + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } - pcgen.cdom.enumeration.AbilityCategory abCat; + final StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); + + AbilityCategory ac; + String cat = tok.nextToken(); try { - String cat = tok.nextToken(); - abCat = pcgen.cdom.enumeration.AbilityCategory.valueOf(cat); + ac = AbilityCategory.valueOf(cat); } - catch (IllegalArgumentException iae) + catch (IllegalArgumentException e) { + Logging.errorPrint(getTokenName() + + " refers to invalid Ability Category: " + cat); return false; } if (!tok.hasMoreTokens()) { - // TODO This is the second test of this - should just countTokens()? - // What is faster? + Logging + .errorPrint(getTokenName() + + " must have a Nature, Format is: CATEGORY|NATURE|AbilityName: " + + value); return false; } - AbilityNature nature; + String natureKey = tok.nextToken(); + AbilityNature an; try { - String natureKey = tok.nextToken(); - nature = AbilityNature.valueOf(natureKey); + an = AbilityNature.valueOf(natureKey); } - catch (IllegalArgumentException iae) + catch (IllegalArgumentException e) { + Logging.errorPrint(getTokenName() + + " refers to invalid Ability Category: " + natureKey); return false; } if (!tok.hasMoreTokens()) { - // TODO This is the second test of this - should just countTokens()? - // What is faster? + Logging + .errorPrint(getTokenName() + + " must have abilities, Format is: CATEGORY|NATURE|AbilityName: " + + value); return false; } - List<PCGraphGrantsEdge> edgeList = new ArrayList<PCGraphGrantsEdge>(); - - String token = tok.nextToken(); - while (true) + while (tok.hasMoreTokens()) { CDOMCategorizedSingleRef<Ability> ability = - context.ref.getCDOMReference(ABILITY_CLASS, abCat, token); + context.ref.getCDOMReference(ABILITY_CLASS, ac, tok + .nextToken()); PCGraphGrantsEdge edge = context.graph.linkObjectIntoGraph(getTokenName(), obj, ability); - edge.setAssociation(AssociationKey.ABILITY_NATURE, nature); - edgeList.add(edge); - - if (!tok.hasMoreTokens()) - { - // No prereqs, so we're done - return true; - } - token = tok.nextToken(); - if (token.startsWith("PRE") || token.startsWith("!PRE")) - { - break; - } + edge.setAssociation(AssociationKey.ABILITY_NATURE, an); } - - while (true) - { - Prerequisite prereq = getPrerequisite(token); - if (prereq == null) - { - Logging.errorPrint(" (Did you put abilities after the " - + "PRExxx tags in ABILITY:?)"); - return false; - } - for (PCGraphGrantsEdge edge : edgeList) - { - edge.addPrerequisite(prereq); - } - if (!tok.hasMoreTokens()) - { - break; - } - token = tok.nextToken(); - } - return true; } @@ -298,58 +292,39 @@ { return null; } - TripleKeyMapToList<AbilityNature, String, Set<Prerequisite>, Ability> m = - new TripleKeyMapToList<AbilityNature, String, Set<Prerequisite>, Ability>(); + DoubleKeyMapToList<AbilityNature, Category<Ability>, CDOMCategorizedSingleRef<Ability>> m = + new DoubleKeyMapToList<AbilityNature, Category<Ability>, CDOMCategorizedSingleRef<Ability>>(); for (PCGraphEdge edge : edgeSet) { AbilityNature nature = edge.getAssociation(AssociationKey.ABILITY_NATURE); - Ability ab = (Ability) edge.getSinkNodes().get(0); - m.addToListFor(nature, ab.getCategory(), new HashSet<Prerequisite>( - edge.getPrerequisiteList()), ab); + CDOMCategorizedSingleRef<Ability> ab = + (CDOMCategorizedSingleRef<Ability>) edge.getSinkNodes() + .get(0); + m.addToListFor(nature, ab.getCDOMCategory(), ab); } - PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); - List<String> list = new ArrayList<String>(); + SortedSet<CategorizedCDOMReference<Ability>> set = + new TreeSet<CategorizedCDOMReference<Ability>>( + TokenUtilities.CAT_REFERENCE_SORTER); + Set<String> returnSet = new TreeSet<String>(); for (AbilityNature nature : m.getKeySet()) { - for (String category : m.getSecondaryKeySet(nature)) + for (Category<Ability> category : m.getSecondaryKeySet(nature)) { - for (Set<Prerequisite> prereqs : m.getTertiaryKeySet(nature, - category)) + StringBuilder sb = new StringBuilder(); + sb.append(category).append(Constants.PIPE); + sb.append(nature); + set.clear(); + set.addAll(m.getListFor(nature, category)); + for (CategorizedCDOMReference<Ability> a : set) { - StringBuilder sb = new StringBuilder(); - sb.append(category).append(Constants.PIPE); - sb.append(nature); - for (Ability a : m.getListFor(nature, category, prereqs)) - { - sb.append(Constants.PIPE).append(a.getKeyName()); - } - if (prereqs != null && !prereqs.isEmpty()) - { - for (Prerequisite p : prereqs) - { - StringWriter swriter = new StringWriter(); - try - { - prereqWriter.write(swriter, p); - } - catch (PersistenceLayerException e) - { - context - .addWriteMessage("Error writing Prerequisite: " - + e); - return null; - } - sb.append(Constants.PIPE) - .append(swriter.toString()); - } - } - list.add(sb.toString()); + sb.append(Constants.PIPE).append(a.getLSTformat()); } + returnSet.add(sb.toString()); } } - return list.toArray(new String[list.size()]); + return returnSet.toArray(new String[returnSet.size()]); } } Modified: branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/plugin/lsttokens/CcskillLst.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -29,7 +29,6 @@ import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; -import pcgen.cdom.base.PrereqObject; import pcgen.cdom.enumeration.AssociationKey; import pcgen.cdom.enumeration.SkillCost; import pcgen.cdom.graph.PCGraphAllowsEdge; @@ -90,27 +89,48 @@ + " arguments uses double separator || : " + value); return false; } + + boolean foundAny = false; + boolean foundOther = false; + StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); + boolean first = true; + while (tok.hasMoreTokens()) { String tokText = tok.nextToken(); - if (Constants.LST_CLEAR.equals(tokText)) + if (Constants.LST_DOT_CLEAR.equals(tokText)) { + if (!first) + { + Logging.errorPrint(" Non-sensical " + getTokenName() + + ": .CLEAR was not the first list item"); + return false; + } context.graph.unlinkChildNodesOfClass(getTokenName(), obj, SKILL_CLASS); } else if (tokText.startsWith(Constants.LST_DOT_CLEAR_DOT)) { - PrereqObject skill = - TokenUtilities.getObjectReference(context, SKILL_CLASS, - tokText.substring(7)); - if (skill == null) + CDOMReference<Skill> ref; + String clearText = tokText.substring(7); + if (Constants.LST_ALL.equals(clearText)) { + ref = context.ref.getCDOMAllReference(SKILL_CLASS); + } + else + { + ref = + TokenUtilities.getTypeOrPrimitive(context, + SKILL_CLASS, clearText); + } + if (ref == null) + { Logging.errorPrint(" Error was encountered while parsing " + getTokenName()); return false; } - context.graph.unlinkChildNode(getTokenName(), obj, skill); + context.graph.unlinkChildNode(getTokenName(), obj, ref); } else { @@ -120,22 +140,39 @@ * C/CC Skill object and therefore doesn't know how to search * the sublists */ - PrereqObject skill = - TokenUtilities.getObjectReference(context, SKILL_CLASS, - tokText); - if (skill == null) + CDOMReference<Skill> ref; + if (Constants.LST_ALL.equals(tokText)) { + foundAny = true; + ref = context.ref.getCDOMAllReference(SKILL_CLASS); + } + else + { + foundOther = true; + ref = + TokenUtilities.getTypeOrPrimitive(context, + SKILL_CLASS, tokText); + } + if (ref == null) + { Logging.errorPrint(" Error was encountered while parsing " + getTokenName()); return false; } PCGraphAllowsEdge edge = context.graph.linkAllowIntoGraph(getTokenName(), obj, - skill); + ref); edge.setAssociation(AssociationKey.SKILL_COST, SkillCost.CROSS_CLASS); } + first = false; } + if (foundAny && foundOther) + { + Logging.errorPrint("Non-sensical " + getTokenName() + + ": Contains ANY and a specific reference: " + value); + return false; + } return true; } Modified: branches/cdom/code/src/java/plugin/lsttokens/ChangeprofLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/ChangeprofLst.java 2007-04-28 18:54:15 UTC (rev 2814) +++ branches/cdom/code/src/java/plugin/lsttokens/ChangeprofLst.java 2007-04-28 19:17:29 UTC (rev 2815) @@ -22,9 +22,14 @@ */ package plugin.lsttokens; +import java.util.ArrayList; +import java.util.List; import java.util.Set; +import java.util.SortedSet; import java.util.StringTokenizer; +import java.util.TreeSet; +import pcgen.base.lang.StringUtil; import pcgen.base.util.HashMapToList; import pcgen.base.util.Logging; import pcgen.cdom.base.CDOMGroupRef; @@ -38,6 +43,7 @@ import pcgen.persistence.LoadContext; import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.GlobalLstToken; +import pcgen.persistence.lst.utils.TokenUtilities; /** * @author djones4 @@ -90,12 +96,36 @@ public boolean parse(LoadContext context, CDOMObject obj, String value) { + if (value.length() == 0) + { + Logging.errorPrint(getTokenName() + " arguments may not be empty"); + return false; + } + if (value.charAt(0) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not start with | : " + value); + return false; + } + if (value.charAt(value.length() - 1) == '|') + { + Logging.errorPrint(getTokenName() + + " arguments may not end with | : " + value); + return false; + } + if (value.indexOf("||") != -1) + { + Logging.errorPrint(getTokenName() + + " arguments uses double separator || : " + value); + return false; + } // value should be of the format: // Name1,TYPE.type1,Name3=Prof1|Name4,Name5=Prof2 // // e.g.: TYPE.Hammer,Hand Axe=Simple|Urgosh,Waraxe=Martial StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); + List<ChangeProf> list = new ArrayList<ChangeProf>(); while (tok.hasMoreTokens()) { @@ -104,42 +134,61 @@ if (equalLoc < 0) { Logging.errorPrint("Improper " + getTokenName() - + ": Expect format to be <Prof>,<Prof>=<Prof Type>."); + + ": No = found. " + + "Expect format to be <Prof>,<Prof>=<Prof Type>"); Logging.errorPrint(" Token was: " + tokText); Logging.errorPrint(" Tag was: " + value); return false; } + else if (equalLoc != tokText.lastIndexOf('=')) + { + Logging.errorPrint("Improper " + getTokenName() + + ": Two = found. " + + "Expect format to be <Prof>,<Prof>=<Prof Type>"); + Logging.errorPrint(" Token was: " + tokText); + Logging.errorPrint(" Tag was: " + value); + return false; + } String newType = tokText.substring(equalLoc + 1); + if (newType.length() == 0) + { + Logging.errorPrint("Improper " + getTokenName() + + ": Empty Result Type. " + + "Expect format to be <Prof>,<Prof>=<Prof Type>"); + Logging.errorPrint(" Token was: " + tokText); + Logging.errorPrint(" Tag was: " + value); + return false; + } String[] val = {newType}; CDOMGroupRef<WeaponProf> newTypeProf = context.ref.getCDOMTypeReference(WEAPONPROF_CLASS, val); String profs = tokText.substring(0, equalLoc); + if (profs.length() == 0) + { + Logging.errorPrint("Improper " + getTokenName() + + ": Empty Source Prof. " + + "Expect format to be <Prof>,<Prof>=<Prof Type>"); + Logging.errorPrint(" Token was: " + tokText); + Logging.errorPrint(" Tag was: " + value); + return false; + } StringTokenizer pTok = new StringTokenizer(profs, Constants.COMMA); while (pTok.hasMoreTokens()) { - CDOMReference<WeaponProf> wp; - if (tokText.startsWith(Constants.LST_TYPE) - || tokText.startsWith(Constants.LST_TYPE_OLD)) - { - String[... [truncated message content] |
From: <th...@us...> - 2007-05-21 02:45:24
|
Revision: 2979 http://svn.sourceforge.net/pcgen/?rev=2979&view=rev Author: thpr Date: 2007-05-20 19:44:37 -0700 (Sun, 20 May 2007) Log Message: ----------- CDOM: First set of PrerequisiteTester updates Modified Paths: -------------- branches/cdom/code/src/java/pcgen/core/prereq/PrerequisiteTest.java branches/cdom/code/src/java/plugin/pretokens/test/PreStatTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreSubClassTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreTemplateTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreTextTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreTypeTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreVisionTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreWeaponProfTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreWieldTester.java Added Paths: ----------- branches/cdom/code/src/utest/plugin/pretokens/ branches/cdom/code/src/utest/plugin/pretokens/test/ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java branches/cdom/code/src/utest/plugin/pretokens/test/PreStatTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSubClassTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreTemplateTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreTextTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreTypeTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreVisionTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreWeaponProfTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreWieldTesterTest.java Modified: branches/cdom/code/src/java/pcgen/core/prereq/PrerequisiteTest.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/prereq/PrerequisiteTest.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/pcgen/core/prereq/PrerequisiteTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -37,4 +37,6 @@ public int passes(Prerequisite prereq, Equipment equipment, PlayerCharacter aPC) throws PrerequisiteException; public String toHtmlString(Prerequisite prereq); public String kindHandled(); + + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException; } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreStatTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreStatTester.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreStatTester.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -26,9 +26,12 @@ */ package plugin.pretokens.test; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.core.PCStat; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; import pcgen.util.PropertyFactory; @@ -74,4 +77,14 @@ "PreStat.toHtml", prereq.getKey(), prereq.getOperator().toString(), prereq.getOperand()); //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int targetNumber = Integer.parseInt(prereq.getOperand()); + PCGenGraph graph = character.getActiveGraph(); + PCStat stat = graph.getGrantedNode(PCStat.class, prereq.getKey()); + int statVal = character.getTotalWeight(stat); + int runningTotal = prereq.getOperator().compare(statVal, targetNumber); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSubClassTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSubClassTester.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSubClassTester.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -26,8 +26,12 @@ */ package plugin.pretokens.test; +import java.util.List; + +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PCClass; import pcgen.core.PlayerCharacter; +import pcgen.core.SubClass; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; import pcgen.core.prereq.PrerequisiteException; @@ -87,4 +91,35 @@ return "SUBCLASS"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal = 0; + int num; + try + { + num = Integer.parseInt(prereq.getOperand()); // number we must match + } + catch (NumberFormatException nfe) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreSubClass.error.badly_formed", prereq.toString())); //$NON-NLS-1$ + } + + String requiredClass = prereq.getKey(); + PCGenGraph activeGraph = character.getActiveGraph(); + List<SubClass> list = activeGraph.getGrantedNodeList(SubClass.class); + for (SubClass cl : list) + { + String subClassName = cl.getKeyName(); + if (requiredClass.equalsIgnoreCase(subClassName)) + { + runningTotal++; + break; + } + } + + runningTotal = prereq.getOperator().compare(runningTotal, num); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreTemplateTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreTemplateTester.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreTemplateTester.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -26,6 +26,9 @@ */ package plugin.pretokens.test; +import java.util.List; + +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PCTemplate; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; @@ -64,7 +67,6 @@ if (!character.getTemplateList().isEmpty()) { - String templateKey = prereq.getKey().toUpperCase(); final int wildCard = templateKey.indexOf('%'); //handle wildcards (always assume they end the line) @@ -97,4 +99,52 @@ return "TEMPLATE"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal = 0; + + final int number; + try + { + number = Integer.parseInt(prereq.getOperand()); + } + catch (NumberFormatException exceptn) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreTemplate.error", prereq.toString())); //$NON-NLS-1$ + } + + PCGenGraph activeGraph = character.getActiveGraph(); + List<PCTemplate> list = + activeGraph.getGrantedNodeList(PCTemplate.class); + + if (!list.isEmpty()) + { + String templateKey = prereq.getKey().toUpperCase(); + int wildCard = templateKey.indexOf('%'); + //handle wildcards (always assume they end the line) + if (wildCard >= 0) + { + templateKey = templateKey.substring(0, wildCard); + for (PCTemplate aTemplate : list) + { + if (aTemplate.getKeyName().toUpperCase().startsWith( + templateKey)) + { + runningTotal++; + } + } + } + else + { + if (activeGraph.containsGranted(PCTemplate.class, templateKey)) + { + runningTotal++; + } + } + } + runningTotal = prereq.getOperator().compare(runningTotal, number); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreTextTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreTextTester.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreTextTester.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -29,6 +29,7 @@ import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteOperator; import pcgen.core.prereq.PrerequisiteTest; @@ -65,4 +66,17 @@ return "TEXT"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + // PRETEXT: is a flavor text string that needs + // to be displayed in the GUI, but the PC + // should always be qualified to take it, as + // it's a DM call/issue + if (prereq.getOperator().equals(PrerequisiteOperator.NEQ)) + { + return countedTotal(prereq, 0); + } + return countedTotal(prereq, 1); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreTypeTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreTypeTester.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreTypeTester.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -127,4 +127,9 @@ "PreType.toHtml", prereq.getOperator().toDisplayString(), prereq.getKey()); //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + throw new UnsupportedOperationException("PRETYPE is not a PC Prereq"); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreVisionTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreVisionTester.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreVisionTester.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -26,10 +26,12 @@ */ package plugin.pretokens.test; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PlayerCharacter; import pcgen.core.Vision; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; import pcgen.util.enumeration.VisionType; @@ -75,4 +77,26 @@ return "VISION"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + final int requiredRange = Integer.parseInt(prereq.getOperand()); + int runningTotal = 0; + VisionType requiredVisionType = + VisionType.getVisionType(prereq.getKey()); + + PCGenGraph activeGraph = character.getActiveGraph(); + + for (Vision charVision : activeGraph.getGrantedNodeList(Vision.class)) + { + if (charVision.getType().equals(requiredVisionType)) + { + int visionRange = Integer.parseInt(charVision.getDistance()); + runningTotal += + prereq.getOperator() + .compare(visionRange, requiredRange); + } + } + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreWeaponProfTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreWeaponProfTester.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreWeaponProfTester.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -26,6 +26,11 @@ */ package plugin.pretokens.test; +import java.util.List; + +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.Equipment; import pcgen.core.EquipmentList; import pcgen.core.PlayerCharacter; @@ -142,4 +147,71 @@ return "WEAPONPROF"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal = 0; + + final int number; + try + { + number = Integer.parseInt(prereq.getOperand()); + } + catch (NumberFormatException exceptn) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreFeat.error", prereq.toString())); //$NON-NLS-1$ + } + + PCGenGraph activeGraph = character.getActiveGraph(); + final String aString = prereq.getKey(); + if ("DEITYWEAPON".equals(aString) && character.getDeity() != null) //$NON-NLS-1$ + { + for (String weaponKey : CoreUtility.split(character.getDeity() + .getFavoredWeapon(), '|')) + { + if (activeGraph.containsGranted(WeaponProf.class, weaponKey)) + { + runningTotal++; + } + } + } + else if (aString.startsWith("TYPE.") || aString.startsWith("TYPE=")) //$NON-NLS-1$ //$NON-NLS-2$ + { + Type requiredType = Type.getConstant(aString.substring(5)); + List<WeaponProf> list = + activeGraph.getGrantedNodeList(WeaponProf.class); + if (list != null) + { + for (WeaponProf wp : list) + { + if (wp.containsInList(ListKey.TYPE, requiredType)) + { + runningTotal++; + } + else + { + final Equipment eq = + EquipmentList.getEquipmentNamed(wp.getKeyName()); + if (eq != null) + { + if (eq.containsInList(ListKey.TYPE, requiredType)) + { + runningTotal++; + } + } + } + } + } + } + else + { + if (activeGraph.containsGranted(WeaponProf.class, aString)) + { + runningTotal++; + } + } + runningTotal = prereq.getOperator().compare(runningTotal, number); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreWieldTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreWieldTester.java 2007-05-21 00:11:21 UTC (rev 2978) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreWieldTester.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -28,6 +28,7 @@ import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; /** @@ -62,4 +63,10 @@ { return "WIELD"; //$NON-NLS-1$ } + + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + throw new UnsupportedOperationException("PREWIELD is not a PC Prereq"); + } } Added: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,402 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public abstract class AbstractCDOMObjectTestCase<T extends PObject> extends + AbstractCDOMPreTestTestCase<T> +{ + + public Prerequisite getAnyPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("ANY"); + p.setOperand("2"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getSimplePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Winged Mage"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getWildcard() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Wild%"); + p.setOperand("2"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getCountTemplates() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("%"); + p.setOperand("2"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getGenericPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Crossbow"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getParenPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Crossbow (Heavy)"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTypeDotPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("TYPE.Exotic"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTypeEqualsPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("TYPE=Martial"); + p.setOperand("2"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public abstract String getKind(); + + public abstract PrerequisiteTest getTest(); + + public abstract boolean isWildcardLegal(); + + public abstract boolean isTypeLegal(); + + public abstract boolean isAnyLegal(); + + @Test + public void testInvalidCount() + { + Prerequisite prereq = getSimplePrereq(); + prereq.setOperand("x"); + try + { + getTest().passesCDOM(prereq, pc); + fail(); + } + catch (PrerequisiteException pe) + { + // OK (operand should be a number) + } + } + + @Test + public void testAny() throws PrerequisiteException + { + if (isAnyLegal()) + { + Prerequisite prereq = getAnyPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Winged Mage"); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + assertEquals(0, getTest().passesCDOM(getParenPrereq(), pc)); + } + } + + @Test + public void testFalseAny() throws PrerequisiteException + { + if (isAnyLegal()) + { + Prerequisite prereq = getAnyPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantFalseObject("Winged Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + assertEquals(0, getTest().passesCDOM(getParenPrereq(), pc)); + } + } + + @Test + public void testSimple() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Winged Mage"); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + assertEquals(0, getTest().passesCDOM(getParenPrereq(), pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantFalseObject("Winged Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testParen() throws PrerequisiteException + { + Prerequisite prereq = getParenPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Crossbow (Heavy)"); + // Has Crossbow (Heavy) + assertEquals(1, getTest().passesCDOM(prereq, pc)); + // But not Katana + assertEquals(0, getTest().passesCDOM(getSimplePrereq(), pc)); + // And not Generic Crossbow + assertEquals(0, getTest().passesCDOM(getGenericPrereq(), pc)); + } + + @Test + public void testWildcard() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getWildcard(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Winged Creature"); + // Still at zero qualifying + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + // Not enough + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Beast"); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testFalseWildcard() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getWildcard(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Winged Creature"); + // Still at zero qualifying + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + // Not enough + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantFalseObject("Wild Beast"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testCount() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getCountTemplates(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Winged Creature"); + // Still at zero qualifying + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + // enough + assertEquals(1, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Beast"); + // more than enough + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testFalseCount() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getCountTemplates(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Winged Creature"); + // Still at zero qualifying + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantFalseObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeDot() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getTypeDotPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = grantCDOMObject("Katana"); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Test having multiple types + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testFalseTypeDot() throws PrerequisiteException + { + if (isTypeLegal()) + { + + Prerequisite prereq = getTypeDotPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = grantFalseObject("Katana"); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + // Would be 1 if true + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Would be 1 if true + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeEqual() throws PrerequisiteException + { + if (isTypeLegal()) + { + + Prerequisite prereq = getTypeEqualsPrereq(); + // PC Should start without the WeaponProf + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = grantCDOMObject("Katana"); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Fails because only one is present + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject sword = grantCDOMObject("Longsword"); + sword.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Test with WP having multiple types + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testFalseTypeEqual() throws PrerequisiteException + { + if (isTypeLegal()) + { + + Prerequisite prereq = getTypeEqualsPrereq(); + // PC Should start without the WeaponProf + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = grantCDOMObject("Katana"); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Fails because only one is present + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject sword = grantFalseObject("Longsword"); + sword.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Would be 1 if true + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Would be 1 if true + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + } +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import junit.framework.TestCase; + +import org.junit.Before; + +import pcgen.cdom.base.PrereqObject; +import pcgen.cdom.enumeration.StringKey; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.core.PObject; +import pcgen.core.PlayerCharacter; + +public abstract class AbstractCDOMPreTestTestCase<T extends PObject> extends + TestCase +{ + + PlayerCharacter pc; + + @Override + @Before + public void setUp() + { + pc = new PlayerCharacter(false); + } + + public abstract Class<T> getCDOMClass(); + + public abstract Class<? extends PObject> getFalseClass(); + + public <TT extends PObject> TT getObject(Class<TT> cl, String s) + { + TT obj; + try + { + obj = cl.newInstance(); + obj.setKeyName(s); + obj.put(StringKey.NAME, s); + return obj; + } + catch (InstantiationException e) + { + fail(e.getLocalizedMessage()); + } + catch (IllegalAccessException e) + { + fail(e.getLocalizedMessage()); + } + return null; + } + + public PObject getFalseObject(String s) + { + return getObject(getFalseClass(), s); + } + + public T getObject(String s) + { + return getObject(getCDOMClass(), s); + } + + public PCGraphGrantsEdge grantObject(PObject obj) + { + PCGenGraph graph = pc.getActiveGraph(); + PrereqObject root = graph.getRoot(); + graph.addNode(obj); + PCGraphGrantsEdge edge = new PCGraphGrantsEdge(root, obj, "TestCase"); + graph.addEdge(edge); + return edge; + } + + public PObject grantCDOMObject(String s) + { + T object = getObject(s); + grantObject(object); + return object; + } + + public PObject grantFalseObject(String s) + { + PObject object = getFalseObject(s); + grantObject(object); + return object; + } +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreStatTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreStatTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreStatTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.core.Language; +import pcgen.core.PCStat; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreStatTesterTest extends AbstractCDOMPreTestTestCase<PCStat> +{ + + PreStatTester tester = new PreStatTester(); + + @Override + public Class<PCStat> getCDOMClass() + { + return PCStat.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + public String getKind() + { + return "STAT"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public Prerequisite getSimplePrereq(String stat, int val) + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey(stat); + p.setOperand(Integer.toString(val)); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getNoOperatorPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("INT"); + p.setOperand("15"); + return p; + } + + @Test + public void testSimple() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq("STR", 15); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PCStat strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PCStat intStat = getObject("INT"); + PCGraphGrantsEdge intEdge = grantObject(intStat); + intEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); + // Fail, no weight on str edge (still) + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + // Fail, not enough weight on edge + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); + // Pass, exact value + assertEquals(1, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(16)); + // Pass, more than enough + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSubClassTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSubClassTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSubClassTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.Language; +import pcgen.core.PObject; +import pcgen.core.SubClass; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSubClassTesterTest extends AbstractCDOMObjectTestCase<SubClass> +{ + + PreSubClassTester tester = new PreSubClassTester(); + + @Override + public Class<SubClass> getCDOMClass() + { + return SubClass.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "SUBCLASS"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isWildcardLegal() + { + return false; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Override + public boolean isAnyLegal() + { + return false; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreTemplateTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreTemplateTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreTemplateTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.Language; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreTemplateTesterTest extends + AbstractCDOMObjectTestCase<PCTemplate> +{ + + PreTemplateTester tester = new PreTemplateTester(); + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "TEMPLATE"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isWildcardLegal() + { + return true; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Override + public boolean isAnyLegal() + { + return false; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreTextTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreTextTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreTextTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.core.PlayerCharacter; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; + +public class PreTextTesterTest extends TestCase +{ + + Prerequisite p; + PreTextTester tester = new PreTextTester(); + PlayerCharacter pc = new PlayerCharacter(false); + + @Override + @Before + public void setUp() + { + p = new Prerequisite(); + p.setKind("TEXT"); + p.setOperand("PC must be of noble birth"); + } + + @Test + public void testTester() throws PrerequisiteException + { + assertEquals(1, tester.passesCDOM(p, pc)); + } +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreTypeTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreTypeTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreTypeTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.core.PlayerCharacter; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; + +public class PreTypeTesterTest extends TestCase +{ + + Prerequisite p; + PreTypeTester tester = new PreTypeTester(); + PlayerCharacter pc = new PlayerCharacter(false); + + @Override + @Before + public void setUp() + { + p = new Prerequisite(); + p.setKind("TYPE"); + p.setOperand("Martial"); + } + + @Test + //(expected = UnsupportedOperationException.class) + public void testPCInvalid() throws PrerequisiteException + { + try + { + tester.passesCDOM(p, pc); + fail("Expected PRETYPE to be invalid for a PC"); + } + catch (UnsupportedOperationException e) + { + // OK + } + } +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreVisionTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreVisionTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreVisionTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import junit.framework.TestCase; + +import org.junit.Test; + +import pcgen.cdom.base.PrereqObject; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.core.PlayerCharacter; +import pcgen.core.Vision; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; + +public class PreVisionTesterTest extends TestCase +{ + + PreVisionTester tester = new PreVisionTester(); + + public Prerequisite getSimplePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind("VISION"); + p.setKey("Normal"); + p.setOperand("30"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getSpecialPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind("VISION"); + p.setKey("Darkvision"); + p.setOperand("20"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testSimpleEqual() throws PrerequisiteException + { + PlayerCharacter pc = new PlayerCharacter(false); + // PC Should start without + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + PCGenGraph graph = pc.getActiveGraph(); + PrereqObject root = graph.getRoot(); + Vision v1 = Vision.getVision("Normal (30')"); + graph.addNode(v1); + graph.addEdge(new PCGraphGrantsEdge(root, v1, "TestCase")); + assertEquals(1, tester.passesCDOM(this.getSimplePrereq(), pc)); + assertEquals(0, tester.passesCDOM(this.getSpecialPrereq(), pc)); + } + + @Test + public void testSimpleLess() throws PrerequisiteException + { + PlayerCharacter pc = new PlayerCharacter(false); + // PC Should start without + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + PCGenGraph graph = pc.getActiveGraph(); + PrereqObject root = graph.getRoot(); + Vision v1 = Vision.getVision("Normal (20')"); + graph.addNode(v1); + graph.addEdge(new PCGraphGrantsEdge(root, v1, "TestCase")); + // Has, but not sufficient distance + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + // No Darkvision + assertEquals(0, tester.passesCDOM(this.getSpecialPrereq(), pc)); + } + + @Test + public void testSimpleGreater() throws PrerequisiteException + { + PlayerCharacter pc = new PlayerCharacter(false); + // PC Should start without + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + PCGenGraph graph = pc.getActiveGraph(); + PrereqObject root = graph.getRoot(); + Vision v1 = Vision.getVision("Normal (40')"); + graph.addNode(v1); + graph.addEdge(new PCGraphGrantsEdge(root, v1, "TestCase")); + // Has + assertEquals(1, tester.passesCDOM(this.getSimplePrereq(), pc)); + // No Darkvision + assertEquals(0, tester.passesCDOM(this.getSpecialPrereq(), pc)); + } + + @Test + public void testTwoVisionEqual() throws PrerequisiteException + { + PlayerCharacter pc = new PlayerCharacter(false); + // PC Should start without + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + PCGenGraph graph = pc.getActiveGraph(); + PrereqObject root = graph.getRoot(); + Vision v2 = Vision.getVision("Darkvision (30')"); + graph.addNode(v2); + graph.addEdge(new PCGraphGrantsEdge(root, v2, "TestCase")); + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + Vision v1 = Vision.getVision("Normal (30')"); + graph.addNode(v1); + graph.addEdge(new PCGraphGrantsEdge(root, v1, "TestCase")); + assertEquals(1, tester.passesCDOM(this.getSimplePrereq(), pc)); + } + + @Test + public void testVisionTwiceLess() throws PrerequisiteException + { + PlayerCharacter pc = new PlayerCharacter(false); + // PC Should start without + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + PCGenGraph graph = pc.getActiveGraph(); + PrereqObject root = graph.getRoot(); + Vision v1 = Vision.getVision("Normal (10')"); + graph.addNode(v1); + graph.addEdge(new PCGraphGrantsEdge(root, v1, "TestCase")); + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + Vision v2 = Vision.getVision("Normal (20')"); + graph.addNode(v2); + graph.addEdge(new PCGraphGrantsEdge(root, v2, "TestCase")); + // Make sure it's not being additive (e.g. 10 + 20) + assertEquals(0, tester.passesCDOM(this.getSimplePrereq(), pc)); + Vision v3 = Vision.getVision("Normal (30')"); + graph.addNode(v3); + graph.addEdge(new PCGraphGrantsEdge(root, v3, "TestCase")); + assertEquals(1, tester.passesCDOM(this.getSimplePrereq(), pc)); + Vision v4 = Vision.getVision("Normal (15')"); + graph.addNode(v4); + graph.addEdge(new PCGraphGrantsEdge(root, v4, "TestCase")); + // Make sure it's not grabbing the last one + assertEquals(1, tester.passesCDOM(this.getSimplePrereq(), pc)); + } +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreWeaponProfTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreWeaponProfTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreWeaponProfTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.WeaponProf; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreWeaponProfTesterTest extends + AbstractCDOMObjectTestCase<WeaponProf> +{ + + PreWeaponProfTester tester = new PreWeaponProfTester(); + + @Override + public Class<WeaponProf> getCDOMClass() + { + return WeaponProf.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return PCTemplate.class; + } + + @Override + public String getKind() + { + return "WEAPONPROF"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isTypeLegal() + { + return true; + } + + @Override + public boolean isWildcardLegal() + { + return false; + } + + @Override + public boolean isAnyLegal() + { + return false; + } + + // TODO need to test with Equipment having the type, not WeaponProf having + // the type :( + + // TODO Need to test DEITYWEAPON +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreWieldTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreWieldTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreWieldTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.core.PlayerCharacter; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; + +public class PreWieldTesterTest extends TestCase +{ + + Prerequisite p; + PreWieldTester tester = new PreWieldTester(); + PlayerCharacter pc = new PlayerCharacter(false); + + @Override + @Before + public void setUp() + { + p = new Prerequisite(); + p.setKind("WIELD"); + p.setOperand("TwoHanded"); + } + + @Test + //(expected = UnsupportedOperationException.class) + public void testPCInvalid() throws PrerequisiteException + { + try + { + tester.passesCDOM(p, pc); + fail("Expected PREWEILD to be invalid for a PC"); + } + catch (UnsupportedOperationException e) + { + // OK + } + } +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-05-21 03:36:37
|
Revision: 2980 http://svn.sourceforge.net/pcgen/?rev=2980&view=rev Author: thpr Date: 2007-05-20 20:36:36 -0700 (Sun, 20 May 2007) Log Message: ----------- CDOM: Second set of PrerequisiteTester updates Modified Paths: -------------- branches/cdom/code/src/java/plugin/pretokens/test/PreSpecialAbilityTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreSpellBookTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreSpellCastMemorizeTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreSpellCastTester.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSubClassTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreTemplateTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreWeaponProfTesterTest.java Added Paths: ----------- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMBooleanTestCase.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectKeyTestCase.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSpecialAbilityTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellBookTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellCastMemorizeTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellCastTesterTest.java Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSpecialAbilityTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSpecialAbilityTester.java 2007-05-21 02:44:37 UTC (rev 2979) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSpecialAbilityTester.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -26,6 +26,7 @@ */ package plugin.pretokens.test; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PCTemplate; import pcgen.core.PlayerCharacter; import pcgen.core.SpecialAbility; @@ -106,4 +107,38 @@ return "SA"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal = 0; + + final int number; + try + { + number = Integer.parseInt(prereq.getOperand()); + } + catch (NumberFormatException exceptn) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreTemplate.error", prereq.toString())); //$NON-NLS-1$ + } + + PCGenGraph activeGraph = character.getActiveGraph(); + List<SpecialAbility> list = + activeGraph.getGrantedNodeList(SpecialAbility.class); + + if (!list.isEmpty()) + { + String saKey = prereq.getKey().toUpperCase(); + for (SpecialAbility sa : list) + { + if (sa.getKeyName().toUpperCase().startsWith(saKey)) + { + runningTotal++; + } + } + } + runningTotal = prereq.getOperator().compare(runningTotal, number); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSpellBookTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSpellBookTester.java 2007-05-21 02:44:37 UTC (rev 2979) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSpellBookTester.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -26,10 +26,15 @@ */ package plugin.pretokens.test; +import java.util.List; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PCClass; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; /** @@ -72,4 +77,26 @@ return "SPELLBOOK"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + boolean prereqUsesBook = prereq.getKey().toUpperCase().startsWith("Y"); //$NON-NLS-1$ + int runningTotal = 0; + int requiredNumber = Integer.parseInt(prereq.getOperand()); + + PCGenGraph activeGraph = character.getActiveGraph(); + List<PCClass> list = activeGraph.getGrantedNodeList(PCClass.class); + for (PCClass spellClass : list) + { + Boolean sb = spellClass.get(ObjectKey.SPELLBOOK); + if (sb != null && sb.booleanValue() == prereqUsesBook) + { + runningTotal++; + } + } + + runningTotal = + prereq.getOperator().compare(runningTotal, requiredNumber); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSpellCastMemorizeTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSpellCastMemorizeTester.java 2007-05-21 02:44:37 UTC (rev 2979) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSpellCastMemorizeTester.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -6,10 +6,15 @@ */ package plugin.pretokens.test; +import java.util.List; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PCClass; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; import pcgen.util.PropertyFactory; @@ -76,4 +81,26 @@ "PreSpellCastMemorize.toHtml_does_not_memorise", prereq.getOperator().toDisplayString()); //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int requiredNumber = Integer.parseInt(prereq.getOperand()); + Boolean prereqMemorized = + Boolean.valueOf(prereq.getKey().toUpperCase().startsWith("Y")); + int runningTotal = 0; + + PCGenGraph activeGraph = character.getActiveGraph(); + List<PCClass> list = activeGraph.getGrantedNodeList(PCClass.class); + for (PCClass aClass : list) + { + if (prereqMemorized.equals(aClass.get(ObjectKey.MEMORIZE_SPELLS))) + { + runningTotal++; + } + } + + runningTotal = + prereq.getOperator().compare(runningTotal, requiredNumber); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSpellCastTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSpellCastTester.java 2007-05-21 02:44:37 UTC (rev 2979) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSpellCastTester.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -26,10 +26,14 @@ */ package plugin.pretokens.test; +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PCClass; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; import pcgen.util.PropertyFactory; @@ -85,4 +89,26 @@ return PropertyFactory.getFormattedString("PreSpellCast.toHtml", args); //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + final int requiredNumber = Integer.parseInt(prereq.getOperand()); + final String prereqSpellType = prereq.getKey(); + int runningTotal = 0; + + PCGenGraph activeGraph = character.getActiveGraph(); + for (PCClass cl : activeGraph.getGrantedNodeList(PCClass.class)) + { + Type spellType = cl.get(ObjectKey.SPELL_TYPE); + if (spellType != null + && prereqSpellType.equalsIgnoreCase(spellType.toString())) + { + runningTotal++; + } + } + + runningTotal = + prereq.getOperator().compare(runningTotal, requiredNumber); + return countedTotal(prereq, runningTotal); + } + } Added: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMBooleanTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMBooleanTestCase.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMBooleanTestCase.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public abstract class AbstractCDOMBooleanTestCase<T extends PObject> extends + AbstractCDOMPreTestTestCase<T> +{ + + public Prerequisite getYesPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("YES"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getNoPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("NO"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public abstract String getKind(); + + public abstract PrerequisiteTest getTest(); + + public abstract ObjectKey<Boolean> getObjectKey(); + + @Test + public void testInvalidCount() + { + Prerequisite prereq = getYesPrereq(); + prereq.setOperand("x"); + try + { + getTest().passesCDOM(prereq, pc); + fail(); + } + catch (PrerequisiteException pe) + { + // OK (operand should be a number) + } + catch (NumberFormatException pe) + { + // OK (operand should be a number) + } + } + + @Test + public void testYes() throws PrerequisiteException + { + Prerequisite prereq = getYesPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj1 = grantCDOMObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj1.put(getObjectKey(), Boolean.FALSE); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj2 = grantCDOMObject("Winged Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj2.put(getObjectKey(), Boolean.FALSE); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj2.put(getObjectKey(), Boolean.TRUE); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testNo() throws PrerequisiteException + { + Prerequisite prereq = getNoPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj1 = grantCDOMObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj1.put(getObjectKey(), Boolean.TRUE); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj2 = grantCDOMObject("Winged Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj2.put(getObjectKey(), Boolean.TRUE); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj2.put(getObjectKey(), Boolean.FALSE); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getYesPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj1 = grantCDOMObject("Wild Mage"); + obj1.put(getObjectKey(), Boolean.FALSE); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj2 = grantFalseObject("Winged Mage"); + obj2.put(getObjectKey(), Boolean.FALSE); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj2.put(getObjectKey(), Boolean.TRUE); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectKeyTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectKeyTestCase.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectKeyTestCase.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public abstract class AbstractCDOMObjectKeyTestCase<T extends PObject, OT> + extends AbstractCDOMPreTestTestCase<T> +{ + + public Prerequisite getSimplePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey(getPassObject().toString()); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public abstract String getKind(); + + public abstract PrerequisiteTest getTest(); + + public abstract ObjectKey<OT> getObjectKey(); + + public abstract OT getPassObject(); + + public abstract OT getFailObject(); + + @Test + public void testInvalidCount() + { + Prerequisite prereq = getSimplePrereq(); + prereq.setOperand("x"); + try + { + getTest().passesCDOM(prereq, pc); + fail(); + } + catch (PrerequisiteException pe) + { + // OK (operand should be a number) + } + catch (NumberFormatException pe) + { + // OK (operand should be a number) + } + } + + @Test + public void testSimple() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj1 = grantCDOMObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj1.put(getObjectKey(), getFailObject()); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj2 = grantCDOMObject("Winged Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj2.put(getObjectKey(), getFailObject()); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj2.put(getObjectKey(), getPassObject()); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj1 = grantCDOMObject("Wild Mage"); + obj1.put(getObjectKey(), getFailObject()); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject obj2 = grantFalseObject("Winged Mage"); + obj2.put(getObjectKey(), getFailObject()); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + obj2.put(getObjectKey(), getPassObject()); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? + +} Modified: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-05-21 02:44:37 UTC (rev 2979) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -125,6 +125,8 @@ public abstract boolean isWildcardLegal(); + public abstract boolean isTestStarting(); + public abstract boolean isTypeLegal(); public abstract boolean isAnyLegal(); @@ -213,8 +215,9 @@ assertEquals(1, getTest().passesCDOM(prereq, pc)); // But not Katana assertEquals(0, getTest().passesCDOM(getSimplePrereq(), pc)); - // And not Generic Crossbow - assertEquals(0, getTest().passesCDOM(getGenericPrereq(), pc)); + // And maybe Generic Crossbow + assertEquals(isTestStarting() ? 1 : 0, getTest().passesCDOM( + getGenericPrereq(), pc)); } @Test Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSpecialAbilityTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSpecialAbilityTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSpecialAbilityTesterTest.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.Language; +import pcgen.core.PObject; +import pcgen.core.SpecialAbility; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSpecialAbilityTesterTest extends + AbstractCDOMObjectTestCase<SpecialAbility> +{ + + PreSpecialAbilityTester tester = new PreSpecialAbilityTester(); + + @Override + public Class<SpecialAbility> getCDOMClass() + { + return SpecialAbility.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "TEMPLATE"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isWildcardLegal() + { + return false; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Override + public boolean isAnyLegal() + { + return false; + } + + @Override + public boolean isTestStarting() + { + return true; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellBookTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellBookTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellBookTesterTest.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.Language; +import pcgen.core.PCClass; +import pcgen.core.PObject; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSpellBookTesterTest extends + AbstractCDOMBooleanTestCase<PCClass> +{ + + PreSpellBookTester tester = new PreSpellBookTester(); + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "SPELLBOOK"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public ObjectKey<Boolean> getObjectKey() + { + return ObjectKey.SPELLBOOK; + } +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellCastMemorizeTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellCastMemorizeTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellCastMemorizeTesterTest.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.Language; +import pcgen.core.PCClass; +import pcgen.core.PObject; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSpellCastMemorizeTesterTest extends + AbstractCDOMBooleanTestCase<PCClass> +{ + + PreSpellCastMemorizeTester tester = new PreSpellCastMemorizeTester(); + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "spellcast.memoriz"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public ObjectKey<Boolean> getObjectKey() + { + return ObjectKey.MEMORIZE_SPELLS; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellCastTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellCastTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellCastTesterTest.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.enumeration.Type; +import pcgen.core.Language; +import pcgen.core.PCClass; +import pcgen.core.PObject; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSpellCastTesterTest extends + AbstractCDOMObjectKeyTestCase<PCClass, Type> +{ + + PreSpellCastTester tester = new PreSpellCastTester(); + + @Override + public Class<PCClass> getCDOMClass() + { + return PCClass.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "spellcast.type"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public Type getFailObject() + { + return Type.getConstant("Arcane"); + } + + @Override + public ObjectKey<Type> getObjectKey() + { + return ObjectKey.SPELL_TYPE; + } + + @Override + public Type getPassObject() + { + return Type.getConstant("Divine"); + } +} Modified: branches/cdom/code/src/utest/plugin/pretokens/test/PreSubClassTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSubClassTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSubClassTesterTest.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -69,4 +69,10 @@ return false; } + @Override + public boolean isTestStarting() + { + return false; + } + } Modified: branches/cdom/code/src/utest/plugin/pretokens/test/PreTemplateTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreTemplateTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreTemplateTesterTest.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -70,4 +70,10 @@ return false; } + @Override + public boolean isTestStarting() + { + return false; + } + } Modified: branches/cdom/code/src/utest/plugin/pretokens/test/PreWeaponProfTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreWeaponProfTesterTest.java 2007-05-21 02:44:37 UTC (rev 2979) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreWeaponProfTesterTest.java 2007-05-21 03:36:36 UTC (rev 2980) @@ -70,6 +70,12 @@ return false; } + @Override + public boolean isTestStarting() + { + return false; + } + // TODO need to test with Equipment having the type, not WeaponProf having // the type :( This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-05-27 23:36:04
|
Revision: 3064 http://svn.sourceforge.net/pcgen/?rev=3064&view=rev Author: thpr Date: 2007-05-27 16:36:03 -0700 (Sun, 27 May 2007) Log Message: ----------- CDOM: Additional CDOM Implementation of PRExxx Tokens Modified Paths: -------------- branches/cdom/code/src/java/plugin/pretokens/test/PreDeityTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreDomainTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreHasDeityTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreLanguageTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreShieldProfTester.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java Added Paths: ----------- branches/cdom/code/src/utest/plugin/pretokens/test/PreDeityTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreDomainTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreHasDeityTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreLanguageTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreShieldProfTesterTest.java Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreDeityTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreDeityTester.java 2007-05-27 22:22:58 UTC (rev 3063) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreDeityTester.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -9,6 +9,10 @@ import java.util.ArrayList; import java.util.List; +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Pantheon; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.core.Deity; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; @@ -95,4 +99,66 @@ return "DEITY"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + int runningTotal = 0; + + PCGenGraph activeGraph = character.getActiveGraph(); + List<Deity> list = activeGraph.getGrantedNodeList(Deity.class); + + if (prereq.getKey().startsWith("PANTHEON."))//$NON-NLS-1$ + { + Pantheon p = Pantheon.valueOf(prereq.getKey().substring(9)); + for (Deity d : list) + { + List<Pantheon> pantheonList = d.getListFor(ListKey.PANTHEON); + if (prereq.getOperator().equals(PrerequisiteOperator.EQ) + || prereq.getOperator().equals(PrerequisiteOperator.GTEQ)) + { + runningTotal += (pantheonList.contains(p)) ? 1 : 0; + } + else if (prereq.getOperator().equals(PrerequisiteOperator.NEQ) + || prereq.getOperator().equals(PrerequisiteOperator.LT)) + { + runningTotal += (pantheonList.contains(p)) ? 0 : 1; + } + else + { + throw new PrerequisiteException(PropertyFactory + .getFormattedString( + "PreDeity.error.bad_coparator", prereq.toString())); //$NON-NLS-1$ + } + } + } + else + { + for (Deity d : list) + { + String charDeity = d.getKeyName(); + if (prereq.getOperator().equals(PrerequisiteOperator.EQ) + || prereq.getOperator().equals(PrerequisiteOperator.GTEQ)) + { + runningTotal += + (charDeity.equalsIgnoreCase(prereq.getKey())) ? 1 + : 0; + } + else if (prereq.getOperator().equals(PrerequisiteOperator.NEQ) + || prereq.getOperator().equals(PrerequisiteOperator.LT)) + { + runningTotal += + (charDeity.equalsIgnoreCase(prereq.getKey())) ? 0 + : 1; + } + else + { + throw new PrerequisiteException(PropertyFactory + .getFormattedString( + "PreDeity.error.bad_coparator", prereq.toString())); //$NON-NLS-1$ + } + } + } + + return countedTotal(prereq, runningTotal); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreDomainTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreDomainTester.java 2007-05-27 22:22:58 UTC (rev 3063) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreDomainTester.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -26,11 +26,17 @@ */ package plugin.pretokens.test; +import java.util.List; + +import pcgen.cdom.graph.PCGenGraph; +import pcgen.core.Domain; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; import pcgen.util.Logging; +import pcgen.util.PropertyFactory; /** * @author wardc @@ -82,4 +88,42 @@ return "DOMAIN"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + int runningTotal = 0; + int number = 0; + try + { + number = Integer.parseInt(prereq.getOperand()); + } + catch (NumberFormatException e) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreDomain.error.bad_operand", prereq.toString())); //$NON-NLS-1$ + } + + PCGenGraph activeGraph = character.getActiveGraph(); + List<Domain> list = activeGraph.getGrantedNodeList(Domain.class); + + if (!list.isEmpty()) + { + String domainKey = prereq.getKey(); + //handle ANY + if (domainKey.equalsIgnoreCase("ANY")) + { + runningTotal += list.size(); + } + else + { + if (activeGraph.containsGranted(Domain.class, domainKey)) + { + runningTotal++; + } + } + } + runningTotal = prereq.getOperator().compare(runningTotal, number); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreHasDeityTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreHasDeityTester.java 2007-05-27 22:22:58 UTC (rev 3063) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreHasDeityTester.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -28,9 +28,12 @@ */ package plugin.pretokens.test; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.core.Deity; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteOperator; import pcgen.core.prereq.PrerequisiteTest; @@ -72,4 +75,27 @@ { return "HAS.DEITY"; //$NON-NLS-1$ } + + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal; + PCGenGraph activeGraph = character.getActiveGraph(); + boolean charHasDeity = activeGraph.getGrantedNodeCount(Deity.class) != 0; + + String ucOp = prereq.getKey().toUpperCase(); + boolean flag = + (ucOp.charAt(0) == 'Y' && charHasDeity) + || (ucOp.charAt(0) == 'N' && !charHasDeity); + if (prereq.getOperator().equals(PrerequisiteOperator.EQ) + || prereq.getOperator().equals(PrerequisiteOperator.GTEQ)) + { + runningTotal = flag ? 1 : 0; + } + else + { + runningTotal = flag ? 0 : 1; + } + + return countedTotal(prereq, runningTotal); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreLanguageTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreLanguageTester.java 2007-05-27 22:22:58 UTC (rev 3063) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreLanguageTester.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -26,6 +26,11 @@ */ package plugin.pretokens.test; +import java.util.List; + +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.Globals; import pcgen.core.Language; import pcgen.core.PlayerCharacter; @@ -88,4 +93,46 @@ return "LANG"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + final String requiredLang = prereq.getKey(); + final int requiredNumber = Integer.parseInt(prereq.getOperand()); + int runningTotal = 0; + + PCGenGraph activeGraph = character.getActiveGraph(); + + if (requiredLang.equalsIgnoreCase("ANY")) { //$NON-NLS-1$ + runningTotal = activeGraph.getGrantedNodeCount(Language.class); + System.err.println(runningTotal); + System.err.println(activeGraph.getGrantedNodeList(Language.class)); + } + else if (requiredLang.startsWith("TYPE.") || requiredLang.startsWith("TYPE=")) + { + Type requiredType = Type.getConstant(requiredLang.substring(5)); + List<Language> list = + activeGraph.getGrantedNodeList(Language.class); + if (list != null) + { + for (Language lang : list) + { + if (lang.containsInList(ListKey.TYPE, requiredType)) + { + runningTotal++; + } + } + } + } + else + { + if (activeGraph.containsGranted(Language.class, requiredLang)) + { + runningTotal = 1; + } + } + + runningTotal = + prereq.getOperator().compare(runningTotal, requiredNumber); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreShieldProfTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreShieldProfTester.java 2007-05-27 22:22:58 UTC (rev 3063) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreShieldProfTester.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -26,9 +26,16 @@ */ package plugin.pretokens.test; +import java.util.List; + +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PlayerCharacter; +import pcgen.core.ShieldProf; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; /** @@ -75,4 +82,37 @@ return "SHIELDPROF"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + final int numberRequired = Integer.parseInt(prereq.getOperand()); + int runningTotal = 0; + + PCGenGraph activeGraph = character.getActiveGraph(); + final String aString = prereq.getKey(); + if (aString.startsWith("TYPE.") || aString.startsWith("TYPE=")) //$NON-NLS-1$ //$NON-NLS-2$ + { + Type requiredType = Type.getConstant(aString.substring(5)); + List<ShieldProf> list = + activeGraph.getGrantedNodeList(ShieldProf.class); + for (ShieldProf sp : list) + { + if (sp.containsInList(ListKey.TYPE, requiredType)) + { + runningTotal++; + } + } + } + else + { + if (activeGraph.containsGranted(ShieldProf.class, aString)) + { + runningTotal++; + } + } + + runningTotal = + prereq.getOperator().compare(runningTotal, numberRequired); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-05-27 22:22:58 UTC (rev 3063) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -119,6 +119,8 @@ return p; } + // TODO Need to test TYPE.Exotic.Heavy (to test two types at the same time) + public abstract String getKind(); public abstract PrerequisiteTest getTest(); @@ -131,21 +133,26 @@ public abstract boolean isAnyLegal(); - @Test - public void testInvalidCount() - { - Prerequisite prereq = getSimplePrereq(); - prereq.setOperand("x"); - try - { - getTest().passesCDOM(prereq, pc); - fail(); - } - catch (PrerequisiteException pe) - { - // OK (operand should be a number) - } - } + // TODO Not relevant today, because PCGen 5.x supports only one deity + // @Test + // public void testInvalidCount() + // { + // Prerequisite prereq = getSimplePrereq(); + // prereq.setOperand("x"); + // try + // { + // getTest().passesCDOM(prereq, pc); + // fail(); + // } + // catch (PrerequisiteException pe) + // { + // // OK (operand should be a number) + // } + // catch (NumberFormatException pe) + // { + // // OK (operand should be a number) + // } + // } @Test public void testAny() throws PrerequisiteException @@ -157,6 +164,9 @@ assertEquals(0, getTest().passesCDOM(prereq, pc)); grantCDOMObject("Wild Mage"); assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + // Single object granted twice doesn't pass prereq + assertEquals(0, getTest().passesCDOM(prereq, pc)); grantCDOMObject("Winged Mage"); assertEquals(1, getTest().passesCDOM(prereq, pc)); assertEquals(0, getTest().passesCDOM(getParenPrereq(), pc)); Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreDeityTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreDeityTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreDeityTesterTest.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.Deity; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreDeityTesterTest extends + AbstractCDOMObjectTestCase<Deity> +{ + + PreDeityTester tester = new PreDeityTester(); + + @Override + public Class<Deity> getCDOMClass() + { + return Deity.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return PCTemplate.class; + } + + @Override + public String getKind() + { + return "DEITY"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isWildcardLegal() + { + return false; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Override + public boolean isAnyLegal() + { + return false; + } + + @Override + public boolean isTestStarting() + { + return false; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreDomainTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreDomainTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreDomainTesterTest.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.Domain; +import pcgen.core.Language; +import pcgen.core.PObject; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreDomainTesterTest extends AbstractCDOMObjectTestCase<Domain> +{ + + PreDomainTester tester = new PreDomainTester(); + + @Override + public Class<Domain> getCDOMClass() + { + return Domain.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "DOMAIN"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isWildcardLegal() + { + return false; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Override + public boolean isAnyLegal() + { + return true; + } + + @Override + public boolean isTestStarting() + { + return false; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreHasDeityTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreHasDeityTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreHasDeityTesterTest.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -0,0 +1,116 @@ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.core.Deity; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreHasDeityTesterTest extends AbstractCDOMPreTestTestCase<Deity> +{ + + PreHasDeityTester tester = new PreHasDeityTester(); + + @Override + public Class<Deity> getCDOMClass() + { + return Deity.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return PCTemplate.class; + } + + private String getKind() + { + return "HASDEITY"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public Prerequisite getYesPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("YES"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getNoPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("NO"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + // TODO Is this even possible to achieve, or dont' worry about it? + // @Test + // public void testInvalidCount() + // { + // Prerequisite prereq = getYesPrereq(); + // prereq.setOperand("x"); + // try + // { + // getTest().passesCDOM(prereq, pc); + // fail(); + // } + // catch (PrerequisiteException pe) + // { + // // OK (operand should be a number) + // } + // catch (NumberFormatException pe) + // { + // // OK (operand should be a number) + // } + // } + + @Test + public void testYes() throws PrerequisiteException + { + Prerequisite prereq = getYesPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testNo() throws PrerequisiteException + { + Prerequisite prereq = getNoPrereq(); + // PC Should start without + assertEquals(1, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getYesPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantFalseObject("Wild Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantFalseObject("Winged Mage"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreLanguageTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreLanguageTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreLanguageTesterTest.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.Language; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreLanguageTesterTest extends + AbstractCDOMObjectTestCase<Language> +{ + + PreLanguageTester tester = new PreLanguageTester(); + + @Override + public Class<Language> getCDOMClass() + { + return Language.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return PCTemplate.class; + } + + @Override + public String getKind() + { + return "LANG"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isWildcardLegal() + { + return false; + } + + @Override + public boolean isTypeLegal() + { + return true; + } + + @Override + public boolean isAnyLegal() + { + return true; + } + + @Override + public boolean isTestStarting() + { + return false; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreShieldProfTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreShieldProfTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreShieldProfTesterTest.java 2007-05-27 23:36:03 UTC (rev 3064) @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.ShieldProf; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreShieldProfTesterTest extends + AbstractCDOMObjectTestCase<ShieldProf> +{ + + PreShieldProfTester tester = new PreShieldProfTester(); + + @Override + public Class<ShieldProf> getCDOMClass() + { + return ShieldProf.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return PCTemplate.class; + } + + @Override + public String getKind() + { + return "SHIELDPROF"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isTypeLegal() + { + return true; + } + + @Override + public boolean isWildcardLegal() + { + return false; + } + + @Override + public boolean isAnyLegal() + { + return false; + } + + @Override + public boolean isTestStarting() + { + return false; + } + + // TODO need to test with Equipment having the type, not WeaponProf having + // the type :( +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-05-28 01:12:46
|
Revision: 3065 http://svn.sourceforge.net/pcgen/?rev=3065&view=rev Author: thpr Date: 2007-05-27 18:12:40 -0700 (Sun, 27 May 2007) Log Message: ----------- CDOM: Additional CDOM Implementation of PRExxx Tokens Modified Paths: -------------- branches/cdom/code/src/java/pcgen/base/formula/Formula.java branches/cdom/code/src/java/pcgen/cdom/base/FormulaFactory.java branches/cdom/code/src/java/pcgen/cdom/base/JEPFormula.java branches/cdom/code/src/java/pcgen/cdom/graph/PCGenGraph.java branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java branches/cdom/code/src/java/plugin/pretokens/test/PreDamageReductionTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreGenderTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreHandsTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreLegsTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreRaceTester.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java Added Paths: ----------- branches/cdom/code/src/utest/plugin/pretokens/test/PreDamageReductionTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreGenderTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreHandsTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreLegsTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreRaceTesterTest.java Modified: branches/cdom/code/src/java/pcgen/base/formula/Formula.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/formula/Formula.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/pcgen/base/formula/Formula.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -17,6 +17,8 @@ */ package pcgen.base.formula; +import pcgen.core.PlayerCharacter; + /** * @author Thomas Parker (thpr [at] yahoo.com) * @@ -24,6 +26,8 @@ public interface Formula { + int resolve(PlayerCharacter character, String source); + /* * No implementation yet. Eventually, the idea is to hide JEP * behind this interface, so that Formula are type safe and Modified: branches/cdom/code/src/java/pcgen/cdom/base/FormulaFactory.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/FormulaFactory.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/pcgen/cdom/base/FormulaFactory.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -33,6 +33,15 @@ { throw new IllegalArgumentException("Formula cannot be empty"); } + // try + // { + // int i = Integer.parseInt(s); + // } + // catch (NumberFormatException e) + // { + // //Okay, just not an integer + // return new JEPFormula(s); + // } return new JEPFormula(s); } Modified: branches/cdom/code/src/java/pcgen/cdom/base/JEPFormula.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/JEPFormula.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/pcgen/cdom/base/JEPFormula.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -18,6 +18,7 @@ package pcgen.cdom.base; import pcgen.base.formula.Formula; +import pcgen.core.PlayerCharacter; public class JEPFormula implements Formula { @@ -47,4 +48,9 @@ return o instanceof JEPFormula && ((JEPFormula) o).formula.equals(formula); } + + public int resolve(PlayerCharacter character, String source) + { + return character.getVariableValue(formula, source).intValue(); + } } Modified: branches/cdom/code/src/java/pcgen/cdom/graph/PCGenGraph.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/graph/PCGenGraph.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/pcgen/cdom/graph/PCGenGraph.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -70,8 +70,16 @@ public <T extends PrereqObject> int getGrantedNodeCount(Class<T> name) { - // TODO Auto-generated method stub - return 0; + // Long/Slow implementation... + int count = 0; + for (PrereqObject pro : getNodeList()) + { + if (name.isInstance(pro)) + { + count++; + } + } + return count; } public CharacterDescription getDescription() Modified: branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -50,6 +50,7 @@ import java.util.TreeMap; import java.util.TreeSet; +import pcgen.base.formula.Formula; import pcgen.base.graph.visitor.DirectedNodeWeightCalculation; import pcgen.base.util.DoubleKeyMap; import pcgen.base.util.HashMapToList; @@ -57,6 +58,9 @@ import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.PrereqObject; import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.enumeration.Gender; +import pcgen.cdom.enumeration.IntegerKey; +import pcgen.cdom.enumeration.ObjectKey; import pcgen.cdom.graph.PCGenGraph; import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.helper.EquipmentSet; @@ -335,8 +339,6 @@ setStringFor(StringKey.HANDED, PropertyFactory.getString("in_right")); //$NON-NLS-1$ } - PCGenGraph activeGraph; - public PlayerCharacter(boolean b) { variableProcessor = new VariableProcessorPC(this); @@ -17644,6 +17646,13 @@ return reach; } + /* + * BEGIN CDOM CODE + */ + + private PCGenGraph activeGraph; + private Gender genderCDOM; //TODO Need a default that isn't Globals based + public PCGenGraph getActiveGraph() { return activeGraph; @@ -17684,6 +17693,118 @@ return calc.calculateNodeWeight(pro); } + /** + * Determine the number of hands the character has. This is based on their + * race and any applied templates. + * + * @return The number of hands. + */ + public int getCDOMHands() + { + List<Race> list = activeGraph.getGrantedNodeList(Race.class); + int hands = 0; + for (Race r : list) + { + Integer rh = r.get(IntegerKey.HANDS); + if (rh != null) + { + hands = rh.intValue(); + } + } + + // Scan templates for any overrides + List<PCTemplate> tlist = activeGraph.getGrantedNodeList(PCTemplate.class); + for (PCTemplate t : tlist) + { + Integer th = t.get(IntegerKey.HANDS); + if (th != null) + { + hands = th.intValue(); + } + } + return hands; + } + + /** + * Determine the number of legs the character has. This is based on their + * race and any applied templates. + * + * @return The number of legs. + */ + public int getCDOMLegs() + { + List<Race> list = activeGraph.getGrantedNodeList(Race.class); + int legs = 0; + for (Race r : list) + { + Integer rh = r.get(IntegerKey.LEGS); + if (rh != null) + { + legs = rh.intValue(); + } + } + + // Scan templates for any overrides + List<PCTemplate> tlist = activeGraph.getGrantedNodeList(PCTemplate.class); + for (PCTemplate t : tlist) + { + Integer th = t.get(IntegerKey.LEGS); + if (th != null) + { + legs = th.intValue(); + } + } + return legs; + } + + public void setCDOMGender(Gender g) + { + genderCDOM = g; + } + + /** + * Returns the character's gender. + * + * This method will return the stored gender or the template locked gender + * if there is one. + * + * @return The Player Character's Gender + */ + public Gender getCDOMGender() + { + Gender gen = genderCDOM; + List<PCTemplate> tlist = activeGraph.getGrantedNodeList(PCTemplate.class); + for (PCTemplate t : tlist) + { + Gender g = t.get(ObjectKey.GENDER_LOCK); + if (g != null) + { + gen = g; + } + } + return gen; + } + + public int getCDOMDamageReduction(String key) + { + int maxVal = -1; + for (pcgen.cdom.content.DamageReduction dr : getActiveGraph() + .getGrantedNodeList(pcgen.cdom.content.DamageReduction.class)) + { + if (dr.getBypass().equalsIgnoreCase(key)) + { + Formula f = dr.getReduction(); + int val = f.resolve(this, "getDR"); + if (val > maxVal) + { + maxVal = val; + } + } + } + maxVal += (int) getTotalBonusTo("DR", key); + return maxVal; + } + // public double getBonusValue(final String aBonusType, final String // aBonusName ) // { Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreDamageReductionTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreDamageReductionTester.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreDamageReductionTester.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -29,6 +29,7 @@ import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; import pcgen.core.DamageReduction; @@ -71,4 +72,12 @@ { return "DR"; //$NON-NLS-1$ } + + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int target = Integer.parseInt(prereq.getOperand()); + int val = character.getCDOMDamageReduction(prereq.getKey()); + int runningTotal = prereq.getOperator().compare(val, target); + return countedTotal(prereq, runningTotal); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreGenderTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreGenderTester.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreGenderTester.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -26,9 +26,11 @@ */ package plugin.pretokens.test; +import pcgen.cdom.enumeration.Gender; import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteOperator; import pcgen.core.prereq.PrerequisiteTest; @@ -68,4 +70,16 @@ return "GENDER"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal; + Gender gen = character.getCDOMGender(); + boolean matches = + gen != null + && (gen.toString().equalsIgnoreCase(prereq.getKey()) ^ + !prereq.getOperator().equals(PrerequisiteOperator.EQ)); + runningTotal = matches ? 1 : 0; + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreHandsTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreHandsTester.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreHandsTester.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -72,4 +72,23 @@ { return "HANDS"; //$NON-NLS-1$ } + + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal; + try + { + final int targetHands = Integer.parseInt(prereq.getOperand()); + + runningTotal = + prereq.getOperator().compare(character.getCDOMHands(), + targetHands); + } + catch (NumberFormatException nfe) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreHands.error.badly_formed", prereq.getOperand())); //$NON-NLS-1$ + } + return countedTotal(prereq, runningTotal); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreLegsTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreLegsTester.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreLegsTester.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -73,4 +73,23 @@ return "LEGS"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal; + try + { + final int targetLegs = Integer.parseInt(prereq.getOperand()); + + runningTotal = + prereq.getOperator().compare(character.getCDOMLegs(), + targetLegs); + } + catch (NumberFormatException nfe) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreLegs.error.bad_operand", prereq.getOperand())); //$NON-NLS-1$ + } + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreRaceTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreRaceTester.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreRaceTester.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -27,13 +27,18 @@ */ package plugin.pretokens.test; +import java.util.List; import java.util.StringTokenizer; +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.Constants; import pcgen.core.PlayerCharacter; import pcgen.core.Race; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; /** @@ -141,4 +146,95 @@ return "RACE"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + final int reqnumber = Integer.parseInt(prereq.getOperand()); + final String requiredRace = prereq.getKey(); + int runningTotal = 0; + PCGenGraph activeGraph = character.getActiveGraph(); + List<Race> list = activeGraph.getGrantedNodeList(Race.class); + + if (requiredRace.startsWith("TYPE=") || requiredRace.startsWith("TYPE.")) //$NON-NLS-1$ //$NON-NLS-2$ + { + for (Race r : list) + { + StringTokenizer tok = + new StringTokenizer(requiredRace.substring(5), "."); + boolean match = true; + // + // Must match all listed types in order to qualify + // + while (tok.hasMoreTokens()) + { + Type requiredType = Type.getConstant(tok.nextToken()); + if (!r.containsInList(ListKey.TYPE, requiredType)) + { + match = false; + break; + } + } + if (match) + { + ++runningTotal; + } + } + } + else if (requiredRace.startsWith("RACETYPE=") || requiredRace.startsWith("RACETYPE.")) //$NON-NLS-1$ //$NON-NLS-2$ + { + return character.getRaceType().equalsIgnoreCase( + requiredRace.substring(9)) ? 1 : 0; + } + else if (requiredRace.startsWith("RACESUBTYPE=") + || requiredRace.startsWith("RACESUBTYPE.")) + { + final String reqType = requiredRace.substring(12); + for (String subType : character.getRacialSubTypes()) + { + if (reqType.equalsIgnoreCase(subType)) + { + ++runningTotal; + } + } + } + else + { + for (Race r : list) + { + final String characterRace = r.getKeyName(); + final int wild = requiredRace.indexOf('%'); + if (wild == 0) + { + // + // Matches as long as race is not <none selected> + // + if (!characterRace.equalsIgnoreCase(Constants.s_NONESELECTED)) + { + ++runningTotal; + } + } + else if (wild > 0) + { + if (characterRace.regionMatches(true, 0, requiredRace, 0, wild)) + { + ++runningTotal; + } + } + else + { + if (characterRace.equalsIgnoreCase(requiredRace)) + { + ++runningTotal; + } + } + } + } + + if (runningTotal > reqnumber) + { + runningTotal = reqnumber; + } + runningTotal = prereq.getOperator().compare(runningTotal, reqnumber); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java 2007-05-27 23:36:03 UTC (rev 3064) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -76,7 +76,7 @@ return getObject(getCDOMClass(), s); } - public PCGraphGrantsEdge grantObject(PObject obj) + public PCGraphGrantsEdge grantObject(PrereqObject obj) { PCGenGraph graph = pc.getActiveGraph(); PrereqObject root = graph.getRoot(); Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreDamageReductionTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreDamageReductionTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreDamageReductionTesterTest.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -0,0 +1,127 @@ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.content.DamageReduction; +import pcgen.core.Language; +import pcgen.core.PObject; +import pcgen.core.Race; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreDamageReductionTesterTest extends + AbstractCDOMPreTestTestCase<Race> +{ + + PreDamageReductionTester tester = new PreDamageReductionTester(); + + @Override + public Class<Race> getCDOMClass() + { + return Race.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + private String getKind() + { + return "DR"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public Prerequisite getOnePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("+1"); + p.setOperand("10"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTwoPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("+2"); + p.setOperand("5"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testInvalidCount() + { + Prerequisite prereq = getOnePrereq(); + prereq.setOperand("x"); + try + { + getTest().passesCDOM(prereq, pc); + fail(); + } + catch (PrerequisiteException pe) + { + // OK (operand should be a number) + } + catch (NumberFormatException pe) + { + // OK (operand should be a number) + } + } + + @Test + public void testInsufficient() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + DamageReduction fiveOne = DamageReduction.getDamageReduction("5/+1"); + grantObject(fiveOne); + // Insufficient + assertEquals(0, getTest().passesCDOM(prereq, pc)); + DamageReduction fiveTwo = DamageReduction.getDamageReduction("5/+2"); + grantObject(fiveTwo); + // Insufficient + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testExact() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + DamageReduction tenOne = DamageReduction.getDamageReduction("10/+1"); + grantObject(tenOne); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testSurplus() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + DamageReduction tenOne = DamageReduction.getDamageReduction("15/+1"); + grantObject(tenOne); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? + + // TODO Need to test DRs with or and and + + // TODO Need to test DRs that use variables... +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreGenderTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreGenderTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreGenderTesterTest.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -0,0 +1,115 @@ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.Gender; +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.Language; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreGenderTesterTest extends + AbstractCDOMPreTestTestCase<PCTemplate> +{ + + PreGenderTester tester = new PreGenderTester(); + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + private String getKind() + { + return "GENDER"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public Prerequisite getNotMalePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Male"); + p.setOperator(PrerequisiteOperator.NEQ); + return p; + } + + public Prerequisite getFemalePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("FEMALE"); + p.setOperator(PrerequisiteOperator.EQ); + return p; + } + + @Test + public void testMaleLocked() throws PrerequisiteException + { + Prerequisite prereq = getNotMalePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + pc.setCDOMGender(Gender.Male); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + pc.setCDOMGender(Gender.Female); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + PObject templ = grantCDOMObject("Templ"); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + templ.put(ObjectKey.GENDER_LOCK, Gender.Neuter); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + templ.put(ObjectKey.GENDER_LOCK, Gender.Female); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + templ.put(ObjectKey.GENDER_LOCK, Gender.Male); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFemaleLocked() throws PrerequisiteException + { + Prerequisite prereq = getFemalePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + pc.setCDOMGender(Gender.Male); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + pc.setCDOMGender(Gender.Female); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + pc.setCDOMGender(Gender.Neuter); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject templ = grantCDOMObject("Templ"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + templ.put(ObjectKey.GENDER_LOCK, Gender.Male); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + templ.put(ObjectKey.GENDER_LOCK, Gender.Female); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getNotMalePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject falseObj = grantFalseObject("Wild Mage"); + falseObj.put(ObjectKey.GENDER_LOCK, Gender.Neuter); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreHandsTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreHandsTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreHandsTesterTest.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -0,0 +1,196 @@ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.IntegerKey; +import pcgen.core.Language; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.Race; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreHandsTesterTest extends AbstractCDOMPreTestTestCase<Race> +{ + + PreHandsTester tester = new PreHandsTester(); + + @Override + public Class<Race> getCDOMClass() + { + return Race.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + private String getKind() + { + return "HANDS"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public Prerequisite getOnePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTwoPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("2"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testInvalidCount() + { + Prerequisite prereq = getOnePrereq(); + prereq.setOperand("x"); + try + { + getTest().passesCDOM(prereq, pc); + fail(); + } + catch (PrerequisiteException pe) + { + // OK (operand should be a number) + } + catch (NumberFormatException pe) + { + // OK (operand should be a number) + } + } + + @Test + public void testRace() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject human = grantCDOMObject("Human"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(IntegerKey.HANDS, Integer.valueOf(1)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.HANDS, Integer.valueOf(2)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.HANDS, Integer.valueOf(0)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testRaceTemplate() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject human = grantCDOMObject("Human"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(IntegerKey.HANDS, Integer.valueOf(3)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + PObject templ = getObject(PCTemplate.class, "Templ"); + grantObject(templ); + templ.put(IntegerKey.HANDS, Integer.valueOf(1)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.HANDS, Integer.valueOf(0)); + templ.put(IntegerKey.HANDS, Integer.valueOf(4)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.HANDS, Integer.valueOf(4)); + templ.put(IntegerKey.HANDS, Integer.valueOf(0)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject falseObj = grantFalseObject("Wild Mage"); + falseObj.put(IntegerKey.HANDS, Integer.valueOf(1)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreLegsTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreLegsTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreLegsTesterTest.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -0,0 +1,196 @@ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.IntegerKey; +import pcgen.core.Language; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.Race; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreLegsTesterTest extends AbstractCDOMPreTestTestCase<Race> +{ + + PreLegsTester tester = new PreLegsTester(); + + @Override + public Class<Race> getCDOMClass() + { + return Race.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + private String getKind() + { + return "LEGS"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public Prerequisite getOnePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTwoPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("2"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testInvalidCount() + { + Prerequisite prereq = getOnePrereq(); + prereq.setOperand("x"); + try + { + getTest().passesCDOM(prereq, pc); + fail(); + } + catch (PrerequisiteException pe) + { + // OK (operand should be a number) + } + catch (NumberFormatException pe) + { + // OK (operand should be a number) + } + } + + @Test + public void testRace() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject human = grantCDOMObject("Human"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(IntegerKey.LEGS, Integer.valueOf(1)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.LEGS, Integer.valueOf(2)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.LEGS, Integer.valueOf(0)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testRaceTemplate() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject human = grantCDOMObject("Human"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(IntegerKey.LEGS, Integer.valueOf(3)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + PObject templ = getObject(PCTemplate.class, "Templ"); + grantObject(templ); + templ.put(IntegerKey.LEGS, Integer.valueOf(1)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.LEGS, Integer.valueOf(0)); + templ.put(IntegerKey.LEGS, Integer.valueOf(4)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.LEGS, Integer.valueOf(4)); + templ.put(IntegerKey.LEGS, Integer.valueOf(0)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject falseObj = grantFalseObject("Wild Mage"); + falseObj.put(IntegerKey.LEGS, Integer.valueOf(1)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreRaceTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreRaceTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreRaceTesterTest.java 2007-05-28 01:12:40 UTC (rev 3065) @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.Race; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreRaceTesterTest extends + AbstractCDOMObjectTestCase<Race> +{ + + PreRaceTester tester = new PreRaceTester(); + + @Override + public Class<Race> getCDOMClass() + { + return Race.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return PCTemplate.class; + } + + @Override + public String getKind() + { + return "RACE"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isWildcardLegal() + { + return true; + } + + @Override + public boolean isTypeLegal() + { + return true; + } + + @Override + public boolean isAnyLegal() + { + return false; + } + + @Override + public boolean isTestStarting() + { + return false; + } + +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-05-28 15:58:45
|
Revision: 3068 http://svn.sourceforge.net/pcgen/?rev=3068&view=rev Author: thpr Date: 2007-05-28 08:58:44 -0700 (Mon, 28 May 2007) Log Message: ----------- CDOM: Additional CDOM Implementation of PRExxx Tokens Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java branches/cdom/code/src/java/pcgen/core/prereq/PreEquippedTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreEquipBothTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreEquipPrimaryTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreEquipSecondaryTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreEquipTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreEquipTwoWeaponTester.java branches/cdom/code/src/test/pcgen/core/prereq/PreClassTest.java branches/cdom/code/src/test/pcgen/core/prereq/PreSkillTest.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/cdom/content/EquipmentSet.java branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSetFacade.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreEquipTestCase.java branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipBothTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipPrimaryTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipSecondaryTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipTwoWeaponTesterTest.java Removed Paths: ------------- branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSet.java Copied: branches/cdom/code/src/java/pcgen/cdom/content/EquipmentSet.java (from rev 3065, branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSet.java) =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/content/EquipmentSet.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/content/EquipmentSet.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -0,0 +1,8 @@ +package pcgen.cdom.content; + +import pcgen.cdom.base.ConcretePrereqObject; + +public class EquipmentSet extends ConcretePrereqObject +{ + +} Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/AssociationKey.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -102,6 +102,9 @@ public static final AssociationKey<Integer> WEIGHT = new AssociationKey<Integer>(); + public static final AssociationKey<Integer> EQUIPMENT_LOCATION = + new AssociationKey<Integer>(); + private static CaseInsensitiveMap<AssociationKey<?>> map = null; private AssociationKey() Deleted: branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSet.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSet.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSet.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -1,22 +0,0 @@ -package pcgen.cdom.helper; - -import java.util.Collection; - -import pcgen.core.Equipment; - -public class EquipmentSet -{ - - public Collection<Equipment> getEquipment() - { - // TODO Auto-generated method stub - return null; - } - - public Collection<Equipment> getEquipment(int location) - { - // TODO Auto-generated method stub - return null; - } - -} Added: branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSetFacade.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSetFacade.java (rev 0) +++ branches/cdom/code/src/java/pcgen/cdom/helper/EquipmentSetFacade.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -0,0 +1,92 @@ +package pcgen.cdom.helper; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import pcgen.base.graph.visitor.DirectedBreadthFirstTraverseAlgorithm; +import pcgen.cdom.base.PrereqObject; +import pcgen.cdom.content.EquipmentSet; +import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.cdom.graph.PCGraphEdge; +import pcgen.core.Equipment; + +public class EquipmentSetFacade +{ + + private final Class<Equipment> EQUIPMENT_CLASS = Equipment.class; + + private final PCGenGraph graph; + + private final EquipmentSet set; + + public EquipmentSetFacade(PCGenGraph pcgg, EquipmentSet activeSet) + { + if (pcgg == null) + { + throw new IllegalArgumentException("Graph cannot be null"); + } + if (activeSet == null) + { + throw new IllegalArgumentException( + "Active EquipmentSet cannot be null"); + } + graph = pcgg; + set = activeSet; + } + + public Collection<Equipment> getEquipment() + { + DirectedBreadthFirstTraverseAlgorithm<PrereqObject, PCGraphEdge> trav = + new DirectedBreadthFirstTraverseAlgorithm<PrereqObject, PCGraphEdge>( + graph); + trav.traverseFromNode(set); + List<Equipment> list = new ArrayList<Equipment>(); + for (PrereqObject po : trav.getVisitedNodes()) + { + if (EQUIPMENT_CLASS.isInstance(po)) + { + list.add(EQUIPMENT_CLASS.cast(po)); + } + } + return list; + } + + public Collection<Equipment> getEquipment(final int location) + { + DirectedBreadthFirstTraverseAlgorithm<PrereqObject, PCGraphEdge> trav = + new DirectedBreadthFirstTraverseAlgorithm<PrereqObject, PCGraphEdge>( + graph) + { + + @Override + protected boolean canTraverseEdge(PCGraphEdge edge, + PrereqObject gn, int type) + { + if (super.canTraverseEdge(edge, gn, type)) + { + Integer loc = + edge + .getAssociation(AssociationKey.EQUIPMENT_LOCATION); + if (loc != null) + { + return loc.intValue() == location; + } + } + return false; + } + + }; + trav.traverseFromNode(set); + List<Equipment> list = new ArrayList<Equipment>(); + for (PrereqObject po : trav.getVisitedNodes()) + { + if (EQUIPMENT_CLASS.isInstance(po)) + { + list.add(EQUIPMENT_CLASS.cast(po)); + } + } + return list; + } +} Modified: branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -57,13 +57,14 @@ import pcgen.cdom.base.CDOMList; import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.PrereqObject; +import pcgen.cdom.content.EquipmentSet; import pcgen.cdom.enumeration.AssociationKey; import pcgen.cdom.enumeration.Gender; import pcgen.cdom.enumeration.IntegerKey; import pcgen.cdom.enumeration.ObjectKey; import pcgen.cdom.graph.PCGenGraph; import pcgen.cdom.graph.PCGraphEdge; -import pcgen.cdom.helper.EquipmentSet; +import pcgen.cdom.helper.EquipmentSetFacade; import pcgen.core.bonus.Bonus; import pcgen.core.bonus.BonusObj; import pcgen.core.character.CharacterSpell; @@ -17665,10 +17666,20 @@ return null; } - public EquipmentSet getEquipped() + public EquipmentSetFacade getEquipped() { - // TODO Auto-generated method stub - return null; + List<EquipmentSet> list = activeGraph.getGrantedNodeList(EquipmentSet.class); + int size = list.size(); + if (size == 0) + { + return null; + } + else if (size == 1) + { + return new EquipmentSetFacade(activeGraph, list.get(0)); + } + throw new IllegalStateException( + "Character can only have one Granted Equipment Set"); } public int getTotalWeight(PrereqObject pro) @@ -17677,10 +17688,9 @@ { return -1; } - PCGenGraph graph = getActiveGraph(); DirectedNodeWeightCalculation<PrereqObject, PCGraphEdge> calc = new DirectedNodeWeightCalculation<PrereqObject, PCGraphEdge>( - graph) + activeGraph) { @Override protected int getEdgeWeight(int weight, PCGraphEdge edge) Modified: branches/cdom/code/src/java/pcgen/core/prereq/PreEquippedTester.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/prereq/PreEquippedTester.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/pcgen/core/prereq/PreEquippedTester.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -27,6 +27,10 @@ package pcgen.core.prereq; import java.util.StringTokenizer; + +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.helper.EquipmentSetFacade; import pcgen.core.Equipment; import pcgen.core.PlayerCharacter; import pcgen.core.character.WieldCategory; @@ -35,19 +39,25 @@ /** * @author wardc */ -public abstract class PreEquippedTester extends AbstractPrerequisiteTest { +public abstract class PreEquippedTester extends AbstractPrerequisiteTest +{ /** * Process the tokens and return the number that is not passed. - * + * * @param prereq - * @param character The pc to use. - * @param equippedType The equipped type to look for (e.g. Equipment.EQUIPPED_TWO_HANDS) - * + * @param character + * The pc to use. + * @param equippedType + * The equipped type to look for (e.g. + * Equipment.EQUIPPED_TWO_HANDS) + * * @return the number that did not pass * @throws PrerequisiteException */ - public int passesPreEquipHandleTokens(final Prerequisite prereq, final PlayerCharacter character, final int equippedType) throws PrerequisiteException + public int passesPreEquipHandleTokens(final Prerequisite prereq, + final PlayerCharacter character, final int equippedType) + throws PrerequisiteException { // TODO refactor this code with PreEquipTester boolean isEquipped = false; @@ -55,28 +65,33 @@ if (!character.getEquipmentList().isEmpty()) { final String aString = prereq.getKey(); - for ( Equipment eq : character.getEquipmentList() ) + for (Equipment eq : character.getEquipmentList()) { // // Only check equipment of the type we are interested in // - if (!eq.isEquipped() || (eq.getLocation() != equippedType)) + if (!eq.isEquipped() || (eq.getLocation() != equippedType)) { continue; } - if (aString.startsWith("WIELDCATEGORY=") || aString.startsWith("WIELDCATEGORY.")) + if (aString.startsWith("WIELDCATEGORY=") + || aString.startsWith("WIELDCATEGORY.")) { - final WieldCategory wCat = eq.getEffectiveWieldCategory(character); - if ((wCat != null) && wCat.getName().equalsIgnoreCase(aString.substring(14))) + final WieldCategory wCat = + eq.getEffectiveWieldCategory(character); + if ((wCat != null) + && wCat.getName().equalsIgnoreCase( + aString.substring(14))) { isEquipped = true; break; } } - else if (aString.startsWith("TYPE=") || aString.startsWith("TYPE.")) //$NON-NLS-1$ //$NON-NLS-2$ + else if (aString.startsWith("TYPE=") || aString.startsWith("TYPE.")) //$NON-NLS-1$ //$NON-NLS-2$ { - StringTokenizer tok = new StringTokenizer(aString.substring(5), "."); + StringTokenizer tok = + new StringTokenizer(aString.substring(5), "."); boolean match = false; if (tok.hasMoreTokens()) { @@ -85,7 +100,7 @@ // // Must match all listed types in order to qualify // - while(tok.hasMoreTokens()) + while (tok.hasMoreTokens()) { final String type = tok.nextToken(); if (!eq.isType(type)) @@ -100,15 +115,17 @@ break; } } - else //not a TYPE string + else + // not a TYPE string { final String eqName = eq.getName(); if (aString.indexOf('%') >= 0) { - //handle wildcards (always assume they + // handle wildcards (always assume they // end the line) final int percentPos = aString.indexOf('%'); - if (eqName.regionMatches(true, 0, aString, 0, percentPos)) + if (eqName.regionMatches(true, 0, aString, 0, + percentPos)) { isEquipped = true; break; @@ -116,7 +133,7 @@ } else if (eqName.equalsIgnoreCase(aString)) { - //just a straight String compare + // just a straight String compare isEquipped = true; break; } @@ -127,7 +144,8 @@ final PrerequisiteOperator operator = prereq.getOperator(); int runningTotal; - if (operator.equals(PrerequisiteOperator.EQ) || operator.equals(PrerequisiteOperator.GTEQ)) + if (operator.equals(PrerequisiteOperator.EQ) + || operator.equals(PrerequisiteOperator.GTEQ)) { runningTotal = isEquipped ? 1 : 0; } @@ -138,11 +156,115 @@ else { throw new PrerequisiteException(PropertyFactory.getFormattedString( - "PreEquipped.error.invalid_comparison", prereq.toString())); //$NON-NLS-1$ + "PreEquipped.error.invalid_comparison", prereq.toString())); //$NON-NLS-1$ } return countedTotal(prereq, runningTotal); } + /** + * Process the tokens and return the number that is not passed. + * + * @param prereq + * @param character + * The pc to use. + * @param equippedType + * The equipped type to look for (e.g. + * Equipment.EQUIPPED_TWO_HANDS) + * + * @return the number that did not pass + * @throws PrerequisiteException + */ + public int passesCDOMPreEquipHandleTokens(final Prerequisite prereq, + final PlayerCharacter character, final int equippedType) + throws PrerequisiteException + { + EquipmentSetFacade set = character.getEquipped(); + boolean isEquipped = false; + + if (set != null) + { + String aString = prereq.getKey(); + + for (Equipment eq : set.getEquipment(equippedType)) + { + if (aString.startsWith("WIELDCATEGORY=") + || aString.startsWith("WIELDCATEGORY.")) + { + WieldCategory wCat = eq.getEffectiveWieldCategory(character); + if ((wCat != null) + && wCat.getName().equalsIgnoreCase(aString.substring(14))) + { + isEquipped = true; + break; + } + } + else if (aString.startsWith("TYPE=") || aString.startsWith("TYPE.")) //$NON-NLS-1$ //$NON-NLS-2$ + { + StringTokenizer tok = + new StringTokenizer(aString.substring(5), "."); + boolean match = true; + // + // Must match all listed types in order to qualify + // + while (tok.hasMoreTokens()) + { + Type requiredType = Type.getConstant(tok.nextToken()); + if (!eq.containsInList(ListKey.TYPE, requiredType)) + { + match = false; + break; + } + } + if (match) + { + isEquipped = true; + break; + } + } + else + // not a TYPE string + { + String eqName = eq.getKeyName(); + int percentPos = aString.indexOf('%'); + if (percentPos >= 0) + { + // handle wildcards (always assume they + // end the line) + if (eqName.regionMatches(true, 0, aString, 0, percentPos)) + { + isEquipped = true; + break; + } + } + else if (eqName.equalsIgnoreCase(aString)) + { + // just a straight String compare + isEquipped = true; + break; + } + } + } + } + PrerequisiteOperator operator = prereq.getOperator(); + + int runningTotal; + if (operator.equals(PrerequisiteOperator.EQ) + || operator.equals(PrerequisiteOperator.GTEQ)) + { + runningTotal = isEquipped ? 1 : 0; + } + else if (operator.equals(PrerequisiteOperator.NEQ)) + { + runningTotal = isEquipped ? 0 : 1; + } + else + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreEquipped.error.invalid_comparison", prereq.toString())); //$NON-NLS-1$ + } + + return countedTotal(prereq, runningTotal); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreEquipBothTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreEquipBothTester.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreEquipBothTester.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -60,4 +60,11 @@ return "EQUIPBOTH"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + return passesCDOMPreEquipHandleTokens(prereq, character, + Equipment.EQUIPPED_BOTH); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreEquipPrimaryTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreEquipPrimaryTester.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreEquipPrimaryTester.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -60,4 +60,11 @@ return "EQUIPPRIMARY"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + return passesCDOMPreEquipHandleTokens(prereq, character, + Equipment.EQUIPPED_PRIMARY); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreEquipSecondaryTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreEquipSecondaryTester.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreEquipSecondaryTester.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -60,4 +60,10 @@ return "EQUIPSECONDARY"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + return passesCDOMPreEquipHandleTokens(prereq, character, + Equipment.EQUIPPED_SECONDARY); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreEquipTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreEquipTester.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreEquipTester.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -28,6 +28,9 @@ import java.util.StringTokenizer; +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.helper.EquipmentSetFacade; import pcgen.core.Equipment; import pcgen.core.PlayerCharacter; import pcgen.core.character.WieldCategory; @@ -39,7 +42,7 @@ /** * @author wardc - * + * */ public class PreEquipTester extends AbstractPrerequisiteTest implements PrerequisiteTest @@ -47,7 +50,7 @@ /* * (non-Javadoc) - * + * * @see pcgen.core.prereq.PrerequisiteTest#passes(pcgen.core.PlayerCharacter) */ @Override @@ -120,13 +123,13 @@ } } else - //not a TYPE string + // not a TYPE string { final String eqName = eq.getName().toUpperCase(); if (targetEquip.indexOf('%') >= 0) { - //handle wildcards (always assume + // handle wildcards (always assume // they end the line) final int percentPos = targetEquip.indexOf('%'); final String substring = @@ -140,7 +143,7 @@ } else if (eqName.equalsIgnoreCase(targetEquip)) { - //just a straight String compare + // just a straight String compare ++runningTotal; break; } @@ -154,11 +157,97 @@ /* * (non-Javadoc) - * + * * @see pcgen.core.prereq.PrerequisiteTest#kindsHandled() */ public String kindHandled() { return "EQUIP"; //$NON-NLS-1$ } + + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + int runningTotal = 0; + + final int number; + try + { + number = Integer.parseInt(prereq.getOperand()); + } + catch (NumberFormatException exceptn) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreFeat.error", prereq.toString())); //$NON-NLS-1$ + } + + EquipmentSetFacade set = character.getEquipped(); + if (set != null) + { + String targetEquip = prereq.getKey(); + + for (Equipment eq : set.getEquipment()) + { + if (targetEquip.startsWith("WIELDCATEGORY=") + || targetEquip.startsWith("WIELDCATEGORY.")) + { + WieldCategory wCat = eq.getEffectiveWieldCategory(character); + if ((wCat != null) + && wCat.getName().equalsIgnoreCase( + targetEquip.substring(14))) + { + runningTotal++; + break; + } + } + else if (targetEquip.startsWith("TYPE=") || targetEquip.startsWith("TYPE.")) //$NON-NLS-1$ //$NON-NLS-2$ + { + StringTokenizer tok = + new StringTokenizer(targetEquip.substring(5), "."); + boolean match = true; + // + // Must match all listed types in order to qualify + // + while (tok.hasMoreTokens()) + { + Type requiredType = Type.getConstant(tok.nextToken()); + if (!eq.containsInList(ListKey.TYPE, requiredType)) + { + match = false; + break; + } + } + if (match) + { + runningTotal++; + break; + } + } + else + // not a TYPE string + { + String eqName = eq.getKeyName(); + int percentPos = targetEquip.indexOf('%'); + if (percentPos >= 0) + { + // handle wildcards (always assume they + // end the line) + if (eqName.regionMatches(true, 0, targetEquip, 0, percentPos)) + { + runningTotal++; + break; + } + } + else if (eqName.equalsIgnoreCase(targetEquip)) + { + // just a straight String compare + runningTotal++; + break; + } + } + } + } + runningTotal = prereq.getOperator().compare(runningTotal, number); + return countedTotal(prereq, runningTotal); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreEquipTwoWeaponTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreEquipTwoWeaponTester.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreEquipTwoWeaponTester.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -35,13 +35,15 @@ /** * @author wardc - * + * */ public class PreEquipTwoWeaponTester extends PreEquippedTester implements PrerequisiteTest { - /* (non-Javadoc) + /* + * (non-Javadoc) + * * @see pcgen.core.prereq.PrerequisiteTest#passes(pcgen.core.PlayerCharacter) */ @Override @@ -52,11 +54,20 @@ Equipment.EQUIPPED_TWO_HANDS); } - /* (non-Javadoc) + /* + * (non-Javadoc) + * * @see pcgen.core.prereq.PrerequisiteTest#kindsHandled() */ public String kindHandled() { return "EQUIPTWOWEAPON"; //$NON-NLS-1$ } + + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + return passesCDOMPreEquipHandleTokens(prereq, character, + Equipment.EQUIPPED_TWO_HANDS); + } } Modified: branches/cdom/code/src/test/pcgen/core/prereq/PreClassTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/core/prereq/PreClassTest.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/test/pcgen/core/prereq/PreClassTest.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -146,44 +146,6 @@ } /** - * Test to ensure that a character will fail a test - * if it does not have the correct number of levels - * in the class. - * @throws Exception - */ - public void testCharWithMultipleSpellClasses() throws Exception - { - final PCClass pcClass = new PCClass(); - pcClass.setName("MyClass"); - pcClass.setAbbrev("My"); - pcClass.setSpellBaseStat("CHA"); - pcClass.setSpellType("ARCANE"); - pcClass.setCast(1, Arrays.asList("5,4".split(","))); - - final PCClass pcClass2 = new PCClass(); - pcClass2.setName("Other Class"); - pcClass2.setAbbrev("OC"); - pcClass.setSpellBaseStat("INT"); - pcClass2.setSpellType("ARCANE"); - pcClass2.setCast(1, Arrays.asList("5,4".split(","))); - - final PlayerCharacter character = getCharacter(); - character.incrementClassLevel(1, pcClass); - character.incrementClassLevel(2, pcClass2); - - final Prerequisite prereq = new Prerequisite(); - prereq.setKind("class"); - prereq.setKey("SPELLCASTER.ARCANE"); - prereq.setOperand("3"); - prereq.setTotalValues(true); - prereq.setOperator(PrerequisiteOperator.GTEQ); - - final PreClassTester test = new PreClassTester(); - final int passes = test.passes(prereq, character); - assertEquals(3, passes); - } - - /** * Test to ensure that a character without a named class cannot be found * @throws Exception */ Modified: branches/cdom/code/src/test/pcgen/core/prereq/PreSkillTest.java =================================================================== --- branches/cdom/code/src/test/pcgen/core/prereq/PreSkillTest.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/test/pcgen/core/prereq/PreSkillTest.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -269,11 +269,10 @@ prereq.setOperand("10"); final Prerequisite subreq = new Prerequisite(); - subreq.setKind("skill"); + subreq.setKind("skill.tot"); subreq.setKey("TYPE.DEX"); subreq.setOperator(PrerequisiteOperator.GTEQ); subreq.setOperand("1"); - subreq.setTotalValues(true); prereq.addPrerequisite(subreq); @@ -288,11 +287,10 @@ public void testType() throws Exception { final Prerequisite subreq = new Prerequisite(); - subreq.setKind("skill"); + subreq.setKind("skill.tot"); subreq.setKey("TYPE.DEX"); subreq.setOperator(PrerequisiteOperator.GTEQ); subreq.setOperand("7"); - subreq.setTotalValues(true); final PlayerCharacter character = getCharacter(); final boolean passes = PrereqHandler.passes(subreq, character, null); Modified: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-05-28 08:19:48 UTC (rev 3067) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -412,4 +412,6 @@ assertEquals(0, getTest().passesCDOM(prereq, pc)); } } + + // TODO Complex Types (more than one type) } Added: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreEquipTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreEquipTestCase.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreEquipTestCase.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -0,0 +1,367 @@ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.content.EquipmentSet; +import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.core.Equipment; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public abstract class AbstractCDOMPreEquipTestCase extends + AbstractCDOMPreTestTestCase<Equipment> +{ + + @Override + public Class<Equipment> getCDOMClass() + { + return Equipment.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return PCTemplate.class; + } + + public abstract String getKind(); + + public abstract PrerequisiteTest getTest(); + + public abstract int getProperLocation(); + + public abstract int getFalseLocation(); + + private EquipmentSet activeSet = new EquipmentSet(); + + public Equipment equip(String s, int loc) + { + Equipment e = getObject(s); + equip(e, loc); + return e; + } + + public void equip(Equipment e, int loc) + { + PCGenGraph graph = pc.getActiveGraph(); + graph.addNode(e); + PCGraphGrantsEdge edge = + new PCGraphGrantsEdge(activeSet, e, "TestCase"); + edge.setAssociation(AssociationKey.EQUIPMENT_LOCATION, Integer + .valueOf(loc)); + graph.addEdge(edge); + } + + public void unequip(Equipment e) + { + pc.getActiveGraph().removeNode(e); + } + + public boolean isTypeLegal() + { + return true; + } + + public boolean isWildcardLegal() + { + return true; + } + + // public Prerequisite getAnyPrereq() + // { + // Prerequisite p; + // p = new Prerequisite(); + // p.setKind(getKind()); + // p.setKey("ANY"); + // p.setOperand("2"); + // p.setOperator(PrerequisiteOperator.GTEQ); + // return p; + // } + + public Prerequisite getSimplePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Winged Mage"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getWildcard() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Wild%"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getCountTemplates() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("%"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getGenericPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Crossbow"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getParenPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Crossbow (Heavy)"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTypeDotPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("TYPE.Exotic"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTypeEqualsPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("TYPE=Martial"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testSimple() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Equipment wild = equip("Wild Mage", getProperLocation()); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + unequip(wild); + equip("Winged Mage", getProperLocation()); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + assertEquals(0, getTest().passesCDOM(getParenPrereq(), pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Winged Mage", getFalseLocation()); + // Wrong loc + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Wild Mage", getProperLocation()); + // Wrong item + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testParen() throws PrerequisiteException + { + Prerequisite prereq = getParenPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Crossbow (Heavy)", getProperLocation()); + // Has Crossbow (Heavy) + assertEquals(1, getTest().passesCDOM(prereq, pc)); + // But not Katana + assertEquals(0, getTest().passesCDOM(getSimplePrereq(), pc)); + // And not Generic Crossbow + assertEquals(0, getTest().passesCDOM(getGenericPrereq(), pc)); + } + + @Test + public void testWildcard() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getWildcard(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Equipment winged = equip("Winged Creature", getProperLocation()); + // Not qualifying + assertEquals(0, getTest().passesCDOM(prereq, pc)); + unequip(winged); + equip("Wild Mage", getProperLocation()); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testFalseWildcard() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getWildcard(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Winged Creature", getProperLocation()); + // Not qualifying + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Wild Mage", getFalseLocation()); + // Not enough + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testCount() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getCountTemplates(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Winged Creature", getFalseLocation()); + // Still at zero qualifying + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Wild Mage", getProperLocation()); + // enough + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeDot() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getTypeDotPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = equip("Katana", getProperLocation()); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Test having multiple types + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testFalseTypeDot() throws PrerequisiteException + { + if (isTypeLegal()) + { + + Prerequisite prereq = getTypeDotPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = equip("Katana", getFalseLocation()); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + // Would be 1 if true + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Would be 1 if true + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeEqual() throws PrerequisiteException + { + if (isTypeLegal()) + { + + Prerequisite prereq = getTypeEqualsPrereq(); + // PC Should start without the WeaponProf + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = equip("Katana", getProperLocation()); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Test with WP having multiple types + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testFalseTypeEqual() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getTypeEqualsPrereq(); + // PC Should start without the WeaponProf + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = equip("Katana", getFalseLocation()); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Would be 1 if true + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Would be 1 if true + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + } + + // TODO Test where an EqMod has modified a TYPE of a piece of Equipment + + // TODO Need to consider inverted? !PRE? + + // TODO Complex Types (more than one type) + + // TODO Test WIELDCATEGORY +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipBothTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipBothTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipBothTesterTest.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -0,0 +1,35 @@ +package plugin.pretokens.test; + +import pcgen.core.Equipment; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreEquipBothTesterTest extends AbstractCDOMPreEquipTestCase +{ + + PreEquipBothTester tester = new PreEquipBothTester(); + + @Override + public int getFalseLocation() + { + return Equipment.EQUIPPED_SECONDARY; + } + + @Override + public String getKind() + { + return "EQUIPBOTH"; + } + + @Override + public int getProperLocation() + { + return Equipment.EQUIPPED_BOTH; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipPrimaryTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipPrimaryTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipPrimaryTesterTest.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -0,0 +1,35 @@ +package plugin.pretokens.test; + +import pcgen.core.Equipment; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreEquipPrimaryTesterTest extends AbstractCDOMPreEquipTestCase +{ + + PreEquipPrimaryTester tester = new PreEquipPrimaryTester(); + + @Override + public int getFalseLocation() + { + return Equipment.EQUIPPED_SECONDARY; + } + + @Override + public String getKind() + { + return "EQUIPPRIMARY"; + } + + @Override + public int getProperLocation() + { + return Equipment.EQUIPPED_PRIMARY; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipSecondaryTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipSecondaryTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipSecondaryTesterTest.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -0,0 +1,35 @@ +package plugin.pretokens.test; + +import pcgen.core.Equipment; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreEquipSecondaryTesterTest extends AbstractCDOMPreEquipTestCase +{ + + PreEquipSecondaryTester tester = new PreEquipSecondaryTester(); + + @Override + public int getFalseLocation() + { + return Equipment.EQUIPPED_PRIMARY; + } + + @Override + public String getKind() + { + return "EQUIPSECONDARY"; + } + + @Override + public int getProperLocation() + { + return Equipment.EQUIPPED_SECONDARY; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipTesterTest.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -0,0 +1,290 @@ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.content.EquipmentSet; +import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.core.Equipment; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreEquipTesterTest extends AbstractCDOMPreTestTestCase<Equipment> +{ + + PreEquipTester tester = new PreEquipTester(); + + @Override + public Class<Equipment> getCDOMClass() + { + return Equipment.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return PCTemplate.class; + } + + public String getKind() + { + return "PREEQUIP"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public int getProperLocation() + { + return Equipment.EQUIPPED_PRIMARY; + } + + private EquipmentSet activeSet = new EquipmentSet(); + + public Equipment equip(String s, int loc) + { + Equipment e = getObject(s); + equip(e, loc); + return e; + } + + public void equip(Equipment e, int loc) + { + PCGenGraph graph = pc.getActiveGraph(); + graph.addNode(e); + PCGraphGrantsEdge edge = + new PCGraphGrantsEdge(activeSet, e, "TestCase"); + edge.setAssociation(AssociationKey.EQUIPMENT_LOCATION, Integer + .valueOf(loc)); + graph.addEdge(edge); + } + + public void unequip(Equipment e) + { + pc.getActiveGraph().removeNode(e); + } + + public boolean isTypeLegal() + { + return true; + } + + public boolean isWildcardLegal() + { + return true; + } + + // public Prerequisite getAnyPrereq() + // { + // Prerequisite p; + // p = new Prerequisite(); + // p.setKind(getKind()); + // p.setKey("ANY"); + // p.setOperand("2"); + // p.setOperator(PrerequisiteOperator.GTEQ); + // return p; + // } + + public Prerequisite getSimplePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Winged Mage"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getWildcard() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Wild%"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getCountTemplates() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("%"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getGenericPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Crossbow"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getParenPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("Crossbow (Heavy)"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTypeDotPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("TYPE.Exotic"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTypeEqualsPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey("TYPE=Martial"); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testSimple() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Equipment wild = equip("Wild Mage", getProperLocation()); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + unequip(wild); + equip("Winged Mage", getProperLocation()); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + assertEquals(0, getTest().passesCDOM(getParenPrereq(), pc)); + } + + @Test + public void testParen() throws PrerequisiteException + { + Prerequisite prereq = getParenPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Crossbow (Heavy)", getProperLocation()); + // Has Crossbow (Heavy) + assertEquals(1, getTest().passesCDOM(prereq, pc)); + // But not Katana + assertEquals(0, getTest().passesCDOM(getSimplePrereq(), pc)); + // And not Generic Crossbow + assertEquals(0, getTest().passesCDOM(getGenericPrereq(), pc)); + } + + @Test + public void testWildcard() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getWildcard(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Equipment winged = equip("Winged Creature", getProperLocation()); + // Not qualifying + assertEquals(0, getTest().passesCDOM(prereq, pc)); + unequip(winged); + equip("Wild Mage", getProperLocation()); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testCount() throws PrerequisiteException + { + if (isWildcardLegal()) + { + Prerequisite prereq = getCountTemplates(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + equip("Wild Mage", getProperLocation()); + // enough + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeDot() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getTypeDotPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = equip("Katana", getProperLocation()); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Test having multiple types + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeEqual() throws PrerequisiteException + { + if (isTypeLegal()) + { + + Prerequisite prereq = getTypeEqualsPrereq(); + // PC Should start without the WeaponProf + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject katana = equip("Katana", getProperLocation()); + // Not yet the proper type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + katana.removeListFor(ListKey.TYPE); + // Isn't the proper type anymore + assertEquals(0, getTest().passesCDOM(prereq, pc)); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + katana.addToListFor(ListKey.TYPE, Type.getConstant("Cool")); + // Test with WP having multiple types + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + } + + // TODO Test where an EqMod has modified a TYPE of a piece of Equipment + + // TODO Need to consider inverted? !PRE? + + // TODO Complex Types (more than one type) + + // TODO Test WIELDCATEGORY +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipTwoWeaponTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipTwoWeaponTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreEquipTwoWeaponTesterTest.java 2007-05-28 15:58:44 UTC (rev 3068) @@ -0,0 +1,35 @@ +package plugin.pretokens.test; + +import pcgen.core.Equipment; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreEquipTwoWeaponTesterTest extends AbstractCDOMPreEquipTestCase +{ + + PreEquipTwoWeaponTester tester = new PreEquipTwoWeaponTester(); + + @Override + public int getFalseLocation() + { + return Equipment.EQUIPPED_PRIMARY; + } + + @Override + public String getKind() + { + return "EQUIPTWOWEAPON"; + } + + @Override + public int getProperLocation() + { + return Equipment.EQUIPPED_TWO_HANDS; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-05-28 23:36:43
|
Revision: 3070 http://svn.sourceforge.net/pcgen/?rev=3070&view=rev Author: thpr Date: 2007-05-28 16:36:36 -0700 (Mon, 28 May 2007) Log Message: ----------- CDOM: Additional CDOM Implementation of PRExxx Tokens Modified Paths: -------------- branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java branches/cdom/code/src/java/pcgen/cdom/inst/PCClassLevel.java branches/cdom/code/src/java/pcgen/cdom/mode/Size.java branches/cdom/code/src/java/pcgen/core/PCClass.java branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java branches/cdom/code/src/java/pcgen/core/Race.java branches/cdom/code/src/java/plugin/pretokens/test/PreReachTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreRegionTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreSpellResistanceTester.java branches/cdom/code/src/utest/plugin/pretokens/test/PreDamageReductionTesterTest.java Added Paths: ----------- branches/cdom/code/src/java/pcgen/core/DomainList.java branches/cdom/code/src/utest/plugin/pretokens/test/PreReachTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSizeTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellResistanceTesterTest.java Modified: branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/pcgen/cdom/enumeration/ListKey.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -35,6 +35,7 @@ import pcgen.cdom.helper.Capacity; import pcgen.cdom.helper.Quality; import pcgen.core.Description; +import pcgen.core.Domain; import pcgen.core.EquipmentModifier; import pcgen.core.PCClass; import pcgen.core.WeaponProf; Modified: branches/cdom/code/src/java/pcgen/cdom/inst/PCClassLevel.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/inst/PCClassLevel.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/pcgen/cdom/inst/PCClassLevel.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -22,6 +22,11 @@ public final class PCClassLevel extends PObject { + /* + * THIS MUST STAY OBJECT AND NOT PCCLASS!!! + * + * Otherwise there is a circular dependence of this object and PCClass. + */ private final Object classSource; private final int classLevel; @@ -32,6 +37,11 @@ classLevel = lvl; } + public Object getSource() + { + return classSource; + } + public int getClassLevel() { return classLevel; Modified: branches/cdom/code/src/java/pcgen/cdom/mode/Size.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/mode/Size.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/pcgen/cdom/mode/Size.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -64,6 +64,12 @@ return FACTORY.getNextConstant(this); } + public Size getPreviousSize() + { + // TODO What if null (if this is first?) + return FACTORY.getPreviousConstant(this); + } + @Override public String toString() { @@ -90,6 +96,11 @@ return FACTORY.valueOf(s); } + public static Size getConstant(int ordinal) + { + return FACTORY.getConstant(ordinal); + } + private static final TypeFactory FACTORY = new TypeFactory(); public static class TypeFactory extends Added: branches/cdom/code/src/java/pcgen/core/DomainList.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/DomainList.java (rev 0) +++ branches/cdom/code/src/java/pcgen/core/DomainList.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -0,0 +1,8 @@ +package pcgen.core; + +public class DomainList extends CDOMListObject<Domain> +{ + + // No additional Functionality :) + +} Modified: branches/cdom/code/src/java/pcgen/core/PCClass.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/PCClass.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/pcgen/core/PCClass.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -6783,6 +6783,10 @@ // } // theAutoAbilities.put(aCategory, aLevel, null); // } + + /* + * BEGIN CDOM CODE + */ Map<Integer, PCClassLevel> levelMap = new HashMap<Integer, PCClassLevel>(); @@ -6816,5 +6820,20 @@ { return spi != null; } + + public int getCDOMLevel(PCClassLevel pcl) + { + if (this.equals(pcl.getSource())) + { + for (Map.Entry<Integer, PCClassLevel> me : levelMap.entrySet()) + { + if (me.getValue().equals(pcl)) + { + return me.getKey().intValue(); + } + } + } + return -1; + } } Modified: branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -51,6 +51,8 @@ import java.util.TreeSet; import pcgen.base.formula.Formula; +import pcgen.base.formula.Resolver; +import pcgen.base.graph.visitor.DirectedBreadthFirstTraverseAlgorithm; import pcgen.base.graph.visitor.DirectedNodeWeightCalculation; import pcgen.base.util.DoubleKeyMap; import pcgen.base.util.HashMapToList; @@ -58,6 +60,7 @@ import pcgen.cdom.base.CDOMObject; import pcgen.cdom.base.PrereqObject; import pcgen.cdom.content.EquipmentSet; +import pcgen.cdom.content.SpellResistance; import pcgen.cdom.enumeration.AssociationKey; import pcgen.cdom.enumeration.Gender; import pcgen.cdom.enumeration.IntegerKey; @@ -65,6 +68,8 @@ import pcgen.cdom.graph.PCGenGraph; import pcgen.cdom.graph.PCGraphEdge; import pcgen.cdom.helper.EquipmentSetFacade; +import pcgen.cdom.inst.PCClassLevel; +import pcgen.cdom.mode.Size; import pcgen.core.bonus.Bonus; import pcgen.core.bonus.BonusObj; import pcgen.core.character.CharacterSpell; @@ -109,6 +114,7 @@ public final class PlayerCharacter extends Observable implements Cloneable, VariableContainer { + private static final Class<SpellResistance> SPELL_RESISTANCE_CLASS = SpellResistance.class; // Constants for use in getBonus /** ATTACKBONUS = 0 */ public static final int ATTACKBONUS = 0; @@ -17815,6 +17821,163 @@ return maxVal; } + /** + * Determine the character's reach. This is based on their race, any applied + * templates and any other bonuses to reach. + * + * @return The reach radius. + */ + public int getCDOMReach() + { + List<Race> list = activeGraph.getGrantedNodeList(Race.class); + int reach = 0; + for (Race r : list) + { + Integer rh = r.get(IntegerKey.REACH); + if (rh != null) + { + reach = rh.intValue(); + } + } + + // Scan templates for any overrides + List<PCTemplate> tlist = activeGraph.getGrantedNodeList(PCTemplate.class); + for (PCTemplate t : tlist) + { + Integer th = t.get(IntegerKey.REACH); + if (th != null) + { + reach = th.intValue(); + } + } + reach += (int) getTotalBonusTo("COMBAT", "REACH"); + return reach; + } + + public int totalCDOMMonsterLevels() + { + List<PCClass> classlist = activeGraph.getGrantedNodeList(PCClass.class); + List<PCClassLevel> levellist = activeGraph.getGrantedNodeList(PCClassLevel.class); + int totalLevels = 0; + for (PCClass pcClass : classlist) + { + Boolean isM = pcClass.get(ObjectKey.IS_MONSTER); + if (isM != null && isM.booleanValue()) + { + int classLevel = 0; + for (PCClassLevel pcl : levellist) + { + int level = pcClass.getCDOMLevel(pcl); + classLevel = Math.max(classLevel, level); + } + // Techically if classLevel == -1 we have a VERY funky PC + // but we'll let that fly for now + if (classLevel >= 0) + { + totalLevels += classLevel; + } + } + } + return totalLevels; + } + + public int calcCharacterSR() + { + DirectedBreadthFirstTraverseAlgorithm<PrereqObject, PCGraphEdge> trav = + new DirectedBreadthFirstTraverseAlgorithm<PrereqObject, PCGraphEdge>( + activeGraph) + { + @Override + protected boolean canTraverseEdge(PCGraphEdge edge, + PrereqObject gn, int type) + { + return !(gn instanceof Equipment) + && super.canTraverseEdge(edge, gn, type); + } + }; + trav.traverseFromNode(activeGraph.getRoot()); + Set<PrereqObject> list = trav.getVisitedNodes(); + int res = 0; + for (PrereqObject pro : list) + { + if (SPELL_RESISTANCE_CLASS.isInstance(pro)) + { + SpellResistance sr = SPELL_RESISTANCE_CLASS.cast(pro); + res = Math.max(res, sr.getReduction().resolve(this, "")); + } + } + res += (int) getTotalBonusTo("MISC", "SR"); + // + // This would make more sense to just not add in the first place... + // + res -= (int) getEquipmentBonusTo("MISC", "SR"); + return res; + } + + public Size getCDOMSize() + { + Resolver<Size> resolver = null; + List<Race> list = activeGraph.getGrantedNodeList(Race.class); + int mod = 0; + for (Race r : list) + { + Resolver<Size> res = r.get(ObjectKey.SIZE); + if (res != null) + { + resolver = res; + } + // Now see if there is a HD advancement in size + // (Such as for Dragons) + for (int i = 0; i < r.sizesAdvancedCDOM(totalCDOMMonsterLevels()); ++i) + { + mod++; + } + } + + // Scan templates for any overrides + List<PCTemplate> tlist = activeGraph.getGrantedNodeList(PCTemplate.class); + for (PCTemplate t : tlist) + { + Resolver<Size> res = t.get(ObjectKey.SIZE); + if (res != null) + { + resolver = res; + } + } + // Now check and see if a class has modified + // the size of the character with something like: + // BONUS:SIZEMOD|NUMBER|+1 + mod += (int) getTotalBonusTo("SIZEMOD", "NUMBER"); + + if (resolver == null) + { + return Size.getConstant(0); + } + + Size size = resolver.resolve(); + while (mod < 0) + { + Size prev = size.getPreviousSize(); + if (prev == null) + { + return size; + } + size = prev; + mod++; + } + while (mod > 0) + { + Size next = size.getNextSize(); + if (next == null) + { + return size; + } + size = next; + mod--; + } + return size; + } + // public double getBonusValue(final String aBonusType, final String // aBonusName ) // { Modified: branches/cdom/code/src/java/pcgen/core/Race.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/Race.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/pcgen/core/Race.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -23,7 +23,6 @@ package pcgen.core; import java.awt.geom.Point2D; -import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; @@ -31,6 +30,7 @@ import java.util.Map; import java.util.StringTokenizer; +import pcgen.cdom.enumeration.ListKey; import pcgen.core.bonus.BonusObj; import pcgen.core.prereq.Prerequisite; import pcgen.core.utils.CoreUtility; @@ -1177,4 +1177,24 @@ { return bonusSkillList; } + + /* + * BEGIN CDOM CODE + */ + int sizesAdvancedCDOM(int currentHD) + { + List<Integer> list = getListFor(ListKey.HITDICE_ADVANCEMENT); + if (list != null) + { + for (int x = 0; x < list.size(); x++) + { + int listDie = list.get(x).intValue(); + if ((currentHD <= listDie) || (listDie == -1)) + { + return x; + } + } + } + return 0; + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreReachTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreReachTester.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreReachTester.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -72,4 +72,23 @@ { return "REACH"; //$NON-NLS-1$ } + + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int runningTotal; + try + { + int targetReach = Integer.parseInt(prereq.getOperand()); + + runningTotal = + prereq.getOperator().compare(character.getCDOMReach(), + targetReach); + } + catch (NumberFormatException nfe) + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreReach.error.badly_formed", prereq.getOperand())); //$NON-NLS-1$ + } + return countedTotal(prereq, runningTotal); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreRegionTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreRegionTester.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreRegionTester.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -81,4 +81,29 @@ return "REGION"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + final String requiredRegion = prereq.getKey().toUpperCase(); + final String characterRegion = character.getFullRegion().toUpperCase(); + + final boolean sameRegion = characterRegion.startsWith(requiredRegion); + + int runningTotal; + if (prereq.getOperator().equals(PrerequisiteOperator.EQ)) + { + runningTotal = sameRegion ? 1 : 0; + } + else if (prereq.getOperator().equals(PrerequisiteOperator.NEQ)) + { + runningTotal = sameRegion ? 0 : 1; + } + else + { + throw new PrerequisiteException(PropertyFactory.getFormattedString( + "PreRegion.error.invalid_comparator", prereq.toString())); //$NON-NLS-1$ + } + + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSpellResistanceTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSpellResistanceTester.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSpellResistanceTester.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -29,6 +29,7 @@ import pcgen.core.PlayerCharacter; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; /** @@ -61,4 +62,13 @@ return "SR"; //$NON-NLS-1$ } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + { + int requiredSR = Integer.parseInt(prereq.getOperand()); + int characterSR = character.calcCharacterSR(); + int runningTotal = + prereq.getOperator().compare(characterSR, requiredSR); + return countedTotal(prereq, runningTotal); + } + } Modified: branches/cdom/code/src/utest/plugin/pretokens/test/PreDamageReductionTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreDamageReductionTesterTest.java 2007-05-28 22:20:13 UTC (rev 3069) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreDamageReductionTesterTest.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -109,6 +109,18 @@ } @Test + public void testExactOr() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + DamageReduction tenOne = + DamageReduction.getDamageReduction("10/+1 or +2"); + grantObject(tenOne); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test public void testSurplus() throws PrerequisiteException { Prerequisite prereq = getOnePrereq(); @@ -120,8 +132,8 @@ } // TODO Need to consider inverted? !PRE? - + // TODO Need to test DRs with or and and - + // TODO Need to test DRs that use variables... } Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreReachTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreReachTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreReachTesterTest.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -0,0 +1,198 @@ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.IntegerKey; +import pcgen.core.Language; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.Race; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreReachTesterTest extends AbstractCDOMPreTestTestCase<Race> +{ + + PreReachTester tester = new PreReachTester(); + + @Override + public Class<Race> getCDOMClass() + { + return Race.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + private String getKind() + { + return "REACH"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public Prerequisite getOnePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getTwoPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("2"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testInvalidCount() + { + Prerequisite prereq = getOnePrereq(); + prereq.setOperand("x"); + try + { + getTest().passesCDOM(prereq, pc); + fail(); + } + catch (PrerequisiteException pe) + { + // OK (operand should be a number) + } + catch (NumberFormatException pe) + { + // OK (operand should be a number) + } + } + + @Test + public void testRace() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject human = grantCDOMObject("Human"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(IntegerKey.REACH, Integer.valueOf(1)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.REACH, Integer.valueOf(2)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.REACH, Integer.valueOf(0)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testRaceTemplate() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject human = grantCDOMObject("Human"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(IntegerKey.REACH, Integer.valueOf(3)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + PObject templ = getObject(PCTemplate.class, "Templ"); + grantObject(templ); + templ.put(IntegerKey.REACH, Integer.valueOf(1)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.REACH, Integer.valueOf(0)); + templ.put(IntegerKey.REACH, Integer.valueOf(4)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GTEQ); + human.put(IntegerKey.REACH, Integer.valueOf(4)); + templ.put(IntegerKey.REACH, Integer.valueOf(0)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject falseObj = grantFalseObject("Wild Mage"); + falseObj.put(IntegerKey.REACH, Integer.valueOf(1)); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? + + // TODO Need to test BONUS impacting REACH +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSizeTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSizeTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSizeTesterTest.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -0,0 +1,228 @@ +package plugin.pretokens.test; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.formula.FixedSizeResolver; +import pcgen.cdom.mode.Size; +import pcgen.core.Language; +import pcgen.core.PCTemplate; +import pcgen.core.PObject; +import pcgen.core.Race; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSizeTesterTest extends AbstractCDOMPreTestTestCase<Race> +{ + + PreSizeTester tester = new PreSizeTester(); + + private static boolean classSetUpFired = false; + + @BeforeClass + public void classSetUp() + { + classSetUpFired = true; + Size.constructConstant("T", 0); + Size.constructConstant("S", 1); + Size.constructConstant("M", 2); + Size.constructConstant("L", 3); + Size.constructConstant("H", 4); + } + + @Override + @Before + public void setUp() + { + super.setUp(); + if (!classSetUpFired) + { + classSetUp(); + } + } + + @Override + public Class<Race> getCDOMClass() + { + return Race.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + private String getKind() + { + return "SIZE"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + private FixedSizeResolver getSmallSize() + { + return new FixedSizeResolver(Size.valueOf("S")); + } + + private FixedSizeResolver getMediumSize() + { + return new FixedSizeResolver(Size.valueOf("M")); + } + + private FixedSizeResolver getLargeSize() + { + return new FixedSizeResolver(Size.valueOf("L")); + } + + public Prerequisite getMediumPrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("M"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + public Prerequisite getLargePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("L"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testRace() throws PrerequisiteException + { + Prerequisite prereq = getMediumPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject human = grantCDOMObject("Human"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(ObjectKey.SIZE, getSmallSize()); + prereq.setOperator(PrerequisiteOperator.GTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(ObjectKey.SIZE, getMediumSize()); + prereq.setOperator(PrerequisiteOperator.GTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + human.put(ObjectKey.SIZE, getLargeSize()); + prereq.setOperator(PrerequisiteOperator.GTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testRaceTemplate() throws PrerequisiteException + { + Prerequisite prereq = getMediumPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject human = grantCDOMObject("Human"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(ObjectKey.SIZE, getLargeSize()); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + PObject templ = getObject(PCTemplate.class, "Templ"); + grantObject(templ); + human.put(ObjectKey.SIZE, getMediumSize()); + prereq.setOperator(PrerequisiteOperator.GTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + human.put(ObjectKey.SIZE, getLargeSize()); + templ.put(ObjectKey.SIZE, getSmallSize()); + prereq.setOperator(PrerequisiteOperator.GTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + human.put(ObjectKey.SIZE, getSmallSize()); + templ.put(ObjectKey.SIZE, getLargeSize()); + prereq.setOperator(PrerequisiteOperator.GTEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.NEQ); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LTEQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.LT); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.GT); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + prereq.setOperator(PrerequisiteOperator.EQ); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testFalseObject() throws PrerequisiteException + { + Prerequisite prereq = getMediumPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject falseObj = grantFalseObject("Wild Mage"); + falseObj.put(ObjectKey.SIZE, getLargeSize()); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? + + // TODO Need to take into account BONUSes to Size + + // TODO Need to test with Formula Resolvers + + // TODO Need to test with Monster Hit Die Advancement + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellResistanceTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellResistanceTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSpellResistanceTesterTest.java 2007-05-28 23:36:36 UTC (rev 3070) @@ -0,0 +1,185 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +import pcgen.cdom.base.FormulaFactory; +import pcgen.cdom.base.PrereqObject; +import pcgen.cdom.content.SpellResistance; +import pcgen.cdom.graph.PCGenGraph; +import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.core.Equipment; +import pcgen.core.PlayerCharacter; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSpellResistanceTesterTest extends TestCase +{ + + PreSpellResistanceTester tester = new PreSpellResistanceTester(); + + PlayerCharacter pc; + + @Override + @Before + public void setUp() + { + pc = new PlayerCharacter(false); + } + + public String getKind() + { + return "SR"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + public Prerequisite getOnePrereq() + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setOperand("15"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testInvalidCount() + { + Prerequisite prereq = getOnePrereq(); + prereq.setOperand("x"); + try + { + getTest().passesCDOM(prereq, pc); + fail(); + } + catch (PrerequisiteException pe) + { + // OK (operand should be a number) + } + catch (NumberFormatException pe) + { + // OK (operand should be a number) + } + } + + public PCGraphGrantsEdge grantObject(PrereqObject obj) + { + return grantObject(pc.getActiveGraph().getRoot(), obj); + } + + public PCGraphGrantsEdge grantObject(PrereqObject parent, PrereqObject child) + { + PCGenGraph graph = pc.getActiveGraph(); + graph.addNode(child); + PCGraphGrantsEdge edge = + new PCGraphGrantsEdge(parent, child, "TestCase"); + graph.addEdge(edge); + return edge; + } + + @Test + public void testInsufficient() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + SpellResistance five = + new SpellResistance(FormulaFactory.getFormulaFor(5)); + grantObject(five); + // Insufficient + assertEquals(0, getTest().passesCDOM(prereq, pc)); + SpellResistance ten = + new SpellResistance(FormulaFactory.getFormulaFor(10)); + grantObject(ten); + // Insufficient + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testExact() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + SpellResistance five = + new SpellResistance(FormulaFactory.getFormulaFor(5)); + grantObject(five); + // Insufficient + assertEquals(0, getTest().passesCDOM(prereq, pc)); + SpellResistance fifteen = + new SpellResistance(FormulaFactory.getFormulaFor(15)); + grantObject(fifteen); + // Okay + assertEquals(1, getTest().passesCDOM(prereq, pc)); + SpellResistance six = + new SpellResistance(FormulaFactory.getFormulaFor(6)); + grantObject(six); + // Okay, testing max not last + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testSurplus() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + SpellResistance twenty = + new SpellResistance(FormulaFactory.getFormulaFor(20)); + grantObject(twenty); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testInsufficientEquipment() throws PrerequisiteException + { + Prerequisite prereq = getOnePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + SpellResistance five = + new SpellResistance(FormulaFactory.getFormulaFor(5)); + grantObject(five); + // Insufficient + assertEquals(0, getTest().passesCDOM(prereq, pc)); + SpellResistance fifteen = + new SpellResistance(FormulaFactory.getFormulaFor(15)); + Equipment eq = new Equipment(); + grantObject(eq); + grantObject(eq, fifteen); + // Insufficient (on equipment) + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + // TODO Need to consider inverted? !PRE? + + // TODO Need to test with BONUSES + + // TODO Need to test SRs that use variables... + +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-05-28 23:55:49
|
Revision: 3071 http://svn.sourceforge.net/pcgen/?rev=3071&view=rev Author: thpr Date: 2007-05-28 16:55:50 -0700 (Mon, 28 May 2007) Log Message: ----------- CDOM: VFEAT as a Token ...and some other minor changes Modified Paths: -------------- branches/cdom/code/src/java/pcgen/base/util/HashMapToList.java branches/cdom/code/src/java/pcgen/cdom/base/Constants.java branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLstToken.java branches/cdom/code/src/java/plugin/lsttokens/KitLst.java branches/cdom/code/src/java/plugin/lsttokens/VFeatLst.java branches/cdom/code/src/java/plugin/lsttokens/pcclass/AdddomainsToken.java branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java branches/cdom/code/src/utest/plugin/lsttokens/LangAutoLstTest.java branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java Added Paths: ----------- branches/cdom/code/src/utest/plugin/lsttokens/VFeatLstTest.java Modified: branches/cdom/code/src/java/pcgen/base/util/HashMapToList.java =================================================================== --- branches/cdom/code/src/java/pcgen/base/util/HashMapToList.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/java/pcgen/base/util/HashMapToList.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -23,6 +23,7 @@ package pcgen.base.util; import java.util.ArrayList; +import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -132,10 +133,10 @@ * The key indicating which List the objects in the given List * should be added to. * @param list - * A List containing the items to be added to the List for the - * given key. + * A Collection containing the items to be added to the List for + * the given key. */ - public void addAllToListFor(K key, List<V> list) + public void addAllToListFor(K key, Collection<V> list) { if (list == null || list.isEmpty()) { Modified: branches/cdom/code/src/java/pcgen/cdom/base/Constants.java =================================================================== --- branches/cdom/code/src/java/pcgen/cdom/base/Constants.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/java/pcgen/cdom/base/Constants.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -52,6 +52,12 @@ public static final String LST_TYPE_OLD = "TYPE."; + public static final String LST_CROSSCLASS = "CROSSCLASS"; + + public static final String LST_EXCLUSIVE = "EXCLUSIVE"; + + public static final String LST_CLASS = "CLASS"; + public static final String LST_CLASS_DOT = "CLASS."; public static final String LST_CHOOSE = "CHOOSE:"; @@ -107,4 +113,6 @@ public static final String LST_LIST = "LIST"; + public static final String LST_NORANK = "NORANK"; + } Modified: branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLstToken.java =================================================================== --- branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLstToken.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/java/pcgen/persistence/lst/RemoveLstToken.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -19,6 +19,7 @@ import pcgen.core.PObject; import pcgen.persistence.LoadContext; +import pcgen.persistence.PersistenceLayerException; /** * <code>RemoveLstToken</code> @@ -29,7 +30,8 @@ { public boolean parse(PObject target, String value, int level); - public boolean parse(LoadContext context, PObject obj, String string); + public boolean parse(LoadContext context, PObject obj, String string) + throws PersistenceLayerException; public String[] unparse(LoadContext context, PObject object); } Modified: branches/cdom/code/src/java/plugin/lsttokens/KitLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/KitLst.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/java/plugin/lsttokens/KitLst.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -34,7 +34,7 @@ import pcgen.cdom.base.CDOMSimpleSingleRef; import pcgen.cdom.base.Constants; import pcgen.cdom.base.LSTWriteable; -import pcgen.cdom.content.ChoiceSet; +import pcgen.cdom.helper.ChoiceSet; import pcgen.core.Kit; import pcgen.core.PObject; import pcgen.persistence.GraphChanges; @@ -91,6 +91,7 @@ + " must be > 0"); return false; } + //TODO Kit is actually a ChooseSet combined with a ADD:KIT or something like that... cl = new ChoiceSet<CDOMSimpleSingleRef<Kit>>(count, tok .countTokens()); Modified: branches/cdom/code/src/java/plugin/lsttokens/VFeatLst.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/VFeatLst.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/java/plugin/lsttokens/VFeatLst.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -1,13 +1,45 @@ package plugin.lsttokens; +import java.io.StringWriter; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.SortedSet; +import java.util.StringTokenizer; +import java.util.TreeSet; + +import pcgen.base.lang.StringUtil; +import pcgen.base.util.HashMapToList; +import pcgen.cdom.base.AssociatedPrereqObject; +import pcgen.cdom.base.CDOMCategorizedSingleRef; +import pcgen.cdom.base.CDOMObject; +import pcgen.cdom.base.CategorizedCDOMReference; +import pcgen.cdom.base.LSTWriteable; +import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.cdom.enumeration.AbilityNature; +import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.cdom.util.ReferenceUtilities; +import pcgen.core.Ability; +import pcgen.core.Constants; import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.persistence.GraphChanges; +import pcgen.persistence.LoadContext; import pcgen.persistence.PersistenceLayerException; +import pcgen.persistence.lst.AbstractToken; import pcgen.persistence.lst.GlobalLstToken; +import pcgen.persistence.lst.output.prereq.PrerequisiteWriter; import pcgen.persistence.lst.utils.FeatParser; +import pcgen.persistence.lst.utils.TokenUtilities; -public class VFeatLst implements GlobalLstToken +public class VFeatLst extends AbstractToken implements GlobalLstToken { + private static final Class<Ability> ABILITY_CLASS = Ability.class; + + @Override public String getTokenName() { return "VFEAT"; @@ -20,4 +52,107 @@ return true; } + public boolean parse(LoadContext context, CDOMObject obj, String value) + throws PersistenceLayerException + { + if (isEmpty(value) || hasIllegalSeparator('|', value)) + { + return false; + } + + StringTokenizer tok = new StringTokenizer(value, Constants.PIPE); + AbilityCategory ac = AbilityCategory.FEAT; + AbilityNature an = AbilityNature.AUTOMATIC; + + while (tok.hasMoreTokens()) + { + CDOMCategorizedSingleRef<Ability> ability = + context.ref.getCDOMReference(ABILITY_CLASS, ac, tok + .nextToken()); + PCGraphGrantsEdge edge = + context.graph.grant(getTokenName(), obj, ability); + edge.setAssociation(AssociationKey.ABILITY_NATURE, an); + } + return true; + } + + public String[] unparse(LoadContext context, CDOMObject obj) + { + GraphChanges<Ability> changes = + context.graph.getChangesFromToken(getTokenName(), obj, + ABILITY_CLASS); + if (changes == null) + { + return null; + } + Collection<LSTWriteable> added = changes.getAdded(); + if (added == null || added.isEmpty()) + { + // Zero indicates no Token + return null; + } + HashMapToList<Set<Prerequisite>, LSTWriteable> m = + new HashMapToList<Set<Prerequisite>, LSTWriteable>(); + for (LSTWriteable ab : added) + { + AssociatedPrereqObject assoc = changes.getAddedAssociation(ab); + AbilityNature an = + assoc.getAssociation(AssociationKey.ABILITY_NATURE); + if (!AbilityNature.AUTOMATIC.equals(an)) + { + context.addWriteMessage("Abilities awarded by " + + getTokenName() + " must be of AUTOMATIC AbilityNature"); + return null; + } + if (!AbilityCategory.FEAT + .equals(((CategorizedCDOMReference<Ability>) ab) + .getCDOMCategory())) + { + context.addWriteMessage("Abilities awarded by " + + getTokenName() + " must be of CATEGORY FEAT"); + return null; + } + m.addToListFor(new HashSet<Prerequisite>(assoc + .getPrerequisiteList()), ab); + } + + PrerequisiteWriter prereqWriter = new PrerequisiteWriter(); + SortedSet<LSTWriteable> set = + new TreeSet<LSTWriteable>(TokenUtilities.WRITEABLE_SORTER); + + Set<String> list = new TreeSet<String>(); + + for (Set<Prerequisite> prereqs : m.getKeySet()) + { + List<LSTWriteable> abilities = m.getListFor(prereqs); + set.clear(); + set.addAll(abilities); + String ab = ReferenceUtilities.joinLstFormat(set, Constants.PIPE); + if (prereqs != null && !prereqs.isEmpty()) + { + TreeSet<String> prereqSet = new TreeSet<String>(); + for (Prerequisite p : prereqs) + { + StringWriter swriter = new StringWriter(); + try + { + prereqWriter.write(swriter, p); + } + catch (PersistenceLayerException e) + { + context.addWriteMessage("Error writing Prerequisite: " + + e); + return null; + } + prereqSet.add(swriter.toString()); + } + ab = + ab + Constants.PIPE + + StringUtil.join(prereqSet, Constants.PIPE); + } + list.add(ab); + } + return list.toArray(new String[list.size()]); + } + } Modified: branches/cdom/code/src/java/plugin/lsttokens/pcclass/AdddomainsToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/pcclass/AdddomainsToken.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/java/plugin/lsttokens/pcclass/AdddomainsToken.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -29,7 +29,7 @@ import pcgen.cdom.base.CDOMReference; import pcgen.cdom.base.Constants; import pcgen.cdom.base.LSTWriteable; -import pcgen.cdom.content.ChoiceSet; +import pcgen.cdom.helper.ChoiceSet; import pcgen.cdom.util.ReferenceUtilities; import pcgen.core.Domain; import pcgen.core.Globals; @@ -129,6 +129,7 @@ StringTokenizer tok = new StringTokenizer(value, Constants.DOT); + //TODO This is a list (*Domains), not a ChoiceSet ChoiceSet<CDOMReference<Domain>> cl = new ChoiceSet<CDOMReference<Domain>>(1, tok.countTokens()); while (tok.hasMoreTokens()) Modified: branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java =================================================================== --- branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/java/plugin/lsttokens/template/HitdieToken.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -92,6 +92,9 @@ + getTokenName() + ": " + value); return false; } + // TODO Need to test for empty TYPE as well as failed + // leading and trailing . (needs to happen across ALL + // getCDOMTypeReference items) owner = context.ref.getCDOMTypeReference(PCCLASS_CLASS, substring.split("\\.")); Modified: branches/cdom/code/src/utest/plugin/lsttokens/LangAutoLstTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/LangAutoLstTest.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/utest/plugin/lsttokens/LangAutoLstTest.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -19,7 +19,6 @@ import pcgen.core.Language; import pcgen.core.PCTemplate; -import pcgen.core.PObject; import pcgen.persistence.lst.GlobalLstToken; import pcgen.persistence.lst.LstObjectFileLoader; import pcgen.persistence.lst.PCTemplateLoader; Modified: branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java 2007-05-28 23:36:36 UTC (rev 3070) +++ branches/cdom/code/src/utest/plugin/lsttokens/TokenGlobalTestSuite.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -34,7 +34,7 @@ SourceWebLstTest.class, SpellLevelLstTest.class, SpellsLstTest.class, SrLstTest.class, TempdescLstTest.class, TemplateLstTest.class, TypeLstTest.class, UdamLstTest.class, UmultLstTest.class, - UnencumberedmoveLstTest.class, VisionLstTest.class}) + UnencumberedmoveLstTest.class, VFeatLstTest.class, VisionLstTest.class}) public class TokenGlobalTestSuite extends TestSuite { // No contents, see annotations Added: branches/cdom/code/src/utest/plugin/lsttokens/VFeatLstTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/VFeatLstTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/lsttokens/VFeatLstTest.java 2007-05-28 23:55:50 UTC (rev 3071) @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.lsttokens; + +import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.core.Ability; +import pcgen.core.PCTemplate; +import pcgen.persistence.LoadContext; +import pcgen.persistence.lst.GlobalLstToken; +import pcgen.persistence.lst.LstObjectFileLoader; +import pcgen.persistence.lst.PCTemplateLoader; +import plugin.lsttokens.testsupport.AbstractGlobalListTokenTestCase; + +public class VFeatLstTest extends AbstractGlobalListTokenTestCase<Ability> +{ + + @Override + public char getJoinCharacter() + { + return '|'; + } + + @Override + public Class<Ability> getTargetClass() + { + return Ability.class; + } + + @Override + public boolean isTypeLegal() + { + return false; + } + + @Override + public boolean isAllLegal() + { + return false; + } + + @Override + public boolean isClearDotLegal() + { + return false; + } + + @Override + public boolean isClearLegal() + { + return false; + } + + static GlobalLstToken token = new VFeatLst(); + static PCTemplateLoader loader = new PCTemplateLoader(); + + @Override + public LstObjectFileLoader<PCTemplate> getLoader() + { + return loader; + } + + @Override + public Class<PCTemplate> getCDOMClass() + { + return PCTemplate.class; + } + + @Override + public GlobalLstToken getToken() + { + return token; + } + + @Override + protected void construct(LoadContext loadContext, String one) + { + Ability obj = loadContext.ref.constructCDOMObject(Ability.class, one); + loadContext.ref.reassociateReference(AbilityCategory.FEAT, obj); + } +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <th...@us...> - 2007-06-02 22:08:51
|
Revision: 3111 http://svn.sourceforge.net/pcgen/?rev=3111&view=rev Author: thpr Date: 2007-06-02 15:08:53 -0700 (Sat, 02 Jun 2007) Log Message: ----------- CDOM: More implementation of PRExxx: Tokens Modified Paths: -------------- branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java branches/cdom/code/src/java/plugin/pretokens/test/PreAbilityTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreFeatTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreLanguageTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreRaceTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreShieldProfTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreSkillMultTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreSkillTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreSkillTotTester.java branches/cdom/code/src/java/plugin/pretokens/test/PreWeaponProfTester.java branches/cdom/code/src/utest/plugin/lsttokens/deity/AlignTokenTest.java branches/cdom/code/src/utest/plugin/lsttokens/deity/DomainsTokenTest.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java branches/cdom/code/src/utest/plugin/pretokens/test/PreStatTesterTest.java Added Paths: ----------- branches/cdom/code/src/utest/plugin/pretokens/test/PreFeatTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillMultTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillTesterTest.java branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillTotTesterTest.java Modified: branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java =================================================================== --- branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/pcgen/core/PlayerCharacter.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -17702,8 +17702,19 @@ @Override protected int getEdgeWeight(int weight, PCGraphEdge edge) { + PrereqObject source = edge.getNodeAt(0); Integer i = edge.getAssociation(AssociationKey.WEIGHT); - return weight * (i == null ? 1 : i.intValue()); + int edgeWeight = i == null ? 1 : i.intValue(); + if (source instanceof CDOMObject) + { + CDOMObject cdo = (CDOMObject) source; + Boolean mult = cdo.get(ObjectKey.MULTIPLE_ALLOWED); + if (mult == null || !mult.booleanValue()) + { + return weight <= 0 ? 0 : edgeWeight; + } + } + return weight * edgeWeight; } }; @@ -17983,7 +17994,7 @@ { List<PCGraphEdge> list = activeGraph.getInwardEdgeList(pro); // TODO Need to consider mult yes/no stack yes/no - Set set = new HashSet(); + List set = new ArrayList(); for (PCGraphEdge edge : list) { set.add(edge.getAssociation(AssociationKey.ABILITY_ASSOCIATION)); @@ -17993,13 +18004,27 @@ public <AT extends PObject> List<AT> getAssociated(Ability a) { - // TODO Auto-generated method stub - return null; + List<PCGraphEdge> list = activeGraph.getInwardEdgeList(pro); + // TODO Need to consider mult yes/no stack yes/no + List<AT> set = new ArrayList<AT>(); + for (PCGraphEdge edge : list) + { + set.add(edge.getAssociation(AssociationKey.ABILITY_ASSOCIATION)); + } + return set; } public boolean containsAssociatedKey(Ability a, String assocKey) { - // TODO Auto-generated method stub + List<PCGraphEdge> list = activeGraph.getInwardEdgeList(a); + for (PCGraphEdge edge : list) + { + assoc = edge.getAssociation(AssociationKey.ABILITY_ASSOCIATION); + if (assoc.getKeyName().equals(assocKey)) + { + return true; + } + } return false; } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreAbilityTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreAbilityTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreAbilityTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -513,9 +513,9 @@ String key = prereq.getKey(); String subKey = prereq.getSubKey(); String categoryName = prereq.getCategoryName(); - GameMode gameMode = SettingsHandler.getGame(); - //TODO This doesn't get fetched from game Mode in the long run... - AbilityCategory category = gameMode.getAbilityCategory(categoryName); + pcgen.cdom.enumeration.AbilityCategory category = + pcgen.cdom.enumeration.AbilityCategory.valueOf(categoryName); + //TODO What if CATEGORY=null?? final boolean keyIsAny = key.equalsIgnoreCase("ANY"); //$NON-NLS-1$ boolean keyIsType = key.startsWith("TYPE=") || key.startsWith("TYPE."); //$NON-NLS-1$ //$NON-NLS-2$ boolean subKeyIsType = @@ -542,8 +542,7 @@ String featKey = a.getKeyName(); if (!keyIsAny && keyIsType) { - StringTokenizer tok = - new StringTokenizer(key.substring(5), "."); + StringTokenizer tok = new StringTokenizer(key, "."); // Must match all listed types in order to qualify while (tok.hasMoreTokens()) { Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreFeatTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreFeatTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreFeatTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -433,15 +433,15 @@ List<Ability> list = activeGraph.getGrantedNodeList(Ability.class); ABILITY: for (Ability a : list) { - if (!AbilityCategory.FEAT.equals(a.getCDOMCategory())) + if (!pcgen.cdom.enumeration.AbilityCategory.FEAT.equals(a + .getCDOMCategory())) { continue; } String featKey = a.getKeyName(); if (keyIsType) { - StringTokenizer tok = - new StringTokenizer(key.substring(5), "."); + StringTokenizer tok = new StringTokenizer(key, "."); // Must match all listed types in order to qualify while (tok.hasMoreTokens()) { Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreLanguageTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreLanguageTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreLanguageTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -27,6 +27,7 @@ package plugin.pretokens.test; import java.util.List; +import java.util.StringTokenizer; import pcgen.cdom.enumeration.ListKey; import pcgen.cdom.enumeration.Type; @@ -42,13 +43,15 @@ /** * @author wardc - * + * */ public class PreLanguageTester extends AbstractPrerequisiteTest implements PrerequisiteTest { - /* (non-Javadoc) + /* + * (non-Javadoc) + * * @see pcgen.core.prereq.PrerequisiteTest#passes(pcgen.core.PlayerCharacter) */ @Override @@ -85,7 +88,9 @@ return countedTotal(prereq, runningTotal); } - /* (non-Javadoc) + /* + * (non-Javadoc) + * * @see pcgen.core.prereq.PrerequisiteTest#kindsHandled() */ public String kindHandled() @@ -93,7 +98,8 @@ return "LANG"; //$NON-NLS-1$ } - public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException { final String requiredLang = prereq.getKey(); final int requiredNumber = Integer.parseInt(prereq.getOperand()); @@ -106,19 +112,27 @@ System.err.println(runningTotal); System.err.println(activeGraph.getGrantedNodeList(Language.class)); } - else if (requiredLang.startsWith("TYPE.") || requiredLang.startsWith("TYPE=")) + else if (requiredLang.startsWith("TYPE.") + || requiredLang.startsWith("TYPE=")) { - Type requiredType = Type.getConstant(requiredLang.substring(5)); List<Language> list = activeGraph.getGrantedNodeList(Language.class); if (list != null) { - for (Language lang : list) + LANG: for (Language lang : list) { - if (lang.containsInList(ListKey.TYPE, requiredType)) + StringTokenizer tok = + new StringTokenizer(requiredLang.substring(5), "."); + // Must match all listed types in order to qualify + while (tok.hasMoreTokens()) { - runningTotal++; + Type requiredType = Type.getConstant(tok.nextToken()); + if (!lang.containsInList(ListKey.TYPE, requiredType)) + { + continue LANG; + } } + runningTotal++; } } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreRaceTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreRaceTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreRaceTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -156,11 +156,10 @@ if (requiredRace.startsWith("TYPE=") || requiredRace.startsWith("TYPE.")) //$NON-NLS-1$ //$NON-NLS-2$ { - for (Race r : list) + RACE: for (Race r : list) { StringTokenizer tok = new StringTokenizer(requiredRace.substring(5), "."); - boolean match = true; // // Must match all listed types in order to qualify // @@ -169,14 +168,10 @@ Type requiredType = Type.getConstant(tok.nextToken()); if (!r.containsInList(ListKey.TYPE, requiredType)) { - match = false; - break; + continue RACE; } } - if (match) - { - ++runningTotal; - } + runningTotal++; } } else if (requiredRace.startsWith("RACETYPE=") || requiredRace.startsWith("RACETYPE.")) //$NON-NLS-1$ //$NON-NLS-2$ Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreShieldProfTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreShieldProfTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreShieldProfTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -27,6 +27,7 @@ package plugin.pretokens.test; import java.util.List; +import java.util.StringTokenizer; import pcgen.cdom.enumeration.ListKey; import pcgen.cdom.enumeration.Type; @@ -40,13 +41,15 @@ /** * @author wardc - * + * */ public class PreShieldProfTester extends AbstractPrerequisiteTest implements PrerequisiteTest { - /* (non-Javadoc) + /* + * (non-Javadoc) + * * @see pcgen.core.prereq.PrerequisiteTest#passes(pcgen.core.PlayerCharacter) */ @Override @@ -74,7 +77,9 @@ return countedTotal(prereq, runningTotal); } - /* (non-Javadoc) + /* + * (non-Javadoc) + * * @see pcgen.core.prereq.PrerequisiteTest#kindsHandled() */ public String kindHandled() @@ -82,24 +87,32 @@ return "SHIELDPROF"; //$NON-NLS-1$ } - public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException { final int numberRequired = Integer.parseInt(prereq.getOperand()); int runningTotal = 0; PCGenGraph activeGraph = character.getActiveGraph(); final String aString = prereq.getKey(); - if (aString.startsWith("TYPE.") || aString.startsWith("TYPE=")) //$NON-NLS-1$ //$NON-NLS-2$ + if (aString.startsWith("TYPE.") || aString.startsWith("TYPE=")) //$NON-NLS-1$ //$NON-NLS-2$ { - Type requiredType = Type.getConstant(aString.substring(5)); List<ShieldProf> list = activeGraph.getGrantedNodeList(ShieldProf.class); - for (ShieldProf sp : list) + SHIELDPROF: for (ShieldProf sp : list) { - if (sp.containsInList(ListKey.TYPE, requiredType)) + StringTokenizer tok = + new StringTokenizer(aString.substring(5), "."); + // Must match all listed types in order to qualify + while (tok.hasMoreTokens()) { - runningTotal++; + Type requiredType = Type.getConstant(tok.nextToken()); + if (!sp.containsInList(ListKey.TYPE, requiredType)) + { + continue SHIELDPROF; + } } + runningTotal++; } } else Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSkillMultTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSkillMultTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSkillMultTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -27,10 +27,16 @@ import java.util.ArrayList; import java.util.List; +import java.util.StringTokenizer; + +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGenGraph; import pcgen.core.PlayerCharacter; import pcgen.core.Skill; import pcgen.core.prereq.AbstractPrerequisiteTest; import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; import pcgen.core.prereq.PrerequisiteTest; import pcgen.util.PropertyFactory; @@ -154,4 +160,82 @@ return foo; } + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException + { + int requiredRanks = Integer.parseInt(prereq.getOperand()); + // Compute the skill name from the Prerequisite + String requiredSkillKey = prereq.getKey().toUpperCase(); + if (prereq.getSubKey() != null) + { + requiredSkillKey += " (" + prereq.getSubKey().toUpperCase() + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + } + int runningTotal = 0; + PCGenGraph graph = character.getActiveGraph(); + if ((requiredSkillKey.startsWith("TYPE.") || requiredSkillKey + .startsWith("TYPE="))) + { + List<Skill> list = graph.getGrantedNodeList(Skill.class); + SKILL: for (Skill aSkill : list) + { + StringTokenizer tok = + new StringTokenizer(requiredSkillKey.substring(5), "."); + // Must match all listed types in order to qualify + while (tok.hasMoreTokens()) + { + Type requiredType = Type.getConstant(tok.nextToken()); + if (!aSkill.containsInList(ListKey.TYPE, requiredType)) + { + continue SKILL; + } + } + if (prereq.getOperator().compare( + character.getTotalWeight(aSkill), requiredRanks) > 0) + { + runningTotal++; + } + } + } + else + { + int percentLoc = requiredSkillKey.lastIndexOf('%'); + if (percentLoc == -1) + { + Skill skill = + graph.getGrantedNode(Skill.class, requiredSkillKey); + if (prereq.getOperator().compare( + character.getTotalWeight(skill), requiredRanks) > 0) + { + runningTotal++; + } + } + else + { + List<Skill> list = graph.getGrantedNodeList(Skill.class); + for (Skill aSkill : list) + { + String aSkillKey = aSkill.getKeyName().toUpperCase(); + if (aSkillKey.startsWith(requiredSkillKey.substring(0, + percentLoc))) + { + if (prereq.getOperator().compare( + character.getTotalWeight(aSkill), requiredRanks) > 0) + { + runningTotal++; + } + } + } + } + } + // // If we are looking for a negative test i.e. !PRESKILL and the PC + // // doesn't have the skill we have to return a match + // if (!foundSkill) + // { + // if (prereq.getOperator() == PrerequisiteOperator.LT) + // { + // runningTotal++; + // } + // } + return countedTotal(prereq, runningTotal); + } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSkillTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSkillTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSkillTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -27,6 +27,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.StringTokenizer; import pcgen.cdom.enumeration.ListKey; import pcgen.cdom.enumeration.Type; @@ -79,7 +80,8 @@ boolean foundMatch = false; boolean foundSkill = false; - final List<Skill> skillList = new ArrayList<Skill>(character.getSkillList()); + final List<Skill> skillList = + new ArrayList<Skill>(character.getSkillList()); for (Skill aSkill : skillList) { final String aSkillKey = aSkill.getKeyName().toUpperCase(); @@ -123,8 +125,7 @@ { foundSkill = true; if (prereq.getOperator().compare( - aSkill.getTotalRank(character).intValue(), - requiredRanks) > 0) + aSkill.getTotalRank(character).intValue(), requiredRanks) > 0) { runningTotal++; } @@ -201,18 +202,25 @@ if ((requiredSkillKey.startsWith("TYPE.") || requiredSkillKey .startsWith("TYPE="))) { - Type requiredType = Type.getConstant(requiredSkillKey.substring(5)); List<Skill> list = graph.getGrantedNodeList(Skill.class); - for (Skill aSkill : list) + SKILL: for (Skill aSkill : list) { - if (aSkill.containsInList(ListKey.TYPE, requiredType)) + StringTokenizer tok = + new StringTokenizer(requiredSkillKey.substring(5), "."); + // Must match all listed types in order to qualify + while (tok.hasMoreTokens()) { - if (prereq.getOperator().compare( - character.getTotalWeight(aSkill), requiredRanks) > 0) + Type requiredType = Type.getConstant(tok.nextToken()); + if (!aSkill.containsInList(ListKey.TYPE, requiredType)) { - runningTotal++; + continue SKILL; } } + if (prereq.getOperator().compare( + character.getTotalWeight(aSkill), requiredRanks) > 0) + { + runningTotal++; + } } } else @@ -257,5 +265,4 @@ // } return countedTotal(prereq, runningTotal); } - } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreSkillTotTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreSkillTotTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreSkillTotTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -26,6 +26,7 @@ */package plugin.pretokens.test; import java.util.List; +import java.util.StringTokenizer; import pcgen.cdom.enumeration.ListKey; import pcgen.cdom.enumeration.Type; @@ -101,8 +102,7 @@ if (foundMatch) { foundSkill = foundMatch; - runningTotal += - aSkill.getTotalRank(character).intValue(); + runningTotal += aSkill.getTotalRank(character).intValue(); if (runningTotal == 0) { foundMatch = false; @@ -180,14 +180,21 @@ if ((requiredSkillKey.startsWith("TYPE.") || requiredSkillKey .startsWith("TYPE="))) { - Type requiredType = Type.getConstant(requiredSkillKey.substring(5)); List<Skill> list = graph.getGrantedNodeList(Skill.class); - for (Skill aSkill : list) + SKILL: for (Skill aSkill : list) { - if (aSkill.containsInList(ListKey.TYPE, requiredType)) + StringTokenizer tok = + new StringTokenizer(requiredSkillKey.substring(5), "."); + // Must match all listed types in order to qualify + while (tok.hasMoreTokens()) { - runningTotal += character.getTotalWeight(aSkill); + Type requiredType = Type.getConstant(tok.nextToken()); + if (!aSkill.containsInList(ListKey.TYPE, requiredType)) + { + continue SKILL; + } } + runningTotal += character.getTotalWeight(aSkill); } } else @@ -213,16 +220,7 @@ } } } - // // If we are looking for a negative test i.e. !PRESKILL and the PC - // // doesn't have the skill we have to return a match - // if (!foundSkill) - // { - // if (prereq.getOperator() == PrerequisiteOperator.LT) - // { - // runningTotal++; - // } - // } - return countedTotal(prereq, runningTotal); + return Math.max(runningTotal, 0); } } Modified: branches/cdom/code/src/java/plugin/pretokens/test/PreWeaponProfTester.java =================================================================== --- branches/cdom/code/src/java/plugin/pretokens/test/PreWeaponProfTester.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/java/plugin/pretokens/test/PreWeaponProfTester.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -27,6 +27,7 @@ package plugin.pretokens.test; import java.util.List; +import java.util.StringTokenizer; import pcgen.cdom.enumeration.ListKey; import pcgen.cdom.enumeration.Type; @@ -44,7 +45,7 @@ /** * @author wardc - * + * */ public class PreWeaponProfTester extends AbstractPrerequisiteTest implements PrerequisiteTest @@ -52,28 +53,35 @@ /** * <b>Tag Name</b>: <code>PREWEAPONPROF:x,y,y</code><br /> - * <b>Variables Used (x)</b>: <i>Number</i> (The number of proficiencies that must match the specified requirements). <br/> - * <b>Variables Used (y)</b>: <i>Text</i> (The name of a weapon proficiency). <br /> - * <b>Variables Used (y)</b>: <code>TYPE.</code><i>Text</i> (The name of a weaponprof type). <br /> - * <b>Variables Used (y)</b>: <code>DEITYWEAPON</code> (The favored weapon of the character's deity). <br /> + * <b>Variables Used (x)</b>: <i>Number</i> (The number of + * proficiencies that must match the specified requirements). <br/> + * <b>Variables Used (y)</b>: <i>Text</i> (The name of a weapon + * proficiency). <br /> + * <b>Variables Used (y)</b>: <code>TYPE.</code><i>Text</i> (The + * name of a weaponprof type). <br /> + * <b>Variables Used (y)</b>: <code>DEITYWEAPON</code> (The + * favored weapon of the character's deity). <br /> * <p /> * <b>What it does:</b><br /> * Sets weapon proficiency requirements. * <p /> - * <b>Examples</b>: <br/> - * <code>PREWEAPONPROF:2,Kama,Katana</code><br /> + * <b>Examples</b>: <br/> <code>PREWEAPONPROF:2,Kama,Katana</code><br /> * Character must have both "Kama" and "Katana". * <p /> * <code>PREWEAPONPROF:1,TYPE.Exotic</code> <br /> - * Character must have proficiency with any one exotic weaponprof type. + * Character must have proficiency with any one exotic + * weaponprof type. * <p /> * <code>PREWEAPONPROF:1,TYPE.Martial,Chain (Spiked)</code> <br /> - * Character must have proficiency with either the Chain (Spiked) or any martial weapon. + * Character must have proficiency with either the Chain + * (Spiked) or any martial weapon. * <p /> * <code>PREWEAPONPROF:1,DEITYWEAPON</code> <br /> - * Weapon Prof in question must be one of the chosen deity's favored weapons. + * Weapon Prof in question must be one of the chosen deity's + * favored weapons. * - * @see pcgen.core.prereq.AbstractPrerequisiteTest#passes(pcgen.core.prereq.Prerequisite, pcgen.core.PlayerCharacter) + * @see pcgen.core.prereq.AbstractPrerequisiteTest#passes(pcgen.core.prereq.Prerequisite, + * pcgen.core.PlayerCharacter) */ @Override public int passes(final Prerequisite prereq, final PlayerCharacter character) @@ -147,7 +155,8 @@ return "WEAPONPROF"; //$NON-NLS-1$ } - public int passesCDOM(Prerequisite prereq, PlayerCharacter character) throws PrerequisiteException + public int passesCDOM(Prerequisite prereq, PlayerCharacter character) + throws PrerequisiteException { int runningTotal = 0; @@ -177,29 +186,45 @@ } else if (aString.startsWith("TYPE.") || aString.startsWith("TYPE=")) //$NON-NLS-1$ //$NON-NLS-2$ { - Type requiredType = Type.getConstant(aString.substring(5)); List<WeaponProf> list = - activeGraph.getGrantedNodeList(WeaponProf.class); + activeGraph.getGrantedNodeList(WeaponProf.class); if (list != null) { - for (WeaponProf wp : list) + WEAPONPROF: for (WeaponProf wp : list) { - if (wp.containsInList(ListKey.TYPE, requiredType)) + StringTokenizer tok = + new StringTokenizer(aString.substring(5), "."); + // Must match all listed types in order to qualify + while (tok.hasMoreTokens()) { - runningTotal++; - } - else - { - final Equipment eq = - EquipmentList.getEquipmentNamed(wp.getKeyName()); - if (eq != null) + Type requiredType = Type.getConstant(tok.nextToken()); + if (!wp.containsInList(ListKey.TYPE, requiredType)) { - if (eq.containsInList(ListKey.TYPE, requiredType)) + Equipment eq = + EquipmentList.getEquipmentNamed(wp + .getKeyName()); + if (eq != null) { - runningTotal++; + StringTokenizer eqtok = + new StringTokenizer(aString + .substring(5), "."); + // Must match all listed types in order to + // qualify + while (eqtok.hasMoreTokens()) + { + Type requiredEqType = + Type.getConstant(tok.nextToken()); + if (!eq.containsInList(ListKey.TYPE, + requiredEqType)) + { + continue WEAPONPROF; + } + } } + continue WEAPONPROF; } } + runningTotal++; } } } Modified: branches/cdom/code/src/utest/plugin/lsttokens/deity/AlignTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/deity/AlignTokenTest.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/utest/plugin/lsttokens/deity/AlignTokenTest.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -20,11 +20,10 @@ import java.net.URISyntaxException; import org.junit.Before; -import org.junit.BeforeClass; import org.junit.Test; -import pcgen.cdom.enumeration.AlignmentType; import pcgen.cdom.enumeration.ObjectKey; +import pcgen.core.Alignment; import pcgen.core.Deity; import pcgen.persistence.PersistenceLayerException; import pcgen.persistence.lst.CDOMToken; @@ -37,33 +36,30 @@ static AlignToken token = new AlignToken(); static DeityLoader loader = new DeityLoader(); - private static boolean classSetUpFired = false; - - @BeforeClass - public static final void ltClassSetUp() throws PersistenceLayerException - { - AlignmentType.getConstant("LG"); - AlignmentType.getConstant("LN"); - AlignmentType.getConstant("LE"); - AlignmentType.getConstant("NG"); - AlignmentType.getConstant("TN"); - AlignmentType.getConstant("NE"); - AlignmentType.getConstant("CG"); - AlignmentType.getConstant("CN"); - AlignmentType.getConstant("CE"); - classSetUpFired = true; - } - @Override @Before public final void setUp() throws PersistenceLayerException, URISyntaxException { super.setUp(); - if (!classSetUpFired) - { - ltClassSetUp(); - } + primaryContext.ref.constructCDOMObject(Alignment.class, "LG"); + primaryContext.ref.constructCDOMObject(Alignment.class, "LN"); + primaryContext.ref.constructCDOMObject(Alignment.class, "LE"); + primaryContext.ref.constructCDOMObject(Alignment.class, "NG"); + primaryContext.ref.constructCDOMObject(Alignment.class, "TN"); + primaryContext.ref.constructCDOMObject(Alignment.class, "NE"); + primaryContext.ref.constructCDOMObject(Alignment.class, "CG"); + primaryContext.ref.constructCDOMObject(Alignment.class, "CN"); + primaryContext.ref.constructCDOMObject(Alignment.class, "CE"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "LG"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "LN"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "LE"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "NG"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "TN"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "NE"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "CG"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "CN"); + secondaryContext.ref.constructCDOMObject(Alignment.class, "CE"); } @Override @@ -84,11 +80,6 @@ return token; } - public Object getConstant(String string) - { - return AlignmentType.valueOf(string); - } - public ObjectKey<?> getObjectKey() { return ObjectKey.ALIGNMENT; Modified: branches/cdom/code/src/utest/plugin/lsttokens/deity/DomainsTokenTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/lsttokens/deity/DomainsTokenTest.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/utest/plugin/lsttokens/deity/DomainsTokenTest.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -60,13 +60,13 @@ @Override public boolean isClearDotLegal() { - return false; + return true; } @Override public boolean isClearLegal() { - return false; + return true; } @Override Modified: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMObjectTestCase.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -91,7 +91,8 @@ Prerequisite p; p = new Prerequisite(); p.setKind(getKind()); - p.setKey("Crossbow (Heavy)"); + p.setKey("Crossbow"); + p.setSubKey("Heavy"); p.setOperand("1"); p.setOperator(PrerequisiteOperator.GTEQ); return p; @@ -215,11 +216,23 @@ } @Test + public void testFalseParen() throws PrerequisiteException + { + Prerequisite prereq = getParenPrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Crossbow"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + } + + @Test public void testParen() throws PrerequisiteException { Prerequisite prereq = getParenPrereq(); // PC Should start without assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Crossbow (Light)"); + assertEquals(0, getTest().passesCDOM(prereq, pc)); grantCDOMObject("Crossbow (Heavy)"); // Has Crossbow (Heavy) assertEquals(1, getTest().passesCDOM(prereq, pc)); Modified: branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/utest/plugin/pretokens/test/AbstractCDOMPreTestTestCase.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -78,8 +78,13 @@ public PCGraphGrantsEdge grantObject(PrereqObject obj) { + return grantObject(pc.getActiveGraph().getRoot(), obj); + } + + protected PCGraphGrantsEdge grantObject(PrereqObject root, PrereqObject obj) + { PCGenGraph graph = pc.getActiveGraph(); - PrereqObject root = graph.getRoot(); + graph.addNode(root); graph.addNode(obj); PCGraphGrantsEdge edge = new PCGraphGrantsEdge(root, obj, "TestCase"); graph.addEdge(edge); Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreFeatTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreFeatTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreFeatTesterTest.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.AbilityCategory; +import pcgen.core.Ability; +import pcgen.core.Language; +import pcgen.core.PObject; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreFeatTesterTest extends AbstractCDOMObjectTestCase<Ability> +{ + + PreFeatTester tester = new PreFeatTester(); + + @Override + public Class<Ability> getCDOMClass() + { + return Ability.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "FEAT"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isAnyLegal() + { + return false; + } + + @Override + public boolean isTestStarting() + { + return false; + } + + @Override + public boolean isTypeLegal() + { + return true; + } + + @Override + public boolean isWildcardLegal() + { + return false; + } + + @Override + public Ability getObject(String s) + { + Ability a = super.getObject(s); + a.setCDOMCategory(AbilityCategory.FEAT); + return a; + } + + + @Test + public void testNotAFeat() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq(); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Ability wrong = super.getObject("Winged Mage"); + wrong.setCDOMCategory(AbilityCategory.Mutation); + grantObject(wrong); + assertEquals(0, getTest().passesCDOM(prereq, pc)); + grantCDOMObject("Winged Mage"); + //Pass, as it's a FEAT + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + //TODO Test subkey TYPE= + //TODO Test subkey TYPE. + //TODO Test Count Multiples on item w/ SubKey + //TODO Test subkey wildcard (%) also make sure to use count, just to get empty wildcard + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillMultTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillMultTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillMultTesterTest.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.Language; +import pcgen.core.PObject; +import pcgen.core.Skill; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSkillMultTesterTest extends + AbstractCDOMWeightedObjectTestCase<Skill> +{ + + PreSkillMultTester tester = new PreSkillMultTester(); + + @Override + public Class<Skill> getCDOMClass() + { + return Skill.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "SKILLMULT"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isTypeLegal() + { + return true; + } +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillTesterTest.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import pcgen.core.Language; +import pcgen.core.PObject; +import pcgen.core.Skill; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSkillTesterTest extends + AbstractCDOMWeightedObjectTestCase<Skill> +{ + + PreSkillTester tester = new PreSkillTester(); + + @Override + public Class<Skill> getCDOMClass() + { + return Skill.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + @Override + public String getKind() + { + return "SKILL"; + } + + @Override + public PrerequisiteTest getTest() + { + return tester; + } + + @Override + public boolean isTypeLegal() + { + return true; + } + +} Added: branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillTotTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillTotTesterTest.java (rev 0) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreSkillTotTesterTest.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -0,0 +1,471 @@ +/* + * Copyright (c) 2007 Tom Parker <th...@us...> + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package plugin.pretokens.test; + +import org.junit.Test; + +import pcgen.cdom.enumeration.AssociationKey; +import pcgen.cdom.enumeration.ListKey; +import pcgen.cdom.enumeration.ObjectKey; +import pcgen.cdom.enumeration.Type; +import pcgen.cdom.graph.PCGraphGrantsEdge; +import pcgen.core.Language; +import pcgen.core.PObject; +import pcgen.core.Skill; +import pcgen.core.prereq.Prerequisite; +import pcgen.core.prereq.PrerequisiteException; +import pcgen.core.prereq.PrerequisiteOperator; +import pcgen.core.prereq.PrerequisiteTest; + +public class PreSkillTotTesterTest extends AbstractCDOMPreTestTestCase<Skill> +{ + + PreSkillTotTester tester = new PreSkillTotTester(); + + @Override + public Class<Skill> getCDOMClass() + { + return Skill.class; + } + + @Override + public Class<? extends PObject> getFalseClass() + { + return Language.class; + } + + public String getKind() + { + return "SKILL.TOT"; + } + + public PrerequisiteTest getTest() + { + return tester; + } + + private boolean isTypeLegal() + { + return true; + } + + public Prerequisite getSimplePrereq(String stat) + { + Prerequisite p; + p = new Prerequisite(); + p.setKind(getKind()); + p.setKey(stat); + p.setOperand("1"); + p.setOperator(PrerequisiteOperator.GTEQ); + return p; + } + + @Test + public void testAssumptions() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq("STR"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + grantObject(strStat); + // no weight on edge implies weight == 1?? + // TODO Should this be one or zero?? + assertEquals(1, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testSimple() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq("STR"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + Skill intStat = getObject("INT"); + PCGraphGrantsEdge intEdge = grantObject(intStat); + intEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + assertEquals(13, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); + assertEquals(15, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(16)); + assertEquals(16, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testMultiple() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq("STR"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + assertEquals(1, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + // Fail, not enough weight on edge + assertEquals(13, getTest().passesCDOM(prereq, pc)); + PObject po = getFalseObject("FOO"); + grantObject(po); + PCGraphGrantsEdge edge2 = grantObject(po, strStat); + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight on edges + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + assertEquals(15, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(3)); + assertEquals(16, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testComplexMultipleImpliedNo() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq("STR"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge + assertEquals(1, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + assertEquals(13, getTest().passesCDOM(prereq, pc)); + PObject foo = getFalseObject("FOO"); + PObject bar = getFalseObject("BAR"); + grantObject(bar); + grantObject(foo); + grantObject(bar, foo); + PCGraphGrantsEdge edge2 = grantObject(foo, strStat); + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + assertEquals(15, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(3)); + assertEquals(16, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testComplexMultipleNo() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq("STR"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge + assertEquals(1, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + // Fail, not enough weight on edge + assertEquals(13, getTest().passesCDOM(prereq, pc)); + PObject foo = getFalseObject("FOO"); + PObject bar = getFalseObject("BAR"); + foo.put(ObjectKey.MULTIPLE_ALLOWED, Boolean.FALSE); + grantObject(bar); + grantObject(foo); + grantObject(bar, foo); + PCGraphGrantsEdge edge2 = grantObject(foo, strStat); + // Fail, not enough weight on edge (second edge no weight) + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight on edges + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + assertEquals(15, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(3)); + assertEquals(16, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testComplexMultipleYes() throws PrerequisiteException + { + Prerequisite prereq = getSimplePrereq("STR"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge + assertEquals(1, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(11)); + // Fail, not enough weight on edge + assertEquals(11, getTest().passesCDOM(prereq, pc)); + PObject foo = getFalseObject("FOO"); + PObject bar = getFalseObject("BAR"); + foo.put(ObjectKey.MULTIPLE_ALLOWED, Boolean.TRUE); + grantObject(bar); + grantObject(foo); + grantObject(bar, foo); + PCGraphGrantsEdge edge2 = grantObject(foo, strStat); + // Fail, not enough weight on edge (second edge no weight) + assertEquals(13, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Pass, not enough weight on edges + assertEquals(13, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + assertEquals(15, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(3)); + assertEquals(17, getTest().passesCDOM(prereq, pc)); + } + + @Test + public void testTypeSimple() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getSimplePrereq("TYPE=Martial"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill intStat = getObject("INT"); + PCGraphGrantsEdge intEdge = grantObject(intStat); + intEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); + // Fail, no weight on str edge (still), no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + // Fail, not enough weight on edge, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); + // Fail, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(16)); + // Fail, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + // Fail, not enough weight on edge, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Fail, not enough weight on edge + assertEquals(13, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); + // Pass, exact value + assertEquals(15, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(16)); + // Pass, more than enough + assertEquals(16, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Weapon")); + // Pass, more than enough + assertEquals(16, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeMultiple() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getSimplePrereq("TYPE=Martial"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + // Fail, not enough weight on edge, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject po = getFalseObject("FOO"); + grantObject(po); + PCGraphGrantsEdge edge2 = grantObject(po, strStat); + // Fail, not enough weight on edge (second edge no weight), no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight on edges, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + // Fail, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + // Fail, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Fail, not enough weight on edge + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + // Pass, exact value + assertEquals(15, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(3)); + // Pass, more than enough + assertEquals(16, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Weapon")); + // Pass, more than enough + assertEquals(16, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeComplexMultipleImpliedNo() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getSimplePrereq("TYPE=Martial"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + // Fail, not enough weight on edge + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject foo = getFalseObject("FOO"); + PObject bar = getFalseObject("BAR"); + grantObject(bar); + grantObject(foo); + grantObject(bar, foo); + PCGraphGrantsEdge edge2 = grantObject(foo, strStat); + // Fail, not enough weight on edge (second edge no weight) + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight on edges + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + // Fail, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + // Fail, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Fail, not enough weight on edge + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + // Pass, exact value + assertEquals(15, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(3)); + // Pass, more than enough + assertEquals(16, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Weapon")); + // Pass, more than enough + assertEquals(16, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeComplexMultipleNo() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getSimplePrereq("TYPE=Martial"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); + // Fail, not enough weight on edge + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject foo = getFalseObject("FOO"); + PObject bar = getFalseObject("BAR"); + foo.put(ObjectKey.MULTIPLE_ALLOWED, Boolean.FALSE); + grantObject(bar); + grantObject(foo); + grantObject(bar, foo); + PCGraphGrantsEdge edge2 = grantObject(foo, strStat); + // Fail, not enough weight on edge (second edge no weight) + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight on edges + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + // Fail, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + // Fail, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Fail, not enough weight on edge + assertEquals(14, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + // Pass, exact value + assertEquals(15, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(3)); + // Pass, more than enough + assertEquals(16, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Weapon")); + // Pass, more than enough + assertEquals(16, getTest().passesCDOM(prereq, pc)); + } + } + + @Test + public void testTypeComplexMultipleYes() throws PrerequisiteException + { + if (isTypeLegal()) + { + Prerequisite prereq = getSimplePrereq("TYPE=Martial"); + // PC Should start without + assertEquals(0, getTest().passesCDOM(prereq, pc)); + Skill strStat = getObject("STR"); + PCGraphGrantsEdge strEdge = grantObject(strStat); + // Fail, no weight on edge + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(11)); + // Fail, not enough weight on edge + assertEquals(0, getTest().passesCDOM(prereq, pc)); + PObject foo = getFalseObject("FOO"); + PObject bar = getFalseObject("BAR"); + foo.put(ObjectKey.MULTIPLE_ALLOWED, Boolean.TRUE); + grantObject(bar); + grantObject(foo); + grantObject(bar, foo); + PCGraphGrantsEdge edge2 = grantObject(foo, strStat); + // Fail, not enough weight on edge (second edge no weight) + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Pass, not enough weight on edges + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + // Fail, no type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Exotic")); + // Fail, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(1)); + // Fail, not enough weight, wrong type + assertEquals(0, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Martial")); + // Fail, not enough weight on edge + assertEquals(13, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(2)); + // Pass, exact value + assertEquals(15, getTest().passesCDOM(prereq, pc)); + edge2.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(3)); + // Pass, more than enough + assertEquals(17, getTest().passesCDOM(prereq, pc)); + strStat.addToListFor(ListKey.TYPE, Type.getConstant("Weapon")); + // Pass, more than enough + assertEquals(17, getTest().passesCDOM(prereq, pc)); + } + } + + // TODO Complex Types (more than one type) +} Modified: branches/cdom/code/src/utest/plugin/pretokens/test/PreStatTesterTest.java =================================================================== --- branches/cdom/code/src/utest/plugin/pretokens/test/PreStatTesterTest.java 2007-06-02 16:33:54 UTC (rev 3110) +++ branches/cdom/code/src/utest/plugin/pretokens/test/PreStatTesterTest.java 2007-06-02 22:08:53 UTC (rev 3111) @@ -17,19 +17,13 @@ */ package plugin.pretokens.test; -import org.junit.Test; - -import pcgen.cdom.enumeration.AssociationKey; -import pcgen.cdom.graph.PCGraphGrantsEdge; import pcgen.core.Language; import pcgen.core.PCStat; import pcgen.core.PObject; -import pcgen.core.prereq.Prerequisite; -import pcgen.core.prereq.PrerequisiteException; -import pcgen.core.prereq.PrerequisiteOperator; import pcgen.core.prereq.PrerequisiteTest; -public class PreStatTesterTest extends AbstractCDOMPreTestTestCase<PCStat> +public class PreStatTesterTest extends + AbstractCDOMWeightedObjectTestCase<PCStat> { PreStatTester tester = new PreStatTester(); @@ -46,60 +40,22 @@ return Language.class; } + @Override public String getKind() { return "STAT"; } + @Override public PrerequisiteTest getTest() { return tester; } - public Prerequisite getSimplePrereq(String stat, int val) + @Override + public boolean isTypeLegal() { - Prerequisite p; - p = new Prerequisite(); - p.setKind(getKind()); - p.setKey(stat); - p.setOperand(Integer.toString(val)); - p.setOperator(PrerequisiteOperator.GTEQ); - return p; + return false; } - public Prerequisite getNoOperatorPrereq() - { - Prerequisite p; - p = new Prerequisite(); - p.setKind(getKind()); - p.setKey("INT"); - p.setOperand("15"); - return p; - } - - @Test - public void testSimple() throws PrerequisiteException - { - Prerequisite prereq = getSimplePrereq("STR", 15); - // PC Should start without - assertEquals(0, getTest().passesCDOM(prereq, pc)); - PCStat strStat = getObject("STR"); - PCGraphGrantsEdge strEdge = grantObject(strStat); - // Fail, no weight on edge - assertEquals(0, getTest().passesCDOM(prereq, pc)); - PCStat intStat = getObject("INT"); - PCGraphGrantsEdge intEdge = grantObject(intStat); - intEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); - // Fail, no weight on str edge (still) - assertEquals(0, getTest().passesCDOM(prereq, pc)); - strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(13)); - // Fail, not enough weight on edge - assertEquals(0, getTest().passesCDOM(prereq, pc)); - strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(15)); - // Pass, exact value - assertEquals(1, getTest().passesCDOM(prereq, pc)); - strEdge.setAssociation(AssociationKey.WEIGHT, Integer.valueOf(16)); - // Pass, more than enough - assertEquals(1, getTest().passesCDOM(prereq, pc)); - } } This was sent by the SourceForge.net collaborative development platfo... [truncated message content] |