Java tutorial
/* * This file is part of ADDIS (Aggregate Data Drug Information System). * ADDIS is distributed from http://drugis.org/. * Copyright 2009 Gert van Valkenhoef, Tommi Tervonen. * Copyright 2010 Gert van Valkenhoef, Tommi Tervonen, Tijs Zwinkels, * Maarten Jacobs, Hanno Koeslag, Florin Schimbinschi, Ahmad Kamal, Daniel * Reid. * Copyright 2011 Gert van Valkenhoef, Ahmad Kamal, Daniel Reid, Florin * Schimbinschi. * Copyright 2012 Gert van Valkenhoef, Daniel Reid, Jol Kuiper, Wouter * Reckman. * Copyright 2013 Gert van Valkenhoef, Jol Kuiper. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package org.drugis.addis.presentation.wizard; import static org.drugis.addis.presentation.wizard.TreatmentCategorizationWizardPresentation.findLeafNode; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotSame; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import java.util.Arrays; import java.util.Collections; import java.util.List; import org.apache.commons.collections15.CollectionUtils; import org.apache.commons.collections15.Predicate; import org.drugis.addis.ExampleData; import org.drugis.addis.entities.Domain; import org.drugis.addis.entities.DomainImpl; import org.drugis.addis.entities.DoseUnit; import org.drugis.addis.entities.FixedDose; import org.drugis.addis.entities.FlexibleDose; import org.drugis.addis.entities.ScaleModifier; import org.drugis.addis.entities.UnknownDose; import org.drugis.addis.entities.treatment.Category; import org.drugis.addis.entities.treatment.DecisionTreeEdge; import org.drugis.addis.entities.treatment.DecisionTreeNode; import org.drugis.addis.entities.treatment.DoseQuantityChoiceNode; import org.drugis.addis.entities.treatment.LeafNode; import org.drugis.addis.entities.treatment.RangeEdge; import org.drugis.addis.entities.treatment.TreatmentCategorization; import org.junit.Before; import org.junit.Test; import com.jgoodies.binding.list.ObservableList; import edu.uci.ics.jung.graph.util.Pair; public class TreatmentCategorizationWizardPresentationTest { private TreatmentCategorization d_bean; private TreatmentCategorizationWizardPresentation d_pm; private Domain d_domain; @Before public void setUp() { d_bean = TreatmentCategorization.createDefault("HD/LD", ExampleData.buildDrugCandesartan(), DoseUnit.createMilliGramsPerDay()); d_domain = new DomainImpl(); ExampleData.initDefaultData(d_domain); d_pm = new TreatmentCategorizationWizardPresentation(d_bean, d_domain); } @Test public void testInitialization() { assertEquals(ExampleData.buildDrugCandesartan(), d_pm.getDrug().getValue()); assertEquals("HD/LD", d_pm.getName().getValue()); assertEquals(Collections.emptyList(), d_pm.getCategories()); assertTrue(d_pm.getOptionsForUnknownDose().contains(d_pm.getModelForUnknownDose().getValue())); assertTrue(d_pm.getOptionsForKnownDose().contains(d_pm.getModelForKnownDose().getValue())); assertTrue(d_pm.getOptionsForFixedDose().contains(d_pm.getModelForFixedDose().getValue())); assertTrue(d_pm.getOptionsForFlexibleDose().contains(d_pm.getModelForFlexibleDose().getValue())); } @Test public void testMessWithCategories() { final Category catNode1 = new Category(d_bean, "foo"); final Category catNode2 = new Category(d_bean, "bar"); d_pm.getCategories().add(catNode1); d_pm.getCategories().add(catNode2); assertEquals(Arrays.asList(catNode1, catNode2), d_pm.getCategories()); d_pm.getCategories().remove(catNode1); assertEquals(Arrays.asList(catNode2), d_pm.getCategories()); } @Test public void testSplitNodePreservesOptions() { Category foo = new Category(d_bean, "foo"); d_pm.getCategories().add(foo); d_pm.getModelForFixedDose().setValue(d_pm.getFixedRangeNode()); RangeEdge edge0 = RangeEdge.createDefault(); ObservableList<DecisionTreeNode> options0 = d_pm.getOptionsForEdge(edge0); LeafNode child0 = findLeafNode(d_pm.getOptionsForEdge(edge0), foo); d_pm.getBean().getDecisionTree().addChild(edge0, d_pm.getFixedRangeNode(), child0); Pair<RangeEdge> splitRange = d_pm.splitRange(edge0, 20.0, false); assertSame(child0, d_pm.getModelForEdge(splitRange.getFirst()).getValue()); assertSame(options0, d_pm.getOptionsForEdge(splitRange.getFirst())); assertNotSame(options0, d_pm.getOptionsForEdge(splitRange.getSecond())); assertTrue(d_pm.getOptionsForEdge(splitRange.getSecond()) .contains(d_pm.getModelForEdge(splitRange.getSecond()).getValue())); } @Test public void testUnknownDoseDirectlyToTree() { Category foo = new Category(d_bean, "foo"); d_pm.getCategories().add(foo); d_pm.getModelForUnknownDose().setValue(findLeafNode(d_pm.getOptionsForUnknownDose(), foo)); DecisionTreeNode edgeTarget = d_bean.getDecisionTree().getEdgeTarget(d_pm.findTypeEdge(UnknownDose.class)); assertNodeHasCategory(edgeTarget, foo); } @Test public void testKnownDoseNotToTree() { Category foo = new Category(d_bean, "foo"); d_pm.getCategories().add(foo); DecisionTreeNode fixedExpected = d_bean.getDecisionTree().getEdgeTarget(d_pm.findTypeEdge(FixedDose.class)); DecisionTreeNode flexibleExpected = d_bean.getDecisionTree() .getEdgeTarget(d_pm.findTypeEdge(FixedDose.class)); d_pm.getModelForKnownDose().setValue(findLeafNode(d_pm.getOptionsForKnownDose(), foo)); DecisionTreeNode fixedTarget = d_bean.getDecisionTree().getEdgeTarget(d_pm.findTypeEdge(FixedDose.class)); assertEquals(fixedExpected, fixedTarget); DecisionTreeNode flexibleTarget = d_bean.getDecisionTree() .getEdgeTarget(d_pm.findTypeEdge(FixedDose.class)); assertEquals(flexibleExpected, flexibleTarget); } @Test public void testRewriteWithLeaf() { Category foo = new Category(d_bean, "foo"); d_pm.getCategories().add(foo); Category bar = new Category(d_bean, "bar"); d_pm.getCategories().add(bar); d_pm.getModelForUnknownDose().setValue(findLeafNode(d_pm.getOptionsForUnknownDose(), foo)); d_pm.getModelForKnownDose().setValue(findLeafNode(d_pm.getOptionsForKnownDose(), bar)); d_pm.transformTree(); assertNodeHasCategory(d_bean.getDecisionTree().getEdgeTarget(d_pm.findTypeEdge(UnknownDose.class)), foo); DecisionTreeNode fixedNode = d_bean.getDecisionTree().getEdgeTarget(d_pm.findTypeEdge(FixedDose.class)); assertNodeHasCategory(fixedNode, bar); assertTrue(d_pm.getOptionsForFixedDose().contains(fixedNode)); DecisionTreeNode flexibleNode = d_bean.getDecisionTree() .getEdgeTarget(d_pm.findTypeEdge(FlexibleDose.class)); assertNodeHasCategory(flexibleNode, bar); assertTrue(d_pm.getOptionsForFlexibleDose().contains(flexibleNode)); d_pm.getModelForKnownDose().setValue(findLeafNode(d_pm.getOptionsForKnownDose(), null)); d_pm.transformTree(); fixedNode = d_bean.getDecisionTree().getEdgeTarget(d_pm.findTypeEdge(FixedDose.class)); flexibleNode = d_bean.getDecisionTree().getEdgeTarget(d_pm.findTypeEdge(FlexibleDose.class)); assertNodeHasCategory(fixedNode, null); assertNodeHasCategory(flexibleNode, null); } @Test public void testRewriteDoNotConsiderDoseType() { Category foo = new Category(d_bean, "foo"); d_pm.getCategories().add(foo); Category bar = new Category(d_bean, "bar"); d_pm.getCategories().add(bar); d_pm.getModelForKnownDose() .setValue(TreatmentCategorizationWizardPresentation.CategorySpecifiers.DO_NOT_CONSIDER); d_pm.getModelForFixedDose().setValue(d_pm.getFixedRangeNode()); // Add ranges to tree (normally handled by RangeInputPresentation). RangeEdge edge0 = RangeEdge.createDefault(); d_pm.getBean().getDecisionTree().addChild(edge0, d_pm.getFixedRangeNode(), findLeafNode(d_pm.getOptionsForEdge(edge0), bar)); Pair<RangeEdge> splitRange = d_pm.splitRange(edge0, 20.0, false); d_pm.getModelForEdge(splitRange.getSecond()) .setValue(findLeafNode(d_pm.getOptionsForEdge(splitRange.getSecond()), foo)); d_pm.transformTree(); // The transformed tree should consider MIN_DOSE first. assertEquals(d_pm.getFlexibleLowerRangeNode(), d_pm.getModelForFlexibleDose().getValue()); // The ranges for MIN_DOSE should be identical to those for FixedDose List<DecisionTreeEdge> lowerEdges = d_pm.getFlexibleLowerRanges(); ObservableList<DecisionTreeEdge> fixedEdges = d_pm.getOutEdges(d_pm.getFixedRangeNode()); assertEquals(2, lowerEdges.size()); assertEquals(fixedEdges.get(0).toString(), lowerEdges.get(0).toString()); assertEquals(fixedEdges.get(1).toString(), lowerEdges.get(1).toString()); for (int i = 0; i < lowerEdges.size(); i++) { RangeEdge fixedRange = (RangeEdge) fixedEdges.get(i); RangeEdge lowerRange = (RangeEdge) lowerEdges.get(i); DoseQuantityChoiceNode upper = (DoseQuantityChoiceNode) d_pm.getModelForEdge(lowerRange).getValue(); // FIXME: test that the node is in the options list. // For each MIN_DOSE range, the MAX_DOSE should subsequently be considered assertEquals(FlexibleDose.class, upper.getBeanClass()); assertEquals(FlexibleDose.PROPERTY_MAX_DOSE, upper.getPropertyName()); assertSame(d_bean.getDoseUnit(), upper.getDoseUnit()); // There should be two out-edges, unless the upper bound is +infinity List<DecisionTreeEdge> upperEdges = d_pm.getOutEdges(upper); assertEquals(lowerRange.toString(), upperEdges.get(0).toString()); assertNodeHasCategory((DecisionTreeNode) d_pm.getModelForEdge(upperEdges.get(0)).getValue(), ((LeafNode) d_pm.getModelForEdge(fixedRange).getValue()).getCategory()); if (!Double.isInfinite(lowerRange.getUpperBound())) { assertEquals(2, upperEdges.size()); RangeEdge expected = new RangeEdge(lowerRange.getUpperBound(), !lowerRange.isUpperBoundOpen(), Double.POSITIVE_INFINITY, true); assertEquals(expected.toString(), upperEdges.get(1).toString()); assertNodeHasCategory((DecisionTreeNode) d_pm.getModelForEdge(upperEdges.get(1)).getValue(), null); } else { assertEquals(1, upperEdges.size()); } } } @Test public void testRewriteDoNotConsiderDoseTypeWithExclusion() { Category bar = new Category(d_bean, "bar"); d_pm.getCategories().add(bar); d_pm.getModelForKnownDose() .setValue(TreatmentCategorizationWizardPresentation.CategorySpecifiers.DO_NOT_CONSIDER); d_pm.getModelForFixedDose().setValue(d_pm.getFixedRangeNode()); // Add ranges to tree (normally handled by RangeInputPresentation). RangeEdge edge0 = RangeEdge.createDefault(); d_pm.getBean().getDecisionTree().addChild(edge0, d_pm.getFixedRangeNode(), findLeafNode(d_pm.getOptionsForEdge(edge0), null)); Pair<RangeEdge> splitRange = d_pm.splitRange(edge0, 20.0, false); d_pm.getModelForEdge(splitRange.getSecond()) .setValue(findLeafNode(d_pm.getOptionsForEdge(splitRange.getSecond()), bar)); d_pm.transformTree(); // The lower range is excluded anyway, so don't split on MAX_DOSE. DoseQuantityChoiceNode upper = (DoseQuantityChoiceNode) d_pm .getModelForEdge(d_pm.getFlexibleLowerRanges().get(0)).getValue(); ObservableList<DecisionTreeEdge> edges = d_pm.getOutEdges(upper); assertEquals(1, edges.size()); RangeEdge edge = (RangeEdge) edges.get(0); RangeEdge expected = new RangeEdge(0.0, false, Double.POSITIVE_INFINITY, true); assertEquals(expected.toString(), edge.toString()); assertNodeHasCategory((DecisionTreeNode) d_pm.getModelForEdge(edge).getValue(), null); } @Test public void testFlexibleDoseNodeChaining() { // If MIN_DOSE is considered first, allow MAX_DOSE next d_pm.getModelForFlexibleDose().setValue(d_pm.getFlexibleLowerRangeNode()); RangeEdge edge1 = d_pm.addDefaultRangeEdge(d_pm.getFlexibleLowerRangeNode()); assertNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge1), FlexibleDose.PROPERTY_MIN_DOSE)); assertNotNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge1), FlexibleDose.PROPERTY_MAX_DOSE)); assertTrue(d_pm.getOptionsForEdge(edge1).contains(d_pm.getModelForEdge(edge1).getValue())); // If MAX_DOSE is considered first, allow MIN_DOSE next d_pm.getModelForFlexibleDose().setValue(d_pm.getFlexibleUpperRangeNode()); RangeEdge edge2 = d_pm.addDefaultRangeEdge(d_pm.getFlexibleUpperRangeNode()); assertNotNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge2), FlexibleDose.PROPERTY_MIN_DOSE)); assertNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge2), FlexibleDose.PROPERTY_MAX_DOSE)); assertTrue(d_pm.getOptionsForEdge(edge2).contains(d_pm.getModelForEdge(edge2).getValue())); // No MIN_DOSE / MAX_DOSE for fixed dose nodes d_pm.getModelForFixedDose().setValue(d_pm.getFixedRangeNode()); RangeEdge edge3 = d_pm.addDefaultRangeEdge(d_pm.getFixedRangeNode()); assertNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge3), FlexibleDose.PROPERTY_MIN_DOSE)); assertNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge3), FlexibleDose.PROPERTY_MAX_DOSE)); assertTrue(d_pm.getOptionsForEdge(edge3).contains(d_pm.getModelForEdge(edge3).getValue())); // If MAX_DOSE is considered first, and MIN_DOSE is considered second, no further extra options DoseQuantityChoiceNode lower2 = findDoseQuantityNode(d_pm.getOptionsForEdge(edge2), FlexibleDose.PROPERTY_MIN_DOSE); d_pm.getModelForEdge(edge2).setValue(lower2); RangeEdge edge4 = d_pm.addDefaultRangeEdge(lower2); assertNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge4), FlexibleDose.PROPERTY_MIN_DOSE)); assertNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge4), FlexibleDose.PROPERTY_MAX_DOSE)); assertTrue(d_pm.getOptionsForEdge(edge4).contains(d_pm.getModelForEdge(edge4).getValue())); } @Test public void testFlexibleDoseNodeChainingOnSplit() { // If MIN_DOSE is considered first, allow MAX_DOSE next d_pm.getModelForFlexibleDose().setValue(d_pm.getFlexibleLowerRangeNode()); RangeEdge edge0 = d_pm.addDefaultRangeEdge(d_pm.getFlexibleLowerRangeNode()); Pair<RangeEdge> splitRange = d_pm.splitRange(edge0, 20.0, false); RangeEdge edge1 = splitRange.getFirst(); RangeEdge edge2 = splitRange.getSecond(); assertNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge1), FlexibleDose.PROPERTY_MIN_DOSE)); assertNotNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge1), FlexibleDose.PROPERTY_MAX_DOSE)); assertTrue(d_pm.getOptionsForEdge(edge1).contains(d_pm.getModelForEdge(edge1).getValue())); assertNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge2), FlexibleDose.PROPERTY_MIN_DOSE)); assertNotNull(findDoseQuantityNode(d_pm.getOptionsForEdge(edge2), FlexibleDose.PROPERTY_MAX_DOSE)); assertTrue(d_pm.getOptionsForEdge(edge2).contains(d_pm.getModelForEdge(edge2).getValue())); } private static DoseQuantityChoiceNode findDoseQuantityNode(ObservableList<DecisionTreeNode> options, final String propertyName) { return (DoseQuantityChoiceNode) CollectionUtils.find(options, new Predicate<DecisionTreeNode>() { public boolean evaluate(DecisionTreeNode object) { if (object instanceof DoseQuantityChoiceNode) { DoseQuantityChoiceNode node = (DoseQuantityChoiceNode) object; return propertyName.equals(node.getPropertyName()); } return false; } }); } private static void assertNodeHasCategory(DecisionTreeNode node, Category category) { assertTrue(node instanceof LeafNode); assertEquals(category, ((LeafNode) node).getCategory()); } /* * Regression test for bug #566 */ @Test public void testDoNotReuseDefaultDose() { TreatmentCategorizationWizardPresentation pm1 = new TreatmentCategorizationWizardPresentation( TreatmentCategorization.createDefault(), d_domain); TreatmentCategorizationWizardPresentation pm2 = new TreatmentCategorizationWizardPresentation( TreatmentCategorization.createDefault(), d_domain); pm1.getDoseUnit().setScaleModifier(ScaleModifier.MEGA); assertFalse(pm2.getDoseUnit().equals(pm1.getDoseUnit())); } }