cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonNodeFilterDaoHibernateImplTest.java

   1 /**
   2 * Copyright (C) 2009 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9 package eu.etaxonomy.cdm.persistence.dao.hibernate.taxon;
  10
  11 import static org.junit.Assert.assertEquals;
  12
  13 import java.io.FileNotFoundException;
  14 import java.util.Arrays;
  15 import java.util.List;
  16 import java.util.UUID;
  17
  18 import org.junit.Assert;
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.unitils.dbunit.annotation.DataSet;
  22 import org.unitils.dbunit.annotation.DataSets;
  23 import org.unitils.spring.annotation.SpringBeanByType;
  24
  25 import eu.etaxonomy.cdm.filter.TaxonNodeFilter;
  26 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  27 import eu.etaxonomy.cdm.model.description.Distribution;
  28 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
  29 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  30 import eu.etaxonomy.cdm.model.location.NamedArea;
  31 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  32 import eu.etaxonomy.cdm.model.name.Rank;
  33 import eu.etaxonomy.cdm.model.name.TaxonName;
  34 import eu.etaxonomy.cdm.model.reference.Reference;
  35 import eu.etaxonomy.cdm.model.taxon.Classification;
  36 import eu.etaxonomy.cdm.model.taxon.Taxon;
  37 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  38 import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;
  39 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;
  40 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeFilterDao;
  41 import eu.etaxonomy.cdm.persistence.dao.term.IDefinedTermDao;
  42 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  43 import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;
  44
  45 /**
  46  * @author a.mueller
  47  * @since 2014/06/13
  48  */
  49 public class TaxonNodeFilterDaoHibernateImplTest extends CdmTransactionalIntegrationTest {
  50
  51     @SpringBeanByType
  52     private ITaxonNodeDao taxonNodeDao;
  53
  54     @SpringBeanByType
  55     private IClassificationDao classificationDao;
  56
  57     @SpringBeanByType
  58     private ITaxonNodeFilterDao filterDao;
  59
  60     @SpringBeanByType
  61     private IDefinedTermDao termDao;
  62
  63     private final UUID europeUuid = UUID.fromString("e860871c-3a14-4ef2-9367-bbd92586c95b");
  64     private final UUID germanyUuid = UUID.fromString("7b7c2db5-aa44-4302-bdec-6556fd74b0b9");
  65     private final UUID denmarkUuid = UUID.fromString("f818c97e-fd61-42fe-9d75-d433f8cb349c");
  66     private final UUID franceUuid = UUID.fromString("41c5129a-3465-42cc-b016-59ab9ffad71a");
  67
  68     private final UUID middleEuropeUuid = UUID.fromString("d292f237-da3d-408b-93a1-3257a8c80b97");
  69     private final UUID africaUuid = UUID.fromString("9444016a-b334-4772-8795-ed4019552087");
  70
  71     private final UUID uuidNode1 = UUID.fromString("ec88fd49-59c8-4228-a826-77dff951d7f8");
  72     private final UUID uuidNode2 = UUID.fromString("4c0ecc22-e3c0-445d-912a-93ee49fb256a");
  73     private final UUID uuidNode3 = UUID.fromString("30ba17f1-2f37-4286-9665-27d5adbd230d");
  74     private final UUID uuidNode4 = UUID.fromString("2e6ca5d6-2fc8-4f0c-a3fe-03e596dd8afe");
  75     private final UUID uuidNode5 = UUID.fromString("e01f56c7-0315-450b-a05b-881d21adf02b");
  76     private final UUID uuidNodeUnpublished = UUID.fromString("96888466-f40e-43ed-a17d-cdc62bdf0ff0");
  77
  78     private Classification classification1;
  79     private TaxonNode node1;
  80     private TaxonNode node2;
  81     private TaxonNode node3;
  82     private TaxonNode node4;
  83     private TaxonNode node5;
  84     private TaxonNode nodeUnpublished;
  85     private Taxon taxon1;
  86     private Taxon taxon2;
  87     private Taxon taxon3;
  88     private Taxon taxon4;
  89     private Taxon taxon5;
  90     private Taxon taxonUnpublished;
  91
  92     @Before
  93     public void setUp() throws Exception {
  94         /*
  95          * classification 1
  96          *  - node1 (taxon1, Genus, Europe)
  97          *   - node3 (taxon3, Species, Germany)  //if subspecies exists in Denmark this is not fully correct !!
  98          *    - node4 (taxon4, Subspecies, Denmark)
  99          *    - node5 (taxon5, Subspecies)
 100          *  - node2 (taxon2, Family, France)
 101          */
 102         classification1 = Classification.NewInstance("TestClassification");
 103         Reference citation = null;
 104         String microCitation = null;
 105         taxon1 = Taxon.NewInstance(TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.GENUS(), null, null, null, null, null, null, null, null), null);
 106         taxon2 = Taxon.NewInstance(TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.FAMILY(), null, null, null, null, null, null, null, null), null);
 107         taxon3 = Taxon.NewInstance(TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.SPECIES(), null, null, null, null, null, null, null, null), null);
 108         taxon4 = Taxon.NewInstance(TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.SUBSPECIES(), null, null, null, null, null, null, null, null), null);
 109         taxon5 = Taxon.NewInstance(TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.SUBSPECIES(), null, null, null, null, null, null, null, null), null);
 110         taxonUnpublished = Taxon.NewInstance(TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.SUBSPECIES(), null, null, null, null, null, null, null, null), null);
 111         taxonUnpublished.setPublish(false);
 112
 113         NamedArea europe = (NamedArea) termDao.load(europeUuid);
 114         NamedArea germany = (NamedArea) termDao.load(germanyUuid);
 115         NamedArea denmark = (NamedArea) termDao.load(denmarkUuid);
 116         NamedArea france = (NamedArea) termDao.load(franceUuid);
 117         TaxonDescription.NewInstance(taxon1).addElement(Distribution.NewInstance(europe, PresenceAbsenceTerm.NATIVE()));
 118         TaxonDescription.NewInstance(taxon2).addElement(Distribution.NewInstance(france, PresenceAbsenceTerm.NATIVE()));
 119         TaxonDescription.NewInstance(taxon3).addElement(Distribution.NewInstance(germany, PresenceAbsenceTerm.NATIVE()));
 120         TaxonDescription.NewInstance(taxon4).addElement(Distribution.NewInstance(denmark, PresenceAbsenceTerm.ABSENT()));
 121
 122         node1 = classification1.addChildTaxon(taxon1, citation, microCitation);
 123         node1.setUuid(uuidNode1);
 124         node1= taxonNodeDao.save(node1);
 125
 126         node2 = classification1.addChildTaxon(taxon2, citation, microCitation);
 127         node2.setUuid(uuidNode2);
 128         node2 = taxonNodeDao.save(node2);
 129
 130         node3 = node1.addChildTaxon(taxon3, citation, microCitation);
 131         node3.setUuid(uuidNode3);
 132         taxonNodeDao.save(node3);
 133
 134         node4 = node3.addChildTaxon(taxon4, citation, microCitation);
 135         node4.setUuid(uuidNode4);
 136         taxonNodeDao.save(node4);
 137
 138         node5 = node3.addChildTaxon(taxon5, citation, microCitation);
 139         node5.setUuid(uuidNode5);
 140         node5 = taxonNodeDao.save(node5);
 141
 142         nodeUnpublished = node3.addChildTaxon(taxonUnpublished, citation, microCitation);
 143         nodeUnpublished.setUuid(uuidNodeUnpublished);
 144         nodeUnpublished = taxonNodeDao.save(nodeUnpublished);
 145
 146         //MergeResult result = taxonNodeDao.merge(node5, true);
 147         //node5 = (TaxonNode) result.getMergedEntity();
 148
 149         //taxonNodeDao.save(node5);
 150
 151         classificationDao.save(classification1);
 152     }
 153
 154     @Test
 155     public void testListUuidsOrdered() {
 156         Classification classification = classificationDao.findByUuid(classification1.getUuid());
 157
 158         TaxonNodeFilter filter;
 159         List<UUID> listUuid;
 160
 161         //UUID
 162         filter = TaxonNodeFilter.NewClassificationInstance(classification);
 163         filter.setOrder(TaxonNodeFilter.ORDER.TREEINDEX);
 164         listUuid = filterDao.listUuids(filter);
 165         Assert.assertEquals("All 5 children but not root node should be returned", 5, listUuid.size());
 166
 167         List<UUID> expectedList = Arrays.asList(new UUID[]{uuidNode1, uuidNode3, uuidNode4, uuidNode5, uuidNode2});
 168         //in theory node1 and 3 as well as node4 and 5 could be exchanged depending on the id they get. But we expect
 169         //in this test environment that node1.id < node2.id and node4.id < node5.id
 170         Assert.assertEquals(expectedList, listUuid);
 171
 172         List<Integer> idList = filterDao.idList(filter);
 173         Assert.assertEquals((Integer)node1.getId(), idList.get(0));
 174         Assert.assertEquals((Integer)node3.getId(), idList.get(1));
 175         Assert.assertEquals((Integer)node4.getId(), idList.get(2));
 176         Assert.assertEquals((Integer)node5.getId(), idList.get(3));
 177         Assert.assertEquals((Integer)node2.getId(), idList.get(4));
 178
 179         //ID
 180         filter.setOrder(TaxonNodeFilter.ORDER.ID);
 181         listUuid = filterDao.listUuids(filter);
 182         Assert.assertEquals("All 5 children but not root node should be returned", 5, listUuid.size());
 183
 184         expectedList = Arrays.asList(new UUID[]{uuidNode1, uuidNode2, uuidNode3, uuidNode4, uuidNode5});
 185         //in theory the given id is not necessarily ascending per save, but usually it is, at least in test environment
 186         //and therefore we expect the given result
 187         Assert.assertEquals(expectedList, listUuid);
 188
 189         filter.setOrder(TaxonNodeFilter.ORDER.TREEINDEX_DESC);
 190         listUuid = filterDao.listUuids(filter);
 191         Assert.assertEquals("All 5 children but not root node should be returned", 5, listUuid.size());
 192
 193         expectedList = Arrays.asList(new UUID[]{uuidNode2, uuidNode5, uuidNode4, uuidNode3, uuidNode1});
 194         //in theory node1 and 3 as well as node4 and 5 could be exchanged depending on the id they get. But we expect
 195         //in this test environment that node1.id < node2.id and node4.id < node5.id
 196         Assert.assertEquals(expectedList, listUuid);
 197
 198         idList = filterDao.idList(filter);
 199         Assert.assertEquals((Integer)node2.getId(), idList.get(0));
 200         Assert.assertEquals((Integer)node5.getId(), idList.get(1));
 201         Assert.assertEquals((Integer)node4.getId(), idList.get(2));
 202         Assert.assertEquals((Integer)node3.getId(), idList.get(3));
 203         Assert.assertEquals((Integer)node1.getId(), idList.get(4));
 204     }
 205
 206     @Test
 207     public void testListUuidsByAreas() {
 208         String message = "wrong number of nodes filtered";
 209 //        System.out.println("start:" + new DateTime().toString());
 210
 211         NamedArea europe = HibernateProxyHelper.deproxy(termDao.load(europeUuid), NamedArea.class);
 212         NamedArea middleEurope = HibernateProxyHelper.deproxy(termDao.load(middleEuropeUuid), NamedArea.class);
 213         NamedArea africa = HibernateProxyHelper.deproxy(termDao.load(africaUuid), NamedArea.class);
 214         NamedArea germany = HibernateProxyHelper.deproxy(termDao.load(germanyUuid), NamedArea.class);
 215
 216         TaxonNodeFilter filter = new TaxonNodeFilter(europe);
 217         List<UUID> listUuid = filterDao.listUuids(filter);
 218
 219         assertEquals(message, 3, listUuid.size());
 220         Assert.assertTrue(listUuid.contains(node1.getUuid()));
 221         Assert.assertTrue(listUuid.contains(node2.getUuid()));
 222         Assert.assertTrue(listUuid.contains(node3.getUuid()));
 223         Assert.assertFalse(listUuid.contains(node4.getUuid())); //status is absent
 224
 225         filter = new TaxonNodeFilter(germany);
 226         listUuid = filterDao.listUuids(filter);
 227         assertEquals(message, 1, listUuid.size());
 228         Assert.assertTrue(listUuid.contains(node3.getUuid()));
 229
 230         filter = new TaxonNodeFilter(middleEurope);
 231         listUuid = filterDao.listUuids(filter);
 232         assertEquals(message, 1, listUuid.size());
 233         Assert.assertTrue(listUuid.contains(node3.getUuid()));
 234
 235         filter = new TaxonNodeFilter(africa);
 236         listUuid = filterDao.listUuids(filter);
 237         assertEquals(message, 0, listUuid.size());
 238
 239     }
 240
 241     @Test
 242     @DataSets({
 243         @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="/eu/etaxonomy/cdm/database/ClearDBDataSet.xml")
 244     })
 245     public void testListUuidsByRank() {
 246         String message = "wrong number of nodes filtered";
 247         TaxonNodeFilter filter = TaxonNodeFilter.NewInstance();
 248         List<UUID> listUuid = filterDao.listUuids(filter);
 249         assertEquals(message, 5, listUuid.size());  //test start condition without rank filter
 250
 251         filter = TaxonNodeFilter.NewRankInstance(Rank.SPECIES(), Rank.GENUS());
 252         listUuid = filterDao.listUuids(filter);
 253         assertEquals(message, 2, listUuid.size());
 254         Assert.assertTrue(listUuid.contains(node1.getUuid()));
 255         Assert.assertTrue(listUuid.contains(node3.getUuid()));
 256
 257         filter = TaxonNodeFilter.NewRankInstance(Rank.SPECIES(), Rank.KINGDOM());
 258         listUuid = filterDao.listUuids(filter);
 259         assertEquals(message, 3, listUuid.size());
 260         Assert.assertTrue(listUuid.contains(node1.getUuid()));
 261         Assert.assertTrue(listUuid.contains(node2.getUuid()));
 262         Assert.assertTrue(listUuid.contains(node3.getUuid()));
 263
 264         filter = TaxonNodeFilter.NewRankInstance(Rank.FAMILY(), Rank.FAMILY());
 265         listUuid = filterDao.listUuids(filter);
 266         assertEquals(message, 1, listUuid.size());
 267         Assert.assertTrue(listUuid.contains(node2.getUuid()));
 268
 269         filter = TaxonNodeFilter.NewRankInstance(Rank.VARIETY(), Rank.SPECIES());
 270         listUuid = filterDao.listUuids(filter);
 271         assertEquals(message, 3, listUuid.size());
 272         Assert.assertTrue(listUuid.contains(node3.getUuid()));
 273         Assert.assertTrue(listUuid.contains(node4.getUuid()));
 274         Assert.assertTrue(listUuid.contains(node5.getUuid()));
 275
 276         filter = TaxonNodeFilter.NewRankInstance(Rank.KINGDOM(), Rank.ORDER());
 277         listUuid = filterDao.listUuids(filter);
 278         assertEquals(message, 0, listUuid.size());
 279
 280         //reset
 281         Rank nullRank = null;
 282         filter.setRankMax(nullRank).setRankMin(nullRank);
 283         listUuid = filterDao.listUuids(filter);
 284         assertEquals("Reseting the rank filters should work", 5, listUuid.size());
 285
 286         filter = TaxonNodeFilter.NewRankInstance(Rank.KINGDOM(), Rank.ORDER());
 287         UUID nullUuid = null;
 288         filter.setRankMax(nullUuid).setRankMin(nullUuid);
 289         listUuid = filterDao.listUuids(filter);
 290         assertEquals("Reseting the rank filters should work", 5, listUuid.size());
 291     }
 292
 293     @Test
 294     public void testListUuidsBySubtree() {
 295         Classification classification = classificationDao.findByUuid(classification1.getUuid());
 296         TaxonNodeFilter filter = TaxonNodeFilter.NewSubtreeInstance(node1);
 297         List<UUID> listUuid = filterDao.listUuids(filter);
 298 //      List<TaxonNode> children = taxonNodeDao.listChildrenOf(node1, null, null, null, true);
 299         Assert.assertEquals("All 4 children should be returned", 4, listUuid.size());
 300         Assert.assertTrue(listUuid.contains(node4.getUuid()));
 301         Assert.assertFalse(listUuid.contains(node2.getUuid()));
 302         Assert.assertFalse(listUuid.contains(classification.getRootNode().getUuid()));
 303
 304         filter = TaxonNodeFilter.NewSubtreeInstance(classification.getRootNode());
 305         listUuid = filterDao.listUuids(filter);
 306         Assert.assertEquals("All 5 children but not root node should be returned", 5, listUuid.size());
 307
 308         filter.setIncludeRootNodes(true);
 309         listUuid = filterDao.listUuids(filter);
 310         Assert.assertEquals("All 6 children including root node should be returned", 6, listUuid.size());
 311
 312         filter = TaxonNodeFilter.NewSubtreeInstance(node3);
 313         listUuid = filterDao.listUuids(filter);
 314         Assert.assertEquals("All 3 children should be returned", 3, listUuid.size());
 315
 316         filter.orSubtree(node2);
 317         listUuid = filterDao.listUuids(filter);
 318         Assert.assertEquals("All 3 children and node 2 should be returned", 4, listUuid.size());
 319         Assert.assertTrue(listUuid.contains(node2.getUuid()));
 320
 321         filter = TaxonNodeFilter.NewSubtreeInstance(node1).notSubtree(node4);
 322         listUuid = filterDao.listUuids(filter);
 323         Assert.assertEquals("Node and 2 children but not node4 should be returned", 3, listUuid.size());
 324         Assert.assertFalse(listUuid.contains(node4.getUuid()));
 325
 326         //uuids
 327         filter = TaxonNodeFilter.NewSubtreeInstance(node3.getUuid());
 328         listUuid = filterDao.listUuids(filter);
 329         Assert.assertEquals("All 3 children should be returned", 3, listUuid.size());
 330
 331         filter = TaxonNodeFilter.NewSubtreeInstance(taxon1.getUuid());
 332         listUuid = filterDao.listUuids(filter);
 333         Assert.assertEquals("A NON subtree uuid should not return a result", 0, listUuid.size());
 334
 335     }
 336
 337     @Test
 338     public void testIncludeUnpublished(){
 339         Classification classification = classificationDao.findByUuid(classification1.getUuid());
 340         TaxonNodeFilter filter = TaxonNodeFilter.NewSubtreeInstance(classification.getRootNode());
 341         List<UUID> listUuid = filterDao.listUuids(filter);
 342         Assert.assertEquals("All 5 children but not root node should be returned", 5, listUuid.size());
 343
 344         filter.setIncludeUnpublished(true);
 345         listUuid = filterDao.listUuids(filter);
 346         Assert.assertEquals("All 6 children including unpublished should be returned", 6, listUuid.size());
 347
 348         filter.setIncludeRootNodes(true);
 349         listUuid = filterDao.listUuids(filter);
 350         Assert.assertEquals("All 7 children including root node should be returned", 7, listUuid.size());
 351     }
 352
 353     @Test
 354     public void testListUuidsByClassification() {
 355         Classification classification = classificationDao.findByUuid(classification1.getUuid());
 356
 357         TaxonNodeFilter filter;
 358         List<UUID> listUuid;
 359
 360         filter = TaxonNodeFilter.NewClassificationInstance(classification);
 361         listUuid = filterDao.listUuids(filter);
 362         Assert.assertEquals("All 5 children but not root node should be returned", 5, listUuid.size());
 363
 364         filter.setIncludeRootNodes(true);
 365         listUuid = filterDao.listUuids(filter);
 366         Assert.assertEquals("All 6 children including root node should be returned", 6, listUuid.size());
 367
 368         filter = TaxonNodeFilter.NewClassificationInstance(classification.getUuid())
 369                 .setIncludeRootNodes(true);
 370         listUuid = filterDao.listUuids(filter);
 371         Assert.assertEquals("All 6 children should be returned", 6, listUuid.size());
 372
 373         filter = TaxonNodeFilter.NewClassificationInstance(taxon1.getUuid());
 374         listUuid = filterDao.listUuids(filter);
 375         Assert.assertEquals("A NON classification uuid should not return a result", 0, listUuid.size());
 376
 377     }
 378
 379     @Test
 380     public void testListUuidsByTaxon() {
 381
 382         TaxonNodeFilter filter;
 383         List<UUID> listUuid;
 384
 385         filter = TaxonNodeFilter.NewTaxonInstance(taxon1);
 386         listUuid = filterDao.listUuids(filter);
 387         Assert.assertEquals("The 1 taxon should be returned", 1, listUuid.size());
 388
 389         filter = TaxonNodeFilter.NewTaxonInstance(taxon1.getUuid());
 390         listUuid = filterDao.listUuids(filter);
 391         Assert.assertEquals("The 1 taxon should be returned", 1, listUuid.size());
 392
 393         filter = TaxonNodeFilter.NewTaxonInstance(taxon1.getUuid()).orTaxon(taxon2.getUuid());
 394         listUuid = filterDao.listUuids(filter);
 395         Assert.assertEquals("The 2 taxa should be returned", 2, listUuid.size());
 396
 397         filter = TaxonNodeFilter.NewTaxonInstance(node1.getUuid());
 398         listUuid = filterDao.listUuids(filter);
 399         Assert.assertEquals("A NON taxon uuid should not return a result", 0, listUuid.size());
 400     }
 401
 402     @Test
 403     public void testListUuidsByTaxonNode() {
 404
 405         TaxonNodeFilter filter;
 406         List<UUID> listUuid;
 407
 408         filter = TaxonNodeFilter.NewTaxonNodeInstance(node1);
 409         listUuid = filterDao.listUuids(filter);
 410         Assert.assertEquals("The 1 taxon should be returned", 1, listUuid.size());
 411
 412         filter = TaxonNodeFilter.NewTaxonNodeInstance(node1.getUuid());
 413         listUuid = filterDao.listUuids(filter);
 414         Assert.assertEquals("The 1 nodes should be returned", 1, listUuid.size());
 415
 416         filter = TaxonNodeFilter.NewTaxonNodeInstance(node1.getUuid())
 417                 .orTaxonNode(node2.getUuid());
 418         listUuid = filterDao.listUuids(filter);
 419         Assert.assertEquals("The 2 nodes should be returned", 2, listUuid.size());
 420
 421         filter = TaxonNodeFilter.NewTaxonNodeInstance(taxon1.getUuid());
 422         listUuid = filterDao.listUuids(filter);
 423         Assert.assertEquals("A NON taxon node uuid should not return a result", 0, listUuid.size());
 424
 425     }
 426
 427     @Test
 428     public void testListUuidsCombined() {
 429         Classification classification = classificationDao.findByUuid(classification1.getUuid());
 430         TaxonNodeFilter filter = TaxonNodeFilter.NewSubtreeInstance(node1);
 431         List<UUID> listUuid = filterDao.listUuids(filter);
 432         Assert.assertEquals("All 4 children should be returned", 4, listUuid.size());
 433
 434         filter.orClassification(classification.getUuid());
 435         listUuid = filterDao.listUuids(filter);
 436         Assert.assertEquals("Still 4 children should be returned", 4, listUuid.size());
 437
 438         filter.orTaxon(taxon3).orTaxon(taxon4);
 439         listUuid = filterDao.listUuids(filter);
 440         Assert.assertEquals("The 2 children should be returned", 2, listUuid.size());
 441
 442         filter.orTaxonNode(node3.getUuid());
 443         listUuid = filterDao.listUuids(filter);
 444         Assert.assertEquals("1 node should remain", 1, listUuid.size());
 445
 446         //New
 447         filter = TaxonNodeFilter.NewSubtreeInstance(node1);  //4 children, see above
 448         filter.orClassification(classification.getUuid());//4 children, see above
 449
 450         filter.setRankMax(Rank.uuidSpecies);
 451         listUuid = filterDao.listUuids(filter);
 452         Assert.assertEquals("3 children should be returned", 3, listUuid.size());
 453
 454         filter.setRankMin(Rank.uuidSpecies);
 455         listUuid = filterDao.listUuids(filter);
 456         Assert.assertEquals("Only species should be returned", 1, listUuid.size());
 457
 458         Rank nullRank = null;
 459         filter.setRankMin(nullRank);
 460         filter.setIncludeUnpublished(true);
 461         listUuid = filterDao.listUuids(filter);
 462         Assert.assertEquals("4 children should be returned, including unpublished", 4, listUuid.size());
 463
 464         NamedArea germany = HibernateProxyHelper.deproxy(termDao.load(germanyUuid), NamedArea.class);
 465         filter.orArea(germany);
 466         listUuid = filterDao.listUuids(filter);
 467         Assert.assertEquals("1 child should be returned", 1, listUuid.size());
 468     }
 469
 470     @Test
 471     public void testCountBySubtree() {
 472         Classification classification = classificationDao.findByUuid(classification1.getUuid());
 473         TaxonNodeFilter filter = TaxonNodeFilter.NewSubtreeInstance(node1);
 474         long n = filterDao.count(filter);
 475         Assert.assertEquals("All 4 children should be returned", 4, n);
 476
 477         filter = TaxonNodeFilter.NewSubtreeInstance(classification.getRootNode());
 478         n = filterDao.count(filter);
 479         Assert.assertEquals("All 5 children but not root node should be returned", 5, n);
 480
 481         filter.setIncludeRootNodes(true);
 482         n = filterDao.count(filter);
 483         Assert.assertEquals("All 6 children including root node should be returned", 6, n);
 484     }
 485
 486     @Override
 487     public void createTestDataSet() throws FileNotFoundException {}
 488
 489 }