forester/java/src/org/forester/test/Test.java

   1 // $Id:
   2 // FORESTER -- software libraries and applications
   3 // for evolutionary biology research and applications.
   4 //
   5 // Copyright (C) 2008-2009 Christian M. Zmasek
   6 // Copyright (C) 2008-2009 Burnham Institute for Medical Research
   7 // All rights reserved
   8 //
   9 // This library is free software; you can redistribute it and/or
  10 // modify it under the terms of the GNU Lesser General Public
  11 // License as published by the Free Software Foundation; either
  12 // version 2.1 of the License, or (at your option) any later version.
  13 //
  14 // This library is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17 // Lesser General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU Lesser General Public
  20 // License along with this library; if not, write to the Free Software
  21 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  22 //
  23 // Contact: phylosoft @ gmail . com
  24 // WWW: www.phylosoft.org/forester
  25
  26 package org.forester.test;
  27
  28 import java.io.ByteArrayInputStream;
  29 import java.io.File;
  30 import java.io.FileInputStream;
  31 import java.io.IOException;
  32 import java.util.ArrayList;
  33 import java.util.Date;
  34 import java.util.HashSet;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Locale;
  38 import java.util.Set;
  39
  40 import org.forester.application.support_transfer;
  41 import org.forester.development.DevelopmentTools;
  42 import org.forester.evoinference.TestPhylogenyReconstruction;
  43 import org.forester.evoinference.matrix.character.CharacterStateMatrix;
  44 import org.forester.evoinference.matrix.character.CharacterStateMatrix.BinaryStates;
  45 import org.forester.go.TestGo;
  46 import org.forester.io.parsers.FastaParser;
  47 import org.forester.io.parsers.GeneralMsaParser;
  48 import org.forester.io.parsers.HmmscanPerDomainTableParser;
  49 import org.forester.io.parsers.HmmscanPerDomainTableParser.INDIVIDUAL_SCORE_CUTOFF;
  50 import org.forester.io.parsers.nexus.NexusBinaryStatesMatrixParser;
  51 import org.forester.io.parsers.nexus.NexusCharactersParser;
  52 import org.forester.io.parsers.nexus.NexusPhylogeniesParser;
  53 import org.forester.io.parsers.nhx.NHXParser;
  54 import org.forester.io.parsers.phyloxml.PhyloXmlParser;
  55 import org.forester.io.parsers.tol.TolParser;
  56 import org.forester.io.writers.PhylogenyWriter;
  57 import org.forester.msa.Mafft;
  58 import org.forester.msa.Msa;
  59 import org.forester.msa.MsaInferrer;
  60 import org.forester.pccx.TestPccx;
  61 import org.forester.phylogeny.Phylogeny;
  62 import org.forester.phylogeny.PhylogenyBranch;
  63 import org.forester.phylogeny.PhylogenyMethods;
  64 import org.forester.phylogeny.PhylogenyNode;
  65 import org.forester.phylogeny.data.BinaryCharacters;
  66 import org.forester.phylogeny.data.BranchWidth;
  67 import org.forester.phylogeny.data.Confidence;
  68 import org.forester.phylogeny.data.Distribution;
  69 import org.forester.phylogeny.data.DomainArchitecture;
  70 import org.forester.phylogeny.data.Event;
  71 import org.forester.phylogeny.data.Identifier;
  72 import org.forester.phylogeny.data.PhylogenyData;
  73 import org.forester.phylogeny.data.Polygon;
  74 import org.forester.phylogeny.data.PropertiesMap;
  75 import org.forester.phylogeny.data.Property;
  76 import org.forester.phylogeny.data.Property.AppliesTo;
  77 import org.forester.phylogeny.data.ProteinDomain;
  78 import org.forester.phylogeny.data.Taxonomy;
  79 import org.forester.phylogeny.factories.ParserBasedPhylogenyFactory;
  80 import org.forester.phylogeny.factories.PhylogenyFactory;
  81 import org.forester.phylogeny.iterators.PhylogenyNodeIterator;
  82 import org.forester.sdi.SDI;
  83 import org.forester.sdi.SDIR;
  84 import org.forester.sdi.SDIse;
  85 import org.forester.sdi.TaxonomyAssigner;
  86 import org.forester.sdi.TestGSDI;
  87 import org.forester.sequence.BasicSequence;
  88 import org.forester.sequence.Sequence;
  89 import org.forester.surfacing.Protein;
  90 import org.forester.surfacing.TestSurfacing;
  91 import org.forester.tools.ConfidenceAssessor;
  92 import org.forester.tools.SupportCount;
  93 import org.forester.tools.TreeSplitMatrix;
  94 import org.forester.util.AsciiHistogram;
  95 import org.forester.util.BasicDescriptiveStatistics;
  96 import org.forester.util.BasicTable;
  97 import org.forester.util.BasicTableParser;
  98 import org.forester.util.DescriptiveStatistics;
  99 import org.forester.util.ForesterConstants;
 100 import org.forester.util.ForesterUtil;
 101 import org.forester.util.GeneralTable;
 102 import org.forester.ws.uniprot.DatabaseTools;
 103 import org.forester.ws.uniprot.SequenceDatabaseEntry;
 104 import org.forester.ws.uniprot.UniProtTaxonomy;
 105 import org.forester.ws.uniprot.UniProtWsTools;
 106 import org.forester.ws.wabi.TxSearch;
 107 import org.forester.ws.wabi.TxSearch.RANKS;
 108 import org.forester.ws.wabi.TxSearch.TAX_NAME_CLASS;
 109 import org.forester.ws.wabi.TxSearch.TAX_RANK;
 110
 111 @SuppressWarnings( "unused")
 112 public final class Test {
 113
 114     private final static double  ZERO_DIFF                 = 1.0E-9;
 115     private final static String  PATH_TO_TEST_DATA         = System.getProperty( "user.dir" )
 116                                                                    + ForesterUtil.getFileSeparator() + "test_data"
 117                                                                    + ForesterUtil.getFileSeparator();
 118     private final static String  PATH_TO_RESOURCES         = System.getProperty( "user.dir" )
 119                                                                    + ForesterUtil.getFileSeparator() + "resources"
 120                                                                    + ForesterUtil.getFileSeparator();
 121     private final static boolean USE_LOCAL_PHYLOXML_SCHEMA = true;
 122     private static final String  PHYLOXML_REMOTE_XSD       = ForesterConstants.PHYLO_XML_LOCATION + "/"
 123                                                                    + ForesterConstants.PHYLO_XML_VERSION + "/"
 124                                                                    + ForesterConstants.PHYLO_XML_XSD;
 125     private static final String  PHYLOXML_LOCAL_XSD        = PATH_TO_RESOURCES + "phyloxml_schema/"
 126                                                                    + ForesterConstants.PHYLO_XML_VERSION + "/"
 127                                                                    + ForesterConstants.PHYLO_XML_XSD;
 128
 129     private final static Phylogeny createPhylogeny( final String nhx ) throws IOException {
 130         final Phylogeny p = ParserBasedPhylogenyFactory.getInstance().create( nhx, new NHXParser() )[ 0 ];
 131         return p;
 132     }
 133
 134     private final static Event getEvent( final Phylogeny p, final String n1, final String n2 ) {
 135         final PhylogenyMethods pm = PhylogenyMethods.getInstance();
 136         return pm.obtainLCA( p.getNode( n1 ), p.getNode( n2 ) ).getNodeData().getEvent();
 137     }
 138
 139     public static boolean isEqual( final double a, final double b ) {
 140         return ( ( Math.abs( a - b ) ) < Test.ZERO_DIFF );
 141     }
 142
 143     public static void main( final String[] args ) {
 144         System.out.println( "[Java version: " + ForesterUtil.JAVA_VERSION + " " + ForesterUtil.JAVA_VENDOR + "]" );
 145         System.out.println( "[OS: " + ForesterUtil.OS_NAME + " " + ForesterUtil.OS_ARCH + " " + ForesterUtil.OS_VERSION
 146                 + "]" );
 147         Locale.setDefault( Locale.US );
 148         System.out.println( "[Locale: " + Locale.getDefault() + "]" );
 149         int failed = 0;
 150         int succeeded = 0;
 151         System.out.print( "[Test if directory with files for testing exists/is readable: " );
 152         if ( Test.testDir( PATH_TO_TEST_DATA ) ) {
 153             System.out.println( "OK.]" );
 154         }
 155         else {
 156             System.out.println( "could not find/read from directory \"" + PATH_TO_TEST_DATA + "\".]" );
 157             System.out.println( "Testing aborted." );
 158             System.exit( -1 );
 159         }
 160         System.out.print( "[Test if resources directory exists/is readable: " );
 161         if ( testDir( PATH_TO_RESOURCES ) ) {
 162             System.out.println( "OK.]" );
 163         }
 164         else {
 165             System.out.println( "could not find/read from directory \"" + Test.PATH_TO_RESOURCES + "\".]" );
 166             System.out.println( "Testing aborted." );
 167             System.exit( -1 );
 168         }
 169         final long start_time = new Date().getTime();
 170         System.out.print( "Hmmscan output parser: " );
 171         if ( testHmmscanOutputParser() ) {
 172             System.out.println( "OK." );
 173             succeeded++;
 174         }
 175         else {
 176             System.out.println( "failed." );
 177             failed++;
 178         }
 179         System.out.print( "Basic node methods: " );
 180         if ( Test.testBasicNodeMethods() ) {
 181             System.out.println( "OK." );
 182             succeeded++;
 183         }
 184         else {
 185             System.out.println( "failed." );
 186             failed++;
 187         }
 188         System.out.print( "Basic node construction and parsing of NHX (node level): " );
 189         if ( Test.testNHXNodeParsing() ) {
 190             System.out.println( "OK." );
 191             succeeded++;
 192         }
 193         else {
 194             System.out.println( "failed." );
 195             failed++;
 196         }
 197         System.out.print( "NH parsing: " );
 198         if ( Test.testNHParsing() ) {
 199             System.out.println( "OK." );
 200             succeeded++;
 201         }
 202         else {
 203             System.out.println( "failed." );
 204             failed++;
 205         }
 206         System.out.print( "Conversion to NHX (node level): " );
 207         if ( Test.testNHXconversion() ) {
 208             System.out.println( "OK." );
 209             succeeded++;
 210         }
 211         else {
 212             System.out.println( "failed." );
 213             failed++;
 214         }
 215         System.out.print( "NHX parsing: " );
 216         if ( Test.testNHXParsing() ) {
 217             System.out.println( "OK." );
 218             succeeded++;
 219         }
 220         else {
 221             System.out.println( "failed." );
 222             failed++;
 223         }
 224         System.out.print( "NHX parsing with quotes: " );
 225         if ( Test.testNHXParsingQuotes() ) {
 226             System.out.println( "OK." );
 227             succeeded++;
 228         }
 229         else {
 230             System.out.println( "failed." );
 231             failed++;
 232         }
 233         System.out.print( "Nexus characters parsing: " );
 234         if ( Test.testNexusCharactersParsing() ) {
 235             System.out.println( "OK." );
 236             succeeded++;
 237         }
 238         else {
 239             System.out.println( "failed." );
 240             failed++;
 241         }
 242         System.out.print( "Nexus tree parsing: " );
 243         if ( Test.testNexusTreeParsing() ) {
 244             System.out.println( "OK." );
 245             succeeded++;
 246         }
 247         else {
 248             System.out.println( "failed." );
 249             failed++;
 250         }
 251         System.out.print( "Nexus tree parsing (translating): " );
 252         if ( Test.testNexusTreeParsingTranslating() ) {
 253             System.out.println( "OK." );
 254             succeeded++;
 255         }
 256         else {
 257             System.out.println( "failed." );
 258             failed++;
 259         }
 260         System.out.print( "Nexus matrix parsing: " );
 261         if ( Test.testNexusMatrixParsing() ) {
 262             System.out.println( "OK." );
 263             succeeded++;
 264         }
 265         else {
 266             System.out.println( "failed." );
 267             failed++;
 268         }
 269         System.out.print( "Basic phyloXML parsing: " );
 270         if ( Test.testBasicPhyloXMLparsing() ) {
 271             System.out.println( "OK." );
 272             succeeded++;
 273         }
 274         else {
 275             System.out.println( "failed." );
 276             failed++;
 277         }
 278         System.out.print( "Basic phyloXML parsing (validating against schema): " );
 279         if ( testBasicPhyloXMLparsingValidating() ) {
 280             System.out.println( "OK." );
 281             succeeded++;
 282         }
 283         else {
 284             System.out.println( "failed." );
 285             failed++;
 286         }
 287         System.out.print( "Roundtrip phyloXML parsing (validating against schema): " );
 288         if ( Test.testBasicPhyloXMLparsingRoundtrip() ) {
 289             System.out.println( "OK." );
 290             succeeded++;
 291         }
 292         else {
 293             System.out.println( "failed." );
 294             failed++;
 295         }
 296         System.out.print( "phyloXML Distribution Element: " );
 297         if ( Test.testPhyloXMLparsingOfDistributionElement() ) {
 298             System.out.println( "OK." );
 299             succeeded++;
 300         }
 301         else {
 302             System.out.println( "failed." );
 303             failed++;
 304         }
 305         System.out.print( "Tol XML parsing: " );
 306         if ( Test.testBasicTolXMLparsing() ) {
 307             System.out.println( "OK." );
 308             succeeded++;
 309         }
 310         else {
 311             System.out.println( "failed." );
 312             failed++;
 313         }
 314         System.out.print( "Copying of node data: " );
 315         if ( Test.testCopyOfNodeData() ) {
 316             System.out.println( "OK." );
 317             succeeded++;
 318         }
 319         else {
 320             System.out.println( "failed." );
 321             failed++;
 322         }
 323         System.out.print( "Basic tree methods: " );
 324         if ( Test.testBasicTreeMethods() ) {
 325             System.out.println( "OK." );
 326             succeeded++;
 327         }
 328         else {
 329             System.out.println( "failed." );
 330             failed++;
 331         }
 332         System.out.print( "Postorder Iterator: " );
 333         if ( Test.testPostOrderIterator() ) {
 334             System.out.println( "OK." );
 335             succeeded++;
 336         }
 337         else {
 338             System.out.println( "failed." );
 339             failed++;
 340         }
 341         System.out.print( "Preorder Iterator: " );
 342         if ( Test.testPreOrderIterator() ) {
 343             System.out.println( "OK." );
 344             succeeded++;
 345         }
 346         else {
 347             System.out.println( "failed." );
 348             failed++;
 349         }
 350         System.out.print( "Levelorder Iterator: " );
 351         if ( Test.testLevelOrderIterator() ) {
 352             System.out.println( "OK." );
 353             succeeded++;
 354         }
 355         else {
 356             System.out.println( "failed." );
 357             failed++;
 358         }
 359         System.out.print( "Re-id methods: " );
 360         if ( Test.testReIdMethods() ) {
 361             System.out.println( "OK." );
 362             succeeded++;
 363         }
 364         else {
 365             System.out.println( "failed." );
 366             failed++;
 367         }
 368         System.out.print( "Methods on last external nodes: " );
 369         if ( Test.testLastExternalNodeMethods() ) {
 370             System.out.println( "OK." );
 371             succeeded++;
 372         }
 373         else {
 374             System.out.println( "failed." );
 375             failed++;
 376         }
 377         System.out.print( "Methods on external nodes: " );
 378         if ( Test.testExternalNodeRelatedMethods() ) {
 379             System.out.println( "OK." );
 380             succeeded++;
 381         }
 382         else {
 383             System.out.println( "failed." );
 384             failed++;
 385         }
 386         System.out.print( "Deletion of external nodes: " );
 387         if ( Test.testDeletionOfExternalNodes() ) {
 388             System.out.println( "OK." );
 389             succeeded++;
 390         }
 391         else {
 392             System.out.println( "failed." );
 393             failed++;
 394         }
 395         System.out.print( "Subtree deletion: " );
 396         if ( Test.testSubtreeDeletion() ) {
 397             System.out.println( "OK." );
 398             succeeded++;
 399         }
 400         else {
 401             System.out.println( "failed." );
 402             failed++;
 403         }
 404         System.out.print( "Phylogeny branch: " );
 405         if ( Test.testPhylogenyBranch() ) {
 406             System.out.println( "OK." );
 407             succeeded++;
 408         }
 409         else {
 410             System.out.println( "failed." );
 411             failed++;
 412         }
 413         System.out.print( "Rerooting: " );
 414         if ( Test.testRerooting() ) {
 415             System.out.println( "OK." );
 416             succeeded++;
 417         }
 418         else {
 419             System.out.println( "failed." );
 420             failed++;
 421         }
 422         System.out.print( "Mipoint rooting: " );
 423         if ( Test.testMidpointrooting() ) {
 424             System.out.println( "OK." );
 425             succeeded++;
 426         }
 427         else {
 428             System.out.println( "failed." );
 429             failed++;
 430         }
 431         System.out.print( "Support count: " );
 432         if ( Test.testSupportCount() ) {
 433             System.out.println( "OK." );
 434             succeeded++;
 435         }
 436         else {
 437             System.out.println( "failed." );
 438             failed++;
 439         }
 440         System.out.print( "Support transfer: " );
 441         if ( Test.testSupportTransfer() ) {
 442             System.out.println( "OK." );
 443             succeeded++;
 444         }
 445         else {
 446             System.out.println( "failed." );
 447             failed++;
 448         }
 449         System.out.print( "Finding of LCA: " );
 450         if ( Test.testGetLCA() ) {
 451             System.out.println( "OK." );
 452             succeeded++;
 453         }
 454         else {
 455             System.out.println( "failed." );
 456             failed++;
 457         }
 458         System.out.print( "Calculation of distance between nodes: " );
 459         if ( Test.testGetDistance() ) {
 460             System.out.println( "OK." );
 461             succeeded++;
 462         }
 463         else {
 464             System.out.println( "failed." );
 465             failed++;
 466         }
 467         System.out.print( "SDIse: " );
 468         if ( Test.testSDIse() ) {
 469             System.out.println( "OK." );
 470             succeeded++;
 471         }
 472         else {
 473             System.out.println( "failed." );
 474             failed++;
 475         }
 476         System.out.print( "Taxonomy assigner: " );
 477         if ( Test.testTaxonomyAssigner() ) {
 478             System.out.println( "OK." );
 479             succeeded++;
 480         }
 481         else {
 482             System.out.println( "failed." );
 483             failed++;
 484         }
 485         System.out.print( "SDIunrooted: " );
 486         if ( Test.testSDIunrooted() ) {
 487             System.out.println( "OK." );
 488             succeeded++;
 489         }
 490         else {
 491             System.out.println( "failed." );
 492             failed++;
 493         }
 494         System.out.print( "GSDI: " );
 495         if ( TestGSDI.test() ) {
 496             System.out.println( "OK." );
 497             succeeded++;
 498         }
 499         else {
 500             System.out.println( "failed." );
 501             failed++;
 502         }
 503         System.out.print( "Descriptive statistics: " );
 504         if ( Test.testDescriptiveStatistics() ) {
 505             System.out.println( "OK." );
 506             succeeded++;
 507         }
 508         else {
 509             System.out.println( "failed." );
 510             failed++;
 511         }
 512         System.out.print( "Data objects and methods: " );
 513         if ( Test.testDataObjects() ) {
 514             System.out.println( "OK." );
 515             succeeded++;
 516         }
 517         else {
 518             System.out.println( "failed." );
 519             failed++;
 520         }
 521         System.out.print( "Properties map: " );
 522         if ( Test.testPropertiesMap() ) {
 523             System.out.println( "OK." );
 524             succeeded++;
 525         }
 526         else {
 527             System.out.println( "failed." );
 528             failed++;
 529         }
 530         System.out.print( "Phylogeny reconstruction:" );
 531         System.out.println();
 532         if ( TestPhylogenyReconstruction.test( new File( PATH_TO_TEST_DATA ) ) ) {
 533             System.out.println( "OK." );
 534             succeeded++;
 535         }
 536         else {
 537             System.out.println( "failed." );
 538             failed++;
 539         }
 540         System.out.print( "Analysis of domain architectures: " );
 541         System.out.println();
 542         if ( TestSurfacing.test( new File( PATH_TO_TEST_DATA ) ) ) {
 543             System.out.println( "OK." );
 544             succeeded++;
 545         }
 546         else {
 547             System.out.println( "failed." );
 548             failed++;
 549         }
 550         System.out.print( "GO: " );
 551         System.out.println();
 552         if ( TestGo.test( new File( PATH_TO_TEST_DATA ) ) ) {
 553             System.out.println( "OK." );
 554             succeeded++;
 555         }
 556         else {
 557             System.out.println( "failed." );
 558             failed++;
 559         }
 560         System.out.print( "Modeling tools: " );
 561         if ( TestPccx.test() ) {
 562             System.out.println( "OK." );
 563             succeeded++;
 564         }
 565         else {
 566             System.out.println( "failed." );
 567             failed++;
 568         }
 569         System.out.print( "Split Matrix strict: " );
 570         if ( Test.testSplitStrict() ) {
 571             System.out.println( "OK." );
 572             succeeded++;
 573         }
 574         else {
 575             System.out.println( "failed." );
 576             failed++;
 577         }
 578         System.out.print( "Split Matrix: " );
 579         if ( Test.testSplit() ) {
 580             System.out.println( "OK." );
 581             succeeded++;
 582         }
 583         else {
 584             System.out.println( "failed." );
 585             failed++;
 586         }
 587         System.out.print( "Confidence Assessor: " );
 588         if ( Test.testConfidenceAssessor() ) {
 589             System.out.println( "OK." );
 590             succeeded++;
 591         }
 592         else {
 593             System.out.println( "failed." );
 594             failed++;
 595         }
 596         System.out.print( "Basic table: " );
 597         if ( Test.testBasicTable() ) {
 598             System.out.println( "OK." );
 599             succeeded++;
 600         }
 601         else {
 602             System.out.println( "failed." );
 603             failed++;
 604         }
 605         System.out.print( "General table: " );
 606         if ( Test.testGeneralTable() ) {
 607             System.out.println( "OK." );
 608             succeeded++;
 609         }
 610         else {
 611             System.out.println( "failed." );
 612             failed++;
 613         }
 614         System.out.print( "Amino acid sequence: " );
 615         if ( Test.testAminoAcidSequence() ) {
 616             System.out.println( "OK." );
 617             succeeded++;
 618         }
 619         else {
 620             System.out.println( "failed." );
 621             failed++;
 622         }
 623         System.out.print( "General MSA parser: " );
 624         if ( Test.testGeneralMsaParser() ) {
 625             System.out.println( "OK." );
 626             succeeded++;
 627         }
 628         else {
 629             System.out.println( "failed." );
 630             failed++;
 631         }
 632         System.out.print( "Fasta parser for msa: " );
 633         if ( Test.testFastaParser() ) {
 634             System.out.println( "OK." );
 635             succeeded++;
 636         }
 637         else {
 638             System.out.println( "failed." );
 639             failed++;
 640         }
 641         System.out.print( "Creation of balanced phylogeny: " );
 642         if ( Test.testCreateBalancedPhylogeny() ) {
 643             System.out.println( "OK." );
 644             succeeded++;
 645         }
 646         else {
 647             System.out.println( "failed." );
 648             failed++;
 649         }
 650         System.out.print( "EMBL Entry Retrieval: " );
 651         if ( Test.testEmblEntryRetrieval() ) {
 652             System.out.println( "OK." );
 653             succeeded++;
 654         }
 655         else {
 656             System.out.println( "failed." );
 657             failed++;
 658         }
 659         System.out.print( "Uniprot Entry Retrieval: " );
 660         if ( Test.testUniprotEntryRetrieval() ) {
 661             System.out.println( "OK." );
 662             succeeded++;
 663         }
 664         else {
 665             System.out.println( "failed." );
 666             failed++;
 667         }
 668         System.out.print( "Uniprot Taxonomy Search: " );
 669         if ( Test.testUniprotTaxonomySearch() ) {
 670             System.out.println( "OK." );
 671             succeeded++;
 672         }
 673         else {
 674             System.out.println( "failed." );
 675             failed++;
 676         }
 677         if ( Mafft.isInstalled() ) {
 678             System.out.print( "MAFFT (external program): " );
 679             if ( Test.testMafft() ) {
 680                 System.out.println( "OK." );
 681                 succeeded++;
 682             }
 683             else {
 684                 System.out.println( "failed [will not count towards failed tests]" );
 685             }
 686         }
 687         //        System.out.print( "WABI TxSearch: " );
 688         //        if ( Test.testWabiTxSearch() ) {
 689         //            System.out.println( "OK." );
 690         //            succeeded++;
 691         //        }
 692         //        else {
 693         //            System.out
 694         //                    .println( "failed [will not count towards failed tests since it might be due to absence internet connection]" );
 695         //        }
 696         System.out.println();
 697         final Runtime rt = java.lang.Runtime.getRuntime();
 698         final long free_memory = rt.freeMemory() / 1000000;
 699         final long total_memory = rt.totalMemory() / 1000000;
 700         System.out.println( "Running time    : " + ( new Date().getTime() - start_time ) + "ms " + "(free memory: "
 701                 + free_memory + "MB, total memory: " + total_memory + "MB)" );
 702         System.out.println();
 703         System.out.println( "Successful tests: " + succeeded );
 704         System.out.println( "Failed     tests: " + failed );
 705         System.out.println();
 706         if ( failed < 1 ) {
 707             System.out.println( "OK." );
 708         }
 709         else {
 710             System.out.println( "Not OK." );
 711         }
 712         // System.out.println();
 713         // Development.setTime( true );
 714         //try {
 715         //  final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
 716         //  final String clc = System.getProperty( "user.dir" ) + ForesterUtil.getFileSeparator()
 717         //          + "examples" + ForesterUtil.getFileSeparator() + "CLC.nhx";
 718         // final String multi = Test.PATH_TO_EXAMPLE_FILES +
 719         // "multifurcations_ex_1.nhx";
 720         // final String domains = Test.PATH_TO_EXAMPLE_FILES + "domains1.nhx";
 721         // final Phylogeny t1 = factory.create( new File( domains ), new
 722         // NHXParser() )[ 0 ];
 723         //  final Phylogeny t2 = factory.create( new File( clc ), new NHXParser() )[ 0 ];
 724         // }
 725         // catch ( final Exception e ) {
 726         //     e.printStackTrace();
 727         // }
 728         // t1.getRoot().preorderPrint();
 729         // final PhylogenyFactory factory = ParserBasedPhylogenyFactory
 730         // .getInstance();
 731         // try {
 732         //
 733         // Helper.readNHtree( new File( PATH_TO_EXAMPLE_FILES
 734         // + "\\AtNBSpos.nhx" ) );
 735         // factory.create(
 736         // new File( PATH_TO_EXAMPLE_FILES + "\\AtNBSpos.nhx" ),
 737         // new NHXParser() );
 738         // Helper.readNHtree( new File( PATH_TO_EXAMPLE_FILES
 739         // + "\\AtNBSpos.nhx" ) );
 740         // factory.create(
 741         // new File( PATH_TO_EXAMPLE_FILES + "\\AtNBSpos.nhx" ),
 742         // new NHXParser() );
 743         //
 744         //
 745         // Helper.readNHtree( new File( PATH_TO_EXAMPLE_FILES
 746         // + "\\big_tree.nhx" ) );
 747         // Helper.readNHtree( new File( PATH_TO_EXAMPLE_FILES
 748         // + "\\big_tree.nhx" ) );
 749         // factory.create(
 750         // new File( PATH_TO_EXAMPLE_FILES + "\\big_tree.nhx" ),
 751         // new NHXParser() );
 752         // factory.create(
 753         // new File( PATH_TO_EXAMPLE_FILES + "\\big_tree.nhx" ),
 754         // new NHXParser() );
 755         //
 756         // Helper.readNHtree( new File( PATH_TO_EXAMPLE_FILES
 757         // + "\\big_tree.nhx" ) );
 758         // Helper.readNHtree( new File( PATH_TO_EXAMPLE_FILES
 759         // + "\\big_tree.nhx" ) );
 760         //
 761         // factory.create(
 762         // new File( PATH_TO_EXAMPLE_FILES + "\\big_tree.nhx" ),
 763         // new NHXParser() );
 764         // factory.create(
 765         // new File( PATH_TO_EXAMPLE_FILES + "\\big_tree.nhx" ),
 766         // new NHXParser() );
 767         //
 768         // Helper.readNHtree( new File( PATH_TO_EXAMPLE_FILES
 769         // + "\\AtNBSpos.nhx" ) );
 770         // factory.create(
 771         // new File( PATH_TO_EXAMPLE_FILES + "\\AtNBSpos.nhx" ),
 772         // new NHXParser() );
 773         //
 774         // }
 775         // catch ( IOException e ) {
 776         // // TODO Auto-generated catch block
 777         // e.printStackTrace();
 778         // }
 779     }
 780
 781     private static boolean testBasicNodeMethods() {
 782         try {
 783             if ( PhylogenyNode.getNodeCount() != 0 ) {
 784                 return false;
 785             }
 786             final PhylogenyNode n1 = new PhylogenyNode();
 787             final PhylogenyNode n2 = new PhylogenyNode( "", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
 788             final PhylogenyNode n3 = new PhylogenyNode( "n3", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
 789             final PhylogenyNode n4 = new PhylogenyNode( "n4:0.01", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
 790             if ( n1.isHasAssignedEvent() ) {
 791                 return false;
 792             }
 793             if ( PhylogenyNode.getNodeCount() != 4 ) {
 794                 return false;
 795             }
 796             if ( n3.getIndicator() != 0 ) {
 797                 return false;
 798             }
 799             if ( n3.getNumberOfExternalNodes() != 1 ) {
 800                 return false;
 801             }
 802             if ( !n3.isExternal() ) {
 803                 return false;
 804             }
 805             if ( !n3.isRoot() ) {
 806                 return false;
 807             }
 808             if ( !n4.getName().equals( "n4" ) ) {
 809                 return false;
 810             }
 811         }
 812         catch ( final Exception e ) {
 813             e.printStackTrace( System.out );
 814             return false;
 815         }
 816         return true;
 817     }
 818
 819     private static boolean testBasicPhyloXMLparsing() {
 820         try {
 821             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
 822             final PhyloXmlParser xml_parser = new PhyloXmlParser();
 823             final Phylogeny[] phylogenies_0 = factory.create( Test.PATH_TO_TEST_DATA + "phyloxml_test_t1.xml",
 824                                                               xml_parser );
 825             if ( xml_parser.getErrorCount() > 0 ) {
 826                 System.out.println( xml_parser.getErrorMessages().toString() );
 827                 return false;
 828             }
 829             if ( phylogenies_0.length != 4 ) {
 830                 return false;
 831             }
 832             final Phylogeny t1 = phylogenies_0[ 0 ];
 833             final Phylogeny t2 = phylogenies_0[ 1 ];
 834             final Phylogeny t3 = phylogenies_0[ 2 ];
 835             final Phylogeny t4 = phylogenies_0[ 3 ];
 836             if ( t1.getNumberOfExternalNodes() != 1 ) {
 837                 return false;
 838             }
 839             if ( !t1.isRooted() ) {
 840                 return false;
 841             }
 842             if ( t1.isRerootable() ) {
 843                 return false;
 844             }
 845             if ( !t1.getType().equals( "gene_tree" ) ) {
 846                 return false;
 847             }
 848             if ( t2.getNumberOfExternalNodes() != 2 ) {
 849                 return false;
 850             }
 851             if ( !isEqual( t2.getNode( "node a" ).getDistanceToParent(), 1.0 ) ) {
 852                 return false;
 853             }
 854             if ( !isEqual( t2.getNode( "node b" ).getDistanceToParent(), 2.0 ) ) {
 855                 return false;
 856             }
 857             if ( t2.getNode( "node a" ).getNodeData().getTaxonomies().size() != 2 ) {
 858                 return false;
 859             }
 860             if ( !t2.getNode( "node a" ).getNodeData().getTaxonomy( 0 ).getCommonName().equals( "some parasite" ) ) {
 861                 return false;
 862             }
 863             if ( !t2.getNode( "node a" ).getNodeData().getTaxonomy( 1 ).getCommonName().equals( "the host" ) ) {
 864                 return false;
 865             }
 866             if ( t2.getNode( "node a" ).getNodeData().getSequences().size() != 2 ) {
 867                 return false;
 868             }
 869             if ( !t2.getNode( "node a" ).getNodeData().getSequence( 0 ).getMolecularSequence()
 870                     .startsWith( "actgtgggggt" ) ) {
 871                 return false;
 872             }
 873             if ( !t2.getNode( "node a" ).getNodeData().getSequence( 1 ).getMolecularSequence()
 874                     .startsWith( "ctgtgatgcat" ) ) {
 875                 return false;
 876             }
 877             if ( t3.getNumberOfExternalNodes() != 4 ) {
 878                 return false;
 879             }
 880             if ( !t1.getName().equals( "t1" ) ) {
 881                 return false;
 882             }
 883             if ( !t2.getName().equals( "t2" ) ) {
 884                 return false;
 885             }
 886             if ( !t3.getName().equals( "t3" ) ) {
 887                 return false;
 888             }
 889             if ( !t4.getName().equals( "t4" ) ) {
 890                 return false;
 891             }
 892             if ( !t3.getIdentifier().getValue().equals( "1-1" ) ) {
 893                 return false;
 894             }
 895             if ( !t3.getIdentifier().getProvider().equals( "treebank" ) ) {
 896                 return false;
 897             }
 898             if ( !t3.getNode( "root node" ).getNodeData().getSequence().getType().equals( "protein" ) ) {
 899                 return false;
 900             }
 901             if ( !t3.getNode( "root node" ).getNodeData().getSequence().getName()
 902                     .equals( "Apoptosis facilitator Bcl-2-like 14 protein" ) ) {
 903                 return false;
 904             }
 905             if ( !t3.getNode( "root node" ).getNodeData().getSequence().getSymbol().equals( "BCL2L14" ) ) {
 906                 return false;
 907             }
 908             if ( !t3.getNode( "root node" ).getNodeData().getSequence().getAccession().getValue().equals( "Q9BZR8" ) ) {
 909                 return false;
 910             }
 911             if ( !t3.getNode( "root node" ).getNodeData().getSequence().getAccession().getSource().equals( "UniProtKB" ) ) {
 912                 return false;
 913             }
 914             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getDesc()
 915                     .equals( "apoptosis" ) ) {
 916                 return false;
 917             }
 918             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getRef()
 919                     .equals( "GO:0006915" ) ) {
 920                 return false;
 921             }
 922             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getSource()
 923                     .equals( "UniProtKB" ) ) {
 924                 return false;
 925             }
 926             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getEvidence()
 927                     .equals( "experimental" ) ) {
 928                 return false;
 929             }
 930             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getType()
 931                     .equals( "function" ) ) {
 932                 return false;
 933             }
 934             if ( ( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getConfidence()
 935                     .getValue() != 1 ) {
 936                 return false;
 937             }
 938             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getConfidence()
 939                     .getType().equals( "ml" ) ) {
 940                 return false;
 941             }
 942             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getDesc()
 943                     .equals( "apoptosis" ) ) {
 944                 return false;
 945             }
 946             if ( ( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
 947                     .getProperty( "AFFY:expression" ).getAppliesTo() != AppliesTo.ANNOTATION ) {
 948                 return false;
 949             }
 950             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
 951                     .getProperty( "AFFY:expression" ).getDataType().equals( "xsd:double" ) ) {
 952                 return false;
 953             }
 954             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
 955                     .getProperty( "AFFY:expression" ).getRef().equals( "AFFY:expression" ) ) {
 956                 return false;
 957             }
 958             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
 959                     .getProperty( "AFFY:expression" ).getUnit().equals( "AFFY:x" ) ) {
 960                 return false;
 961             }
 962             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
 963                     .getProperty( "AFFY:expression" ).getValue().equals( "0.2" ) ) {
 964                 return false;
 965             }
 966             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
 967                     .getProperty( "MED:disease" ).getValue().equals( "lymphoma" ) ) {
 968                 return false;
 969             }
 970             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 0 ) ).getRef()
 971                     .equals( "GO:0005829" ) ) {
 972                 return false;
 973             }
 974             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 2 ) ).getDesc()
 975                     .equals( "intracellular organelle" ) ) {
 976                 return false;
 977             }
 978             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getUri( 0 ).getType().equals( "source" ) ) ) {
 979                 return false;
 980             }
 981             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getUri( 0 ).getDescription()
 982                     .equals( "UniProt link" ) ) ) {
 983                 return false;
 984             }
 985             if ( !( t3.getNode( "root node" ).getNodeData().getSequence().getLocation().equals( "12p13-p12" ) ) ) {
 986                 return false;
 987             }
 988             //if ( !( t3.getNode( "root node" ).getNodeData().getDistribution().getDesc().equals( "irgendwo" ) ) ) {
 989             //     return false;
 990             //}
 991             //            if ( !( t3.getNode( "root node" ).getNodeData().getReference().getDoi().equals( "10.1074/jbc.M005889200" ) ) ) {
 992             //                return false;
 993             //            }
 994             //            if ( !t3.getNode( "root node" ).getNodeData().getTaxonomy().getType().equals( "host" ) ) {
 995             //                return false;
 996             //            }
 997             //            if ( !t3.getNode( "root node" ).getNodeData().getTaxonomy().getTaxonomyCode().equals( "ECDYS" ) ) {
 998             //                return false;
 999             //            }
1000             //            if ( !t3.getNode( "root node" ).getNodeData().getTaxonomy().getScientificName().equals( "ecdysozoa" ) ) {
1001             //                return false;
1002             //            }
1003             //            if ( !t3.getNode( "root node" ).getNodeData().getTaxonomy().getCommonName().equals( "molting animals" ) ) {
1004             //                return false;
1005             //            }
1006             //            if ( !t3.getNode( "root node" ).getNodeData().getTaxonomy().getIdentifier().getValue().equals( "1" ) ) {
1007             //                return false;
1008             //            }
1009             //            if ( !t3.getNode( "root node" ).getNodeData().getTaxonomy().getIdentifier().getType().equals( "ncbi" ) ) {
1010             //                return false;
1011             //            }
1012             //            if ( t3.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getTotalLength() != 124 ) {
1013             //                return false;
1014             //            }
1015             //            if ( !t3.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 ).getName()
1016             //                    .equals( "B" ) ) {
1017             //                return false;
1018             //            }
1019             //            if ( t3.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 ).getFrom() != 21 ) {
1020             //                return false;
1021             //            }
1022             //            if ( t3.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 ).getTo() != 44 ) {
1023             //                return false;
1024             //            }
1025             //            if ( t3.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 ).getLength() != 24 ) {
1026             //                return false;
1027             //            }
1028             //            if ( t3.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 )
1029             //                    .getConfidence() != 2144 ) {
1030             //                return false;
1031             //            }
1032             //            if ( !t3.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 ).getId()
1033             //                    .equals( "pfam" ) ) {
1034             //                return false;
1035             //            }
1036             //            if ( t3.getNode( "node bb" ).getNodeData().getBinaryCharacters().getGainedCharacters().size() != 3 ) {
1037             //                return false;
1038             //            }
1039             //            if ( t3.getNode( "node bb" ).getNodeData().getBinaryCharacters().getPresentCharacters().size() != 2 ) {
1040             //                return false;
1041             //            }
1042             //            if ( t3.getNode( "node bb" ).getNodeData().getBinaryCharacters().getLostCharacters().size() != 1 ) {
1043             //                return false;
1044             //            }
1045             //            if ( !t3.getNode( "node bb" ).getNodeData().getBinaryCharacters().getType().equals( "domains" ) ) {
1046             //                return false;
1047             //            }
1048             //            if ( ( ( BinaryCharacters ) t3.getNode( "node bb" ).getNodeData().getBinaryCharacters().copy() )
1049             //                    .getLostCount() != BinaryCharacters.COUNT_DEFAULT ) {
1050             //                ;
1051             //                return false;
1052             //            }
1053             //            if ( t3.getNode( "node b" ).getNodeData().getBinaryCharacters().getGainedCount() != 1 ) {
1054             //                return false;
1055             //            }
1056             //            if ( t3.getNode( "node b" ).getNodeData().getBinaryCharacters().getGainedCharacters().size() != 1 ) {
1057             //                return false;
1058             //            }
1059             //            if ( t3.getNode( "node b" ).getNodeData().getBinaryCharacters().getLostCount() != 3 ) {
1060             //                return false;
1061             //            }
1062             //            if ( t3.getNode( "node b" ).getNodeData().getBinaryCharacters().getLostCharacters().size() != 3 ) {
1063             //                return false;
1064             //            }
1065             //            if ( t3.getNode( "node b" ).getNodeData().getBinaryCharacters().getPresentCount() != 2 ) {
1066             //                return false;
1067             //            }
1068             //            if ( t3.getNode( "node b" ).getNodeData().getBinaryCharacters().getPresentCharacters().size() != 2 ) {
1069             //                return false;
1070             //            }
1071             //            if ( !t3.getNode( "node b" ).getNodeData().getBinaryCharacters().getType().equals( "characters" ) ) {
1072             //                return false;
1073             //            }
1074             //            final Phylogeny[] phylogenies_1 = factory.create( Test.PATH_TO_TEST_DATA + "phyloxml_test_t4.xml",
1075             //                                                              xml_parser );
1076             //            if ( xml_parser.getErrorCount() > 0 ) {
1077             //                System.out.println( xml_parser.getErrorMessages().toString() );
1078             //                return false;
1079             //            }
1080             //            if ( phylogenies_1.length != 2 ) {
1081             //                return false;
1082             //            }
1083             //            final Phylogeny a = phylogenies_1[ 0 ];
1084             //            if ( !a.getName().equals( "tree 4" ) ) {
1085             //                return false;
1086             //            }
1087             //            if ( a.getNumberOfExternalNodes() != 3 ) {
1088             //                return false;
1089             //            }
1090             //            if ( !a.getNode( "node b1" ).getNodeData().getSequence().getName().equals( "b1 gene" ) ) {
1091             //                return false;
1092             //            }
1093             //            if ( !a.getNode( "node b1" ).getNodeData().getTaxonomy().getCommonName().equals( "b1 species" ) ) {
1094             //                return false;
1095             //            }
1096         }
1097         catch ( final Exception e ) {
1098             e.printStackTrace( System.out );
1099             return false;
1100         }
1101         return true;
1102     }
1103
1104     private static boolean testBasicPhyloXMLparsingRoundtrip() {
1105         try {
1106             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
1107             final PhyloXmlParser xml_parser = new PhyloXmlParser();
1108             if ( USE_LOCAL_PHYLOXML_SCHEMA ) {
1109                 xml_parser.setValidateAgainstSchema( PHYLOXML_LOCAL_XSD );
1110             }
1111             else {
1112                 xml_parser.setValidateAgainstSchema( PHYLOXML_REMOTE_XSD );
1113             }
1114             final Phylogeny[] phylogenies_0 = factory.create( Test.PATH_TO_TEST_DATA + "phyloxml_test_t1.xml",
1115                                                               xml_parser );
1116             if ( xml_parser.getErrorCount() > 0 ) {
1117                 System.out.println( xml_parser.getErrorMessages().toString() );
1118                 return false;
1119             }
1120             if ( phylogenies_0.length != 4 ) {
1121                 return false;
1122             }
1123             final StringBuffer t1_sb = new StringBuffer( phylogenies_0[ 0 ].toPhyloXML( 0 ) );
1124             final Phylogeny[] phylogenies_t1 = factory.create( t1_sb, xml_parser );
1125             if ( phylogenies_t1.length != 1 ) {
1126                 return false;
1127             }
1128             final Phylogeny t1_rt = phylogenies_t1[ 0 ];
1129             if ( !t1_rt.getDistanceUnit().equals( "cc" ) ) {
1130                 return false;
1131             }
1132             if ( !t1_rt.isRooted() ) {
1133                 return false;
1134             }
1135             if ( t1_rt.isRerootable() ) {
1136                 return false;
1137             }
1138             if ( !t1_rt.getType().equals( "gene_tree" ) ) {
1139                 return false;
1140             }
1141             final StringBuffer t2_sb = new StringBuffer( phylogenies_0[ 1 ].toPhyloXML( 0 ) );
1142             final Phylogeny[] phylogenies_t2 = factory.create( t2_sb, xml_parser );
1143             final Phylogeny t2_rt = phylogenies_t2[ 0 ];
1144             if ( t2_rt.getNode( "node a" ).getNodeData().getTaxonomies().size() != 2 ) {
1145                 return false;
1146             }
1147             if ( !t2_rt.getNode( "node a" ).getNodeData().getTaxonomy( 0 ).getCommonName().equals( "some parasite" ) ) {
1148                 return false;
1149             }
1150             if ( !t2_rt.getNode( "node a" ).getNodeData().getTaxonomy( 1 ).getCommonName().equals( "the host" ) ) {
1151                 return false;
1152             }
1153             if ( t2_rt.getNode( "node a" ).getNodeData().getSequences().size() != 2 ) {
1154                 return false;
1155             }
1156             if ( !t2_rt.getNode( "node a" ).getNodeData().getSequence( 0 ).getMolecularSequence()
1157                     .startsWith( "actgtgggggt" ) ) {
1158                 return false;
1159             }
1160             if ( !t2_rt.getNode( "node a" ).getNodeData().getSequence( 1 ).getMolecularSequence()
1161                     .startsWith( "ctgtgatgcat" ) ) {
1162                 return false;
1163             }
1164             final StringBuffer t3_sb_0 = new StringBuffer( phylogenies_0[ 2 ].toPhyloXML( 0 ) );
1165             final Phylogeny[] phylogenies_1_0 = factory.create( t3_sb_0, xml_parser );
1166             final StringBuffer t3_sb = new StringBuffer( phylogenies_1_0[ 0 ].toPhyloXML( 0 ) );
1167             final Phylogeny[] phylogenies_1 = factory.create( t3_sb, xml_parser );
1168             if ( phylogenies_1.length != 1 ) {
1169                 return false;
1170             }
1171             final Phylogeny t3_rt = phylogenies_1[ 0 ];
1172             if ( !t3_rt.getName().equals( "t3" ) ) {
1173                 return false;
1174             }
1175             if ( t3_rt.getNumberOfExternalNodes() != 4 ) {
1176                 return false;
1177             }
1178             if ( !t3_rt.getIdentifier().getValue().equals( "1-1" ) ) {
1179                 return false;
1180             }
1181             if ( !t3_rt.getIdentifier().getProvider().equals( "treebank" ) ) {
1182                 return false;
1183             }
1184             if ( !t3_rt.getNode( "root node" ).getNodeData().getSequence().getType().equals( "protein" ) ) {
1185                 return false;
1186             }
1187             if ( !t3_rt.getNode( "root node" ).getNodeData().getSequence().getName()
1188                     .equals( "Apoptosis facilitator Bcl-2-like 14 protein" ) ) {
1189                 return false;
1190             }
1191             if ( !t3_rt.getNode( "root node" ).getNodeData().getSequence().getSymbol().equals( "BCL2L14" ) ) {
1192                 return false;
1193             }
1194             if ( !t3_rt.getNode( "root node" ).getNodeData().getSequence().getAccession().getValue().equals( "Q9BZR8" ) ) {
1195                 return false;
1196             }
1197             if ( !t3_rt.getNode( "root node" ).getNodeData().getSequence().getAccession().getSource()
1198                     .equals( "UniProtKB" ) ) {
1199                 return false;
1200             }
1201             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getDesc()
1202                     .equals( "apoptosis" ) ) {
1203                 return false;
1204             }
1205             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getRef()
1206                     .equals( "GO:0006915" ) ) {
1207                 return false;
1208             }
1209             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getSource()
1210                     .equals( "UniProtKB" ) ) {
1211                 return false;
1212             }
1213             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getEvidence()
1214                     .equals( "experimental" ) ) {
1215                 return false;
1216             }
1217             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getType()
1218                     .equals( "function" ) ) {
1219                 return false;
1220             }
1221             if ( ( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getConfidence()
1222                     .getValue() != 1 ) {
1223                 return false;
1224             }
1225             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getConfidence()
1226                     .getType().equals( "ml" ) ) {
1227                 return false;
1228             }
1229             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getDesc()
1230                     .equals( "apoptosis" ) ) {
1231                 return false;
1232             }
1233             if ( ( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
1234                     .getProperty( "AFFY:expression" ).getAppliesTo() != AppliesTo.ANNOTATION ) {
1235                 return false;
1236             }
1237             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
1238                     .getProperty( "AFFY:expression" ).getDataType().equals( "xsd:double" ) ) {
1239                 return false;
1240             }
1241             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
1242                     .getProperty( "AFFY:expression" ).getRef().equals( "AFFY:expression" ) ) {
1243                 return false;
1244             }
1245             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
1246                     .getProperty( "AFFY:expression" ).getUnit().equals( "AFFY:x" ) ) {
1247                 return false;
1248             }
1249             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
1250                     .getProperty( "AFFY:expression" ).getValue().equals( "0.2" ) ) {
1251                 return false;
1252             }
1253             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 1 ) ).getProperties()
1254                     .getProperty( "MED:disease" ).getValue().equals( "lymphoma" ) ) {
1255                 return false;
1256             }
1257             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 0 ) ).getRef()
1258                     .equals( "GO:0005829" ) ) {
1259                 return false;
1260             }
1261             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getAnnotation( 2 ) ).getDesc()
1262                     .equals( "intracellular organelle" ) ) {
1263                 return false;
1264             }
1265             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getUri( 0 ).getType().equals( "source" ) ) ) {
1266                 return false;
1267             }
1268             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getUri( 0 ).getDescription()
1269                     .equals( "UniProt link" ) ) ) {
1270                 return false;
1271             }
1272             if ( !( t3_rt.getNode( "root node" ).getNodeData().getSequence().getLocation().equals( "12p13-p12" ) ) ) {
1273                 return false;
1274             }
1275             if ( !( t3_rt.getNode( "root node" ).getNodeData().getReference().getDoi().equals( "10.1038/387489a0" ) ) ) {
1276                 return false;
1277             }
1278             if ( !( t3_rt.getNode( "root node" ).getNodeData().getReference().getDescription()
1279                     .equals( "Aguinaldo, A. M. A.; J. M. Turbeville, L. S. Linford, M. C. Rivera, J. R. Garey, R. A. Raff, & J. A. Lake (1997). \"Evidence for a clade of nematodes, arthropods and other moulting animals\". Nature 387 (6632): 489–493." ) ) ) {
1280                 return false;
1281             }
1282             if ( !t3_rt.getNode( "root node" ).getNodeData().getTaxonomy().getTaxonomyCode().equals( "ECDYS" ) ) {
1283                 return false;
1284             }
1285             if ( !t3_rt.getNode( "root node" ).getNodeData().getTaxonomy().getScientificName().equals( "ecdysozoa" ) ) {
1286                 return false;
1287             }
1288             if ( !t3_rt.getNode( "root node" ).getNodeData().getTaxonomy().getCommonName().equals( "molting animals" ) ) {
1289                 return false;
1290             }
1291             if ( !t3_rt.getNode( "root node" ).getNodeData().getTaxonomy().getIdentifier().getValue().equals( "1" ) ) {
1292                 return false;
1293             }
1294             if ( !t3_rt.getNode( "root node" ).getNodeData().getTaxonomy().getIdentifier().getProvider()
1295                     .equals( "ncbi" ) ) {
1296                 return false;
1297             }
1298             if ( t3_rt.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getTotalLength() != 124 ) {
1299                 return false;
1300             }
1301             if ( !t3_rt.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 )
1302                     .getName().equals( "B" ) ) {
1303                 return false;
1304             }
1305             if ( t3_rt.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 )
1306                     .getFrom() != 21 ) {
1307                 return false;
1308             }
1309             if ( t3_rt.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 ).getTo() != 44 ) {
1310                 return false;
1311             }
1312             if ( t3_rt.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 )
1313                     .getLength() != 24 ) {
1314                 return false;
1315             }
1316             if ( t3_rt.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 )
1317                     .getConfidence() != 2144 ) {
1318                 return false;
1319             }
1320             if ( !t3_rt.getNode( "node bc" ).getNodeData().getSequence().getDomainArchitecture().getDomain( 0 ).getId()
1321                     .equals( "pfam" ) ) {
1322                 return false;
1323             }
1324             if ( t3_rt.getNode( "node bb" ).getNodeData().getBinaryCharacters().getGainedCharacters().size() != 3 ) {
1325                 return false;
1326             }
1327             if ( t3_rt.getNode( "node bb" ).getNodeData().getBinaryCharacters().getPresentCharacters().size() != 2 ) {
1328                 return false;
1329             }
1330             if ( t3_rt.getNode( "node bb" ).getNodeData().getBinaryCharacters().getLostCharacters().size() != 1 ) {
1331                 return false;
1332             }
1333             if ( !t3_rt.getNode( "node bb" ).getNodeData().getBinaryCharacters().getType().equals( "domains" ) ) {
1334                 return false;
1335             }
1336             final Taxonomy taxbb = t3_rt.getNode( "node bb" ).getNodeData().getTaxonomy();
1337             if ( !taxbb.getAuthority().equals( "Stephenson, 1935" ) ) {
1338                 return false;
1339             }
1340             if ( !taxbb.getCommonName().equals( "starlet sea anemone" ) ) {
1341                 return false;
1342             }
1343             if ( !taxbb.getIdentifier().getProvider().equals( "EOL" ) ) {
1344                 return false;
1345             }
1346             if ( !taxbb.getIdentifier().getValue().equals( "704294" ) ) {
1347                 return false;
1348             }
1349             if ( !taxbb.getTaxonomyCode().equals( "NEMVE" ) ) {
1350                 return false;
1351             }
1352             if ( !taxbb.getScientificName().equals( "Nematostella vectensis" ) ) {
1353                 return false;
1354             }
1355             if ( taxbb.getSynonyms().size() != 2 ) {
1356                 return false;
1357             }
1358             if ( !taxbb.getSynonyms().contains( "Nematostella vectensis Stephenson1935" ) ) {
1359                 return false;
1360             }
1361             if ( !taxbb.getSynonyms().contains( "See Anemone" ) ) {
1362                 return false;
1363             }
1364             if ( !taxbb.getUri( 0 ).getDescription().equals( "EOL" ) ) {
1365                 return false;
1366             }
1367             if ( !taxbb.getUri( 0 ).getType().equals( "linkout" ) ) {
1368                 return false;
1369             }
1370             if ( !taxbb.getUri( 0 ).getValue().toString().equals( "http://www.eol.org/pages/704294" ) ) {
1371                 return false;
1372             }
1373             if ( ( ( BinaryCharacters ) t3_rt.getNode( "node bb" ).getNodeData().getBinaryCharacters().copy() )
1374                     .getLostCount() != BinaryCharacters.COUNT_DEFAULT ) {
1375                 ;
1376                 return false;
1377             }
1378             if ( t3_rt.getNode( "node b" ).getNodeData().getBinaryCharacters().getGainedCount() != 1 ) {
1379                 return false;
1380             }
1381             if ( t3_rt.getNode( "node b" ).getNodeData().getBinaryCharacters().getGainedCharacters().size() != 1 ) {
1382                 return false;
1383             }
1384             if ( t3_rt.getNode( "node b" ).getNodeData().getBinaryCharacters().getLostCount() != 3 ) {
1385                 return false;
1386             }
1387             if ( t3_rt.getNode( "node b" ).getNodeData().getBinaryCharacters().getLostCharacters().size() != 3 ) {
1388                 return false;
1389             }
1390             if ( t3_rt.getNode( "node b" ).getNodeData().getBinaryCharacters().getPresentCount() != 2 ) {
1391                 return false;
1392             }
1393             if ( t3_rt.getNode( "node b" ).getNodeData().getBinaryCharacters().getPresentCharacters().size() != 2 ) {
1394                 return false;
1395             }
1396             if ( !t3_rt.getNode( "node b" ).getNodeData().getBinaryCharacters().getType().equals( "characters" ) ) {
1397                 return false;
1398             }
1399             //
1400             if ( !t3_rt.getNode( "node ba" ).getNodeData().getDate().getDesc().equals( "Silurian" ) ) {
1401                 return false;
1402             }
1403             if ( !t3_rt.getNode( "node ba" ).getNodeData().getDate().getValue().toPlainString()
1404                     .equalsIgnoreCase( "435" ) ) {
1405                 return false;
1406             }
1407             if ( !t3_rt.getNode( "node ba" ).getNodeData().getDate().getMin().toPlainString().equalsIgnoreCase( "416" ) ) {
1408                 return false;
1409             }
1410             if ( !t3_rt.getNode( "node ba" ).getNodeData().getDate().getMax().toPlainString()
1411                     .equalsIgnoreCase( "443.7" ) ) {
1412                 return false;
1413             }
1414             if ( !t3_rt.getNode( "node ba" ).getNodeData().getDate().getUnit().equals( "mya" ) ) {
1415                 return false;
1416             }
1417             if ( !t3_rt.getNode( "node bb" ).getNodeData().getDate().getDesc().equals( "Triassic" ) ) {
1418                 return false;
1419             }
1420             if ( !t3_rt.getNode( "node bc" ).getNodeData().getDate().getValue().toPlainString()
1421                     .equalsIgnoreCase( "433" ) ) {
1422                 return false;
1423             }
1424         }
1425         catch ( final Exception e ) {
1426             e.printStackTrace( System.out );
1427             return false;
1428         }
1429         return true;
1430     }
1431
1432     private static boolean testBasicPhyloXMLparsingValidating() {
1433         try {
1434             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
1435             PhyloXmlParser xml_parser = null;
1436             try {
1437                 xml_parser = PhyloXmlParser.createPhyloXmlParserXsdValidating();
1438             }
1439             catch ( final Exception e ) {
1440                 // Do nothing -- means were not running from jar.
1441             }
1442             if ( xml_parser == null ) {
1443                 xml_parser = new PhyloXmlParser();
1444                 if ( USE_LOCAL_PHYLOXML_SCHEMA ) {
1445                     xml_parser.setValidateAgainstSchema( PHYLOXML_LOCAL_XSD );
1446                 }
1447                 else {
1448                     xml_parser.setValidateAgainstSchema( PHYLOXML_REMOTE_XSD );
1449                 }
1450             }
1451             final Phylogeny[] phylogenies_0 = factory.create( Test.PATH_TO_TEST_DATA + "phyloxml_test_t1.xml",
1452                                                               xml_parser );
1453             if ( xml_parser.getErrorCount() > 0 ) {
1454                 System.out.println( xml_parser.getErrorMessages().toString() );
1455                 return false;
1456             }
1457             if ( phylogenies_0.length != 4 ) {
1458                 return false;
1459             }
1460             final Phylogeny t1 = phylogenies_0[ 0 ];
1461             final Phylogeny t2 = phylogenies_0[ 1 ];
1462             final Phylogeny t3 = phylogenies_0[ 2 ];
1463             final Phylogeny t4 = phylogenies_0[ 3 ];
1464             if ( !t1.getName().equals( "t1" ) ) {
1465                 return false;
1466             }
1467             if ( !t2.getName().equals( "t2" ) ) {
1468                 return false;
1469             }
1470             if ( !t3.getName().equals( "t3" ) ) {
1471                 return false;
1472             }
1473             if ( !t4.getName().equals( "t4" ) ) {
1474                 return false;
1475             }
1476             if ( t1.getNumberOfExternalNodes() != 1 ) {
1477                 return false;
1478             }
1479             if ( t2.getNumberOfExternalNodes() != 2 ) {
1480                 return false;
1481             }
1482             if ( t3.getNumberOfExternalNodes() != 4 ) {
1483                 return false;
1484             }
1485             final String x2 = Test.PATH_TO_TEST_DATA + "phyloxml_test_t1.xml";
1486             final Phylogeny[] phylogenies_1 = factory.create( x2, xml_parser );
1487             if ( xml_parser.getErrorCount() > 0 ) {
1488                 System.out.println( "errors:" );
1489                 System.out.println( xml_parser.getErrorMessages().toString() );
1490                 return false;
1491             }
1492             if ( phylogenies_1.length != 4 ) {
1493                 return false;
1494             }
1495             final Phylogeny[] phylogenies_2 = factory.create( Test.PATH_TO_TEST_DATA + "phyloxml_test_t3.xml",
1496                                                               xml_parser );
1497             if ( xml_parser.getErrorCount() > 0 ) {
1498                 System.out.println( "errors:" );
1499                 System.out.println( xml_parser.getErrorMessages().toString() );
1500                 return false;
1501             }
1502             if ( phylogenies_2.length != 1 ) {
1503                 return false;
1504             }
1505             if ( phylogenies_2[ 0 ].getNumberOfExternalNodes() != 2 ) {
1506                 return false;
1507             }
1508             final Phylogeny[] phylogenies_3 = factory.create( Test.PATH_TO_TEST_DATA + "phyloxml_test_t4.xml",
1509                                                               xml_parser );
1510             if ( xml_parser.getErrorCount() > 0 ) {
1511                 System.out.println( xml_parser.getErrorMessages().toString() );
1512                 return false;
1513             }
1514             if ( phylogenies_3.length != 2 ) {
1515                 return false;
1516             }
1517             final Phylogeny a = phylogenies_3[ 0 ];
1518             if ( !a.getName().equals( "tree 4" ) ) {
1519                 return false;
1520             }
1521             if ( a.getNumberOfExternalNodes() != 3 ) {
1522                 return false;
1523             }
1524             if ( !a.getNode( "node b1" ).getNodeData().getSequence().getName().equals( "b1 gene" ) ) {
1525                 return false;
1526             }
1527             if ( !a.getNode( "node b1" ).getNodeData().getTaxonomy().getCommonName().equals( "b1 species" ) ) {
1528                 return false;
1529             }
1530             final Phylogeny[] phylogenies_4 = factory.create( Test.PATH_TO_TEST_DATA + "special_characters.xml",
1531                                                               xml_parser );
1532             if ( xml_parser.getErrorCount() > 0 ) {
1533                 System.out.println( xml_parser.getErrorMessages().toString() );
1534                 return false;
1535             }
1536             if ( phylogenies_4.length != 1 ) {
1537                 return false;
1538             }
1539             final Phylogeny s = phylogenies_4[ 0 ];
1540             if ( s.getNumberOfExternalNodes() != 6 ) {
1541                 return false;
1542             }
1543             s.getNode( "first" );
1544             s.getNode( "<>" );
1545             s.getNode( "\"<a'b&c'd\">\"" );
1546             s.getNode( "'''\"" );
1547             s.getNode( "\"\"\"" );
1548             s.getNode( "dick & doof" );
1549         }
1550         catch ( final Exception e ) {
1551             e.printStackTrace( System.out );
1552             return false;
1553         }
1554         return true;
1555     }
1556
1557     private static boolean testBasicTable() {
1558         try {
1559             final BasicTable<String> t0 = new BasicTable<String>();
1560             if ( t0.getNumberOfColumns() != 0 ) {
1561                 return false;
1562             }
1563             if ( t0.getNumberOfRows() != 0 ) {
1564                 return false;
1565             }
1566             t0.setValue( 3, 2, "23" );
1567             t0.setValue( 10, 1, "error" );
1568             t0.setValue( 10, 1, "110" );
1569             t0.setValue( 9, 1, "19" );
1570             t0.setValue( 1, 10, "101" );
1571             t0.setValue( 10, 10, "1010" );
1572             t0.setValue( 100, 10, "10100" );
1573             t0.setValue( 0, 0, "00" );
1574             if ( !t0.getValue( 3, 2 ).equals( "23" ) ) {
1575                 return false;
1576             }
1577             if ( !t0.getValue( 10, 1 ).equals( "110" ) ) {
1578                 return false;
1579             }
1580             if ( !t0.getValueAsString( 1, 10 ).equals( "101" ) ) {
1581                 return false;
1582             }
1583             if ( !t0.getValueAsString( 10, 10 ).equals( "1010" ) ) {
1584                 return false;
1585             }
1586             if ( !t0.getValueAsString( 100, 10 ).equals( "10100" ) ) {
1587                 return false;
1588             }
1589             if ( !t0.getValueAsString( 9, 1 ).equals( "19" ) ) {
1590                 return false;
1591             }
1592             if ( !t0.getValueAsString( 0, 0 ).equals( "00" ) ) {
1593                 return false;
1594             }
1595             if ( t0.getNumberOfColumns() != 101 ) {
1596                 return false;
1597             }
1598             if ( t0.getNumberOfRows() != 11 ) {
1599                 return false;
1600             }
1601             if ( t0.getValueAsString( 49, 4 ) != null ) {
1602                 return false;
1603             }
1604             final String l = ForesterUtil.getLineSeparator();
1605             final StringBuffer source = new StringBuffer();
1606             source.append( "" + l );
1607             source.append( "# 1 1 1 1 1 1 1 1" + l );
1608             source.append( " 00 01 02 03" + l );
1609             source.append( "   10 11 12 13  " + l );
1610             source.append( "20 21 22 23 " + l );
1611             source.append( "    30  31    32 33" + l );
1612             source.append( "40 41 42 43" + l );
1613             source.append( "  # 1 1 1 1 1 " + l );
1614             source.append( "50 51 52 53 54" + l );
1615             final BasicTable<String> t1 = BasicTableParser.parse( source.toString(), " " );
1616             if ( t1.getNumberOfColumns() != 5 ) {
1617                 return false;
1618             }
1619             if ( t1.getNumberOfRows() != 6 ) {
1620                 return false;
1621             }
1622             if ( !t1.getValueAsString( 0, 0 ).equals( "00" ) ) {
1623                 return false;
1624             }
1625             if ( !t1.getValueAsString( 1, 0 ).equals( "01" ) ) {
1626                 return false;
1627             }
1628             if ( !t1.getValueAsString( 3, 0 ).equals( "03" ) ) {
1629                 return false;
1630             }
1631             if ( !t1.getValueAsString( 4, 5 ).equals( "54" ) ) {
1632                 return false;
1633             }
1634             final StringBuffer source1 = new StringBuffer();
1635             source1.append( "" + l );
1636             source1.append( "# 1; 1; 1; 1 ;1 ;1; 1 ;1;" + l );
1637             source1.append( " 00; 01 ;02;03" + l );
1638             source1.append( "   10; 11; 12; 13  " + l );
1639             source1.append( "20; 21; 22; 23 " + l );
1640             source1.append( "    30;  31;    32; 33" + l );
1641             source1.append( "40;41;42;43" + l );
1642             source1.append( "  # 1 1 1 1 1 " + l );
1643             source1.append( ";;;50  ;  ;52; 53;;54   " + l );
1644             final BasicTable<String> t2 = BasicTableParser.parse( source1.toString(), ";" );
1645             if ( t2.getNumberOfColumns() != 5 ) {
1646                 return false;
1647             }
1648             if ( t2.getNumberOfRows() != 6 ) {
1649                 return false;
1650             }
1651             if ( !t2.getValueAsString( 0, 0 ).equals( "00" ) ) {
1652                 return false;
1653             }
1654             if ( !t2.getValueAsString( 1, 0 ).equals( "01" ) ) {
1655                 return false;
1656             }
1657             if ( !t2.getValueAsString( 3, 0 ).equals( "03" ) ) {
1658                 return false;
1659             }
1660             if ( !t2.getValueAsString( 3, 3 ).equals( "33" ) ) {
1661                 return false;
1662             }
1663             if ( !t2.getValueAsString( 3, 5 ).equals( "53" ) ) {
1664                 return false;
1665             }
1666             if ( !t2.getValueAsString( 1, 5 ).equals( "" ) ) {
1667                 return false;
1668             }
1669             final StringBuffer source2 = new StringBuffer();
1670             source2.append( "" + l );
1671             source2.append( "comment: 1; 1; 1; 1 ;1 ;1; 1 ;1;" + l );
1672             source2.append( " 00; 01 ;02;03" + l );
1673             source2.append( "   10; 11; 12; 13  " + l );
1674             source2.append( "20; 21; 22; 23 " + l );
1675             source2.append( "                     " + l );
1676             source2.append( "    30;  31;    32; 33" + l );
1677             source2.append( "40;41;42;43" + l );
1678             source2.append( "  comment: 1 1 1 1 1 " + l );
1679             source2.append( ";;;50  ;   52; 53;;54   " + l );
1680             final List<BasicTable<String>> tl = BasicTableParser.parse( source2.toString(),
1681                                                                         ";",
1682                                                                         false,
1683                                                                         "comment:",
1684                                                                         false );
1685             if ( tl.size() != 2 ) {
1686                 return false;
1687             }
1688             final BasicTable<String> t3 = tl.get( 0 );
1689             final BasicTable<String> t4 = tl.get( 1 );
1690             if ( t3.getNumberOfColumns() != 4 ) {
1691                 return false;
1692             }
1693             if ( t3.getNumberOfRows() != 3 ) {
1694                 return false;
1695             }
1696             if ( t4.getNumberOfColumns() != 4 ) {
1697                 return false;
1698             }
1699             if ( t4.getNumberOfRows() != 3 ) {
1700                 return false;
1701             }
1702             if ( !t3.getValueAsString( 0, 0 ).equals( "00" ) ) {
1703                 return false;
1704             }
1705             if ( !t4.getValueAsString( 0, 0 ).equals( "30" ) ) {
1706                 return false;
1707             }
1708         }
1709         catch ( final Exception e ) {
1710             e.printStackTrace( System.out );
1711             return false;
1712         }
1713         return true;
1714     }
1715
1716     private static boolean testBasicTolXMLparsing() {
1717         try {
1718             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
1719             final TolParser parser = new TolParser();
1720             final Phylogeny[] phylogenies_0 = factory.create( Test.PATH_TO_TEST_DATA + "tol_2484.tol", parser );
1721             if ( parser.getErrorCount() > 0 ) {
1722                 System.out.println( parser.getErrorMessages().toString() );
1723                 return false;
1724             }
1725             if ( phylogenies_0.length != 1 ) {
1726                 return false;
1727             }
1728             final Phylogeny t1 = phylogenies_0[ 0 ];
1729             if ( t1.getNumberOfExternalNodes() != 5 ) {
1730                 return false;
1731             }
1732             if ( !t1.isRooted() ) {
1733                 return false;
1734             }
1735             if ( !t1.getRoot().getNodeData().getTaxonomy().getScientificName().equals( "Mesozoa" ) ) {
1736                 return false;
1737             }
1738             if ( !t1.getRoot().getNodeData().getTaxonomy().getIdentifier().getValue().equals( "2484" ) ) {
1739                 return false;
1740             }
1741             if ( !t1.getRoot().getChildNode( 0 ).getNodeData().getTaxonomy().getScientificName().equals( "Rhombozoa" ) ) {
1742                 return false;
1743             }
1744             if ( t1.getRoot().getChildNode( 0 ).getNumberOfDescendants() != 3 ) {
1745                 return false;
1746             }
1747             final Phylogeny[] phylogenies_1 = factory.create( Test.PATH_TO_TEST_DATA + "tol_2.tol", parser );
1748             if ( parser.getErrorCount() > 0 ) {
1749                 System.out.println( parser.getErrorMessages().toString() );
1750                 return false;
1751             }
1752             if ( phylogenies_1.length != 1 ) {
1753                 return false;
1754             }
1755             final Phylogeny t2 = phylogenies_1[ 0 ];
1756             if ( t2.getNumberOfExternalNodes() != 664 ) {
1757                 return false;
1758             }
1759             if ( !t2.isRooted() ) {
1760                 return false;
1761             }
1762             if ( !t2.getRoot().getNodeData().getTaxonomy().getScientificName().equals( "Eubacteria" ) ) {
1763                 return false;
1764             }
1765             if ( !t2.getRoot().getNodeData().getTaxonomy().getIdentifier().getValue().equals( "2" ) ) {
1766                 return false;
1767             }
1768             if ( t2.getRoot().getNumberOfDescendants() != 24 ) {
1769                 return false;
1770             }
1771             if ( t2.getRoot().getNumberOfDescendants() != 24 ) {
1772                 return false;
1773             }
1774             if ( !t2.getRoot().getChildNode( 0 ).getNodeData().getTaxonomy().getScientificName().equals( "Aquificae" ) ) {
1775                 return false;
1776             }
1777             if ( !t2.getRoot().getChildNode( 0 ).getChildNode( 0 ).getNodeData().getTaxonomy().getScientificName()
1778                     .equals( "Aquifex" ) ) {
1779                 return false;
1780             }
1781             final Phylogeny[] phylogenies_2 = factory.create( Test.PATH_TO_TEST_DATA + "tol_5.tol", parser );
1782             if ( parser.getErrorCount() > 0 ) {
1783                 System.out.println( parser.getErrorMessages().toString() );
1784                 return false;
1785             }
1786             if ( phylogenies_2.length != 1 ) {
1787                 return false;
1788             }
1789             final Phylogeny t3 = phylogenies_2[ 0 ];
1790             if ( t3.getNumberOfExternalNodes() != 184 ) {
1791                 return false;
1792             }
1793             if ( !t3.getRoot().getNodeData().getTaxonomy().getScientificName().equals( "Viruses" ) ) {
1794                 return false;
1795             }
1796             if ( !t3.getRoot().getNodeData().getTaxonomy().getIdentifier().getValue().equals( "5" ) ) {
1797                 return false;
1798             }
1799             if ( t3.getRoot().getNumberOfDescendants() != 6 ) {
1800                 return false;
1801             }
1802             final Phylogeny[] phylogenies_3 = factory.create( Test.PATH_TO_TEST_DATA + "tol_4567.tol", parser );
1803             if ( parser.getErrorCount() > 0 ) {
1804                 System.out.println( parser.getErrorMessages().toString() );
1805                 return false;
1806             }
1807             if ( phylogenies_3.length != 1 ) {
1808                 return false;
1809             }
1810             final Phylogeny t4 = phylogenies_3[ 0 ];
1811             if ( t4.getNumberOfExternalNodes() != 1 ) {
1812                 return false;
1813             }
1814             if ( !t4.getRoot().getNodeData().getTaxonomy().getScientificName().equals( "Marpissa decorata" ) ) {
1815                 return false;
1816             }
1817             if ( !t4.getRoot().getNodeData().getTaxonomy().getIdentifier().getValue().equals( "4567" ) ) {
1818                 return false;
1819             }
1820             if ( t4.getRoot().getNumberOfDescendants() != 0 ) {
1821                 return false;
1822             }
1823             final Phylogeny[] phylogenies_4 = factory.create( Test.PATH_TO_TEST_DATA + "tol_16299.tol", parser );
1824             if ( parser.getErrorCount() > 0 ) {
1825                 System.out.println( parser.getErrorMessages().toString() );
1826                 return false;
1827             }
1828             if ( phylogenies_4.length != 1 ) {
1829                 return false;
1830             }
1831             final Phylogeny t5 = phylogenies_4[ 0 ];
1832             if ( t5.getNumberOfExternalNodes() != 13 ) {
1833                 return false;
1834             }
1835             if ( !t5.getRoot().getNodeData().getTaxonomy().getScientificName().equals( "Hominidae" ) ) {
1836                 return false;
1837             }
1838             if ( !t5.getRoot().getNodeData().getTaxonomy().getIdentifier().getValue().equals( "16299" ) ) {
1839                 return false;
1840             }
1841             if ( t5.getRoot().getNumberOfDescendants() != 2 ) {
1842                 return false;
1843             }
1844         }
1845         catch ( final Exception e ) {
1846             e.printStackTrace( System.out );
1847             return false;
1848         }
1849         return true;
1850     }
1851
1852     private static boolean testBasicTreeMethods() {
1853         try {
1854             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
1855             final Phylogeny t1 = factory.create();
1856             if ( !t1.isEmpty() ) {
1857                 return false;
1858             }
1859             final Phylogeny t2 = factory.create( "((A:1,B:2)AB:1,(C:3,D:5)CD:3)ABCD:0.5", new NHXParser() )[ 0 ];
1860             if ( t2.getNumberOfExternalNodes() != 4 ) {
1861                 return false;
1862             }
1863             if ( t2.getHeight() != 8.5 ) {
1864                 return false;
1865             }
1866             if ( !t2.isCompletelyBinary() ) {
1867                 return false;
1868             }
1869             if ( t2.isEmpty() ) {
1870                 return false;
1871             }
1872             final Phylogeny t3 = factory.create( "((A:1,B:2,C:10)ABC:1,(D:3,E:5)DE:3)", new NHXParser() )[ 0 ];
1873             if ( t3.getNumberOfExternalNodes() != 5 ) {
1874                 return false;
1875             }
1876             if ( t3.getHeight() != 11 ) {
1877                 return false;
1878             }
1879             if ( t3.isCompletelyBinary() ) {
1880                 return false;
1881             }
1882             final PhylogenyNode n = t3.getNode( "ABC" );
1883             PhylogenyNodeIterator it;
1884             for( it = n.iterateChildNodesForward(); it.hasNext(); ) {
1885                 it.next();
1886             }
1887             for( it.reset(); it.hasNext(); ) {
1888                 it.next();
1889             }
1890             final PhylogenyNodeIterator it2 = n.iterateChildNodesForward();
1891             if ( !it2.next().getName().equals( "A" ) ) {
1892                 return false;
1893             }
1894             if ( !it2.next().getName().equals( "B" ) ) {
1895                 return false;
1896             }
1897             if ( !it2.next().getName().equals( "C" ) ) {
1898                 return false;
1899             }
1900             if ( it2.hasNext() ) {
1901                 return false;
1902             }
1903             final Phylogeny t4 = factory.create( "((A:1,B:2,C:10)ABC:1,(D:3,E:5)DE:3,(F,G,H,I))", new NHXParser() )[ 0 ];
1904             if ( t4.getNumberOfExternalNodes() != 9 ) {
1905                 return false;
1906             }
1907             if ( t4.getHeight() != 11 ) {
1908                 return false;
1909             }
1910             if ( t4.isCompletelyBinary() ) {
1911                 return false;
1912             }
1913             final StringBuffer sb5 = new StringBuffer( "(((A11:2)A1:2,(A21:1,A22:2,A23)A2:11,A3:2)A:2,B:10,C:3,D:8)" );
1914             final Phylogeny t5 = factory.create( sb5, new NHXParser() )[ 0 ];
1915             if ( t5.getNumberOfExternalNodes() != 8 ) {
1916                 return false;
1917             }
1918             if ( t5.getHeight() != 15 ) {
1919                 return false;
1920             }
1921             final StringBuffer sb6 = new StringBuffer( "(X,Y,Z,(((A111)A11:2)A1:2,(X,Y,Z,A21:1,A22:2,A23)A2:11,A3:2)A:2,B:10,C:3,D:8)" );
1922             final Phylogeny t6 = factory.create( sb6, new NHXParser() )[ 0 ];
1923             if ( t6.getHeight() != 15 ) {
1924                 return false;
1925             }
1926             final StringBuffer sb7 = new StringBuffer( "(((A11:2)A1:2,(A21:1,A22:2,A23)A2:11,A3:2)A:2,B:10,C:15,D:8)" );
1927             final Phylogeny t7 = factory.create( sb7, new NHXParser() )[ 0 ];
1928             if ( t7.getHeight() != 15 ) {
1929                 return false;
1930             }
1931             final StringBuffer sb8 = new StringBuffer( "(((A11:11)A1:2,(A21:2,A22:2,A23,A24,AA:)A2:11,A3:2)A:2,B:15,C:15,D:15)" );
1932             final Phylogeny t8 = factory.create( sb8, new NHXParser() )[ 0 ];
1933             if ( t8.getNumberOfExternalNodes() != 10 ) {
1934                 return false;
1935             }
1936             if ( t8.getHeight() != 15 ) {
1937                 return false;
1938             }
1939             final char[] a9 = new char[] {};
1940             final Phylogeny t9 = factory.create( a9, new NHXParser() )[ 0 ];
1941             if ( t9.getHeight() != 0 ) {
1942                 return false;
1943             }
1944             final char[] a10 = new char[] { 'a', ':', '6' };
1945             final Phylogeny t10 = factory.create( a10, new NHXParser() )[ 0 ];
1946             if ( t10.getHeight() != 6 ) {
1947                 return false;
1948             }
1949         }
1950         catch ( final Exception e ) {
1951             e.printStackTrace( System.out );
1952             return false;
1953         }
1954         return true;
1955     }
1956
1957     private static boolean testConfidenceAssessor() {
1958         try {
1959             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
1960             final Phylogeny t0 = factory.create( "((((A,B)ab,C)abc,D)abcd,E)abcde", new NHXParser() )[ 0 ];
1961             final Phylogeny[] ev0 = factory
1962                     .create( "((((A,B),C),D),E);((((A,B),C),D),E);((((A,B),C),D),E);((((A,B),C),D),E);",
1963                              new NHXParser() );
1964             ConfidenceAssessor.evaluate( "bootstrap", ev0, t0, false, 1, 0, 2 );
1965             if ( !isEqual( t0.getNode( "ab" ).getBranchData().getConfidence( 0 ).getValue(), 3 ) ) {
1966                 return false;
1967             }
1968             if ( !isEqual( t0.getNode( "abc" ).getBranchData().getConfidence( 0 ).getValue(), 3 ) ) {
1969                 return false;
1970             }
1971             final Phylogeny t1 = factory.create( "((((A,B)ab[&&NHX:B=50],C)abc,D)abcd,E)abcde", new NHXParser() )[ 0 ];
1972             final Phylogeny[] ev1 = factory
1973                     .create( "((((A,B),C),D),E);((A,B),((E,D),C));(((A,B),C),(E,D));(A,(((E,D),C),B));(B,(A,((E,D),C)));(C,((E,D),(A,B)));(D,(E,((A,B),C)));",
1974                              new NHXParser() );
1975             ConfidenceAssessor.evaluate( "bootstrap", ev1, t1, false, 1 );
1976             if ( !isEqual( t1.getNode( "ab" ).getBranchData().getConfidence( 1 ).getValue(), 7 ) ) {
1977                 return false;
1978             }
1979             if ( !isEqual( t1.getNode( "abc" ).getBranchData().getConfidence( 0 ).getValue(), 7 ) ) {
1980                 return false;
1981             }
1982             final Phylogeny t_b = factory.create( "((((A,C)ac,D)acd,E)acde,B)abcde", new NHXParser() )[ 0 ];
1983             final Phylogeny[] ev_b = factory
1984                     .create( "((A,C),X);((A,X),C);(A,C);((((A,B),C),D),E);((A,B),((E,D),C));(((A,B),C),(E,D));(A,(((E,D),C),B));(B,(A,((E,D),C)));(C,((E,D),(A,B)));(D,(E,((A,B),C)));((((A,C)ac,D)acd,E)acde,B)abcd",
1985                              new NHXParser() );
1986             ConfidenceAssessor.evaluate( "bootstrap", ev_b, t_b, false, 1 );
1987             // Archaeopteryx.createApplication( t_b ); //TODO use me again me working here...
1988             if ( !isEqual( t_b.getNode( "ac" ).getBranchData().getConfidence( 0 ).getValue(), 4 ) ) {
1989                 return false;
1990             }
1991             if ( !isEqual( t_b.getNode( "acd" ).getBranchData().getConfidence( 0 ).getValue(), 1 ) ) {
1992                 return false;
1993             }
1994             //
1995             final Phylogeny t1x = factory.create( "((((A,B)ab,C)abc,D)abcd,E)abcde", new NHXParser() )[ 0 ];
1996             final Phylogeny[] ev1x = factory
1997                     .create( "((((A,B),C),D),E);((A,B),((E,D),C));(((A,B),C),(E,D));(A,(((E,D),C),B));(B,(A,((E,D),C)));(C,((E,D),(A,B)));(D,(E,((A,B),C)));",
1998                              new NHXParser() );
1999             ConfidenceAssessor.evaluate( "bootstrap", ev1x, t1x, true, 1 );
2000             if ( !isEqual( t1x.getNode( "ab" ).getBranchData().getConfidence( 0 ).getValue(), 7 ) ) {
2001                 return false;
2002             }
2003             if ( !isEqual( t1x.getNode( "abc" ).getBranchData().getConfidence( 0 ).getValue(), 7 ) ) {
2004                 return false;
2005             }
2006             final Phylogeny t_bx = factory.create( "((((A,C)ac,D)acd,E)acde,B)abcde", new NHXParser() )[ 0 ];
2007             final Phylogeny[] ev_bx = factory
2008                     .create( "((((A,B),C),D),E);((A,B),((E,D),C));(((A,B),C),(E,D));(A,(((E,D),C),B));(B,(A,((E,D),C)));(C,((E,D),(A,B)));(D,(E,((A,B),C)));((((A,C)ac,D)acd,E)acde,B)abcd",
2009                              new NHXParser() );
2010             ConfidenceAssessor.evaluate( "bootstrap", ev_bx, t_bx, true, 1 );
2011             if ( !isEqual( t_bx.getNode( "ac" ).getBranchData().getConfidence( 0 ).getValue(), 1 ) ) {
2012                 return false;
2013             }
2014             if ( !isEqual( t_bx.getNode( "acd" ).getBranchData().getConfidence( 0 ).getValue(), 1 ) ) {
2015                 return false;
2016             }
2017             //
2018             final Phylogeny[] t2 = factory
2019                     .create( "((((a,b),c),d),e);(((a,b),c),(d,e));(((((a,b),c),d),e),f);((((a,b),c),(d,e)),f);(((a,b),c),d,e);((a,b,c),d,e);",
2020                              new NHXParser() );
2021             final Phylogeny[] ev2 = factory
2022                     .create( "((((a,b),c),d),e);((((a,b),c),d),e);((((a,b),e),d),c);((((a,b),e),d),c);(((a,b),(c,d)),e);((a,b),x);((a,b),(x,y));(a,b);(a,e);(a,b,c);",
2023                              new NHXParser() );
2024             for( final Phylogeny target : t2 ) {
2025                 ConfidenceAssessor.evaluate( "bootstrap", ev2, target, false, 1 );
2026             }
2027             //
2028             final Phylogeny t4 = factory.create( "((((((A,B)ab,C)abc,D)abcd,E)abcde,F)abcdef,G)abcdefg",
2029                                                  new NHXParser() )[ 0 ];
2030             final Phylogeny[] ev4 = factory.create( "(((A,B),C),(X,Y));((F,G),((A,B,C),(D,E)))", new NHXParser() );
2031             ConfidenceAssessor.evaluate( "bootstrap", ev4, t4, false, 1 );
2032             if ( !isEqual( t4.getNode( "ab" ).getBranchData().getConfidence( 0 ).getValue(), 1 ) ) {
2033                 return false;
2034             }
2035             if ( !isEqual( t4.getNode( "abc" ).getBranchData().getConfidence( 0 ).getValue(), 2 ) ) {
2036                 return false;
2037             }
2038             if ( !isEqual( t4.getNode( "abcde" ).getBranchData().getConfidence( 0 ).getValue(), 1 ) ) {
2039                 return false;
2040             }
2041         }
2042         catch ( final Exception e ) {
2043             e.printStackTrace();
2044             return false;
2045         }
2046         return true;
2047     }
2048
2049     private static boolean testCopyOfNodeData() {
2050         try {
2051             final PhylogenyNode n1 = new PhylogenyNode( "n5:0.1[&&NHX:S=Ecoli:E=1.1.1.1:D=Y:Co=Y:B=56:T=1:O=22:SO=33:SN=44:W=2:C=10.20.30:XN=S=tag1=value1=unit1]" );
2052             final PhylogenyNode n2 = n1.copyNodeData();
2053             if ( !n1.toNewHampshireX().equals( n2.toNewHampshireX() ) ) {
2054                 return false;
2055             }
2056         }
2057         catch ( final Exception e ) {
2058             e.printStackTrace();
2059             return false;
2060         }
2061         return true;
2062     }
2063
2064     private static boolean testDataObjects() {
2065         try {
2066             final Confidence s0 = new Confidence();
2067             final Confidence s1 = new Confidence();
2068             if ( !s0.isEqual( s1 ) ) {
2069                 return false;
2070             }
2071             final Confidence s2 = new Confidence( 0.23, "bootstrap" );
2072             final Confidence s3 = new Confidence( 0.23, "bootstrap" );
2073             if ( s2.isEqual( s1 ) ) {
2074                 return false;
2075             }
2076             if ( !s2.isEqual( s3 ) ) {
2077                 return false;
2078             }
2079             final Confidence s4 = ( Confidence ) s3.copy();
2080             if ( !s4.isEqual( s3 ) ) {
2081                 return false;
2082             }
2083             s3.asSimpleText();
2084             s3.asText();
2085             // Taxonomy
2086             // ----------
2087             final Taxonomy t1 = new Taxonomy();
2088             final Taxonomy t2 = new Taxonomy();
2089             final Taxonomy t3 = new Taxonomy();
2090             final Taxonomy t4 = new Taxonomy();
2091             final Taxonomy t5 = new Taxonomy();
2092             t1.setIdentifier( new Identifier( "ecoli" ) );
2093             t1.setTaxonomyCode( "ECOLI" );
2094             t1.setScientificName( "E. coli" );
2095             t1.setCommonName( "coli" );
2096             final Taxonomy t0 = ( Taxonomy ) t1.copy();
2097             if ( !t1.isEqual( t0 ) ) {
2098                 return false;
2099             }
2100             t2.setIdentifier( new Identifier( "ecoli" ) );
2101             t2.setTaxonomyCode( "other" );
2102             t2.setScientificName( "what" );
2103             t2.setCommonName( "something" );
2104             if ( !t1.isEqual( t2 ) ) {
2105                 return false;
2106             }
2107             t2.setIdentifier( new Identifier( "nemve" ) );
2108             if ( t1.isEqual( t2 ) ) {
2109                 return false;
2110             }
2111             t1.setIdentifier( null );
2112             t3.setTaxonomyCode( "ECOLI" );
2113             t3.setScientificName( "what" );
2114             t3.setCommonName( "something" );
2115             if ( !t1.isEqual( t3 ) ) {
2116                 return false;
2117             }
2118             t1.setIdentifier( null );
2119             t1.setTaxonomyCode( "" );
2120             t4.setScientificName( "E. ColI" );
2121             t4.setCommonName( "something" );
2122             if ( !t1.isEqual( t4 ) ) {
2123                 return false;
2124             }
2125             t4.setScientificName( "B. subtilis" );
2126             t4.setCommonName( "something" );
2127             if ( t1.isEqual( t4 ) ) {
2128                 return false;
2129             }
2130             t1.setIdentifier( null );
2131             t1.setTaxonomyCode( "" );
2132             t1.setScientificName( "" );
2133             t5.setCommonName( "COLI" );
2134             if ( !t1.isEqual( t5 ) ) {
2135                 return false;
2136             }
2137             t5.setCommonName( "vibrio" );
2138             if ( t1.isEqual( t5 ) ) {
2139                 return false;
2140             }
2141             // Identifier
2142             // ----------
2143             final Identifier id0 = new Identifier( "123", "pfam" );
2144             final Identifier id1 = ( Identifier ) id0.copy();
2145             if ( !id1.isEqual( id1 ) ) {
2146                 return false;
2147             }
2148             if ( !id1.isEqual( id0 ) ) {
2149                 return false;
2150             }
2151             if ( !id0.isEqual( id1 ) ) {
2152                 return false;
2153             }
2154             id1.asSimpleText();
2155             id1.asText();
2156             // ProteinDomain
2157             // ---------------
2158             final ProteinDomain pd0 = new ProteinDomain( "abc", 100, 200 );
2159             final ProteinDomain pd1 = ( ProteinDomain ) pd0.copy();
2160             if ( !pd1.isEqual( pd1 ) ) {
2161                 return false;
2162             }
2163             if ( !pd1.isEqual( pd0 ) ) {
2164                 return false;
2165             }
2166             pd1.asSimpleText();
2167             pd1.asText();
2168             final ProteinDomain pd2 = new ProteinDomain( pd0.getName(), pd0.getFrom(), pd0.getTo(), "id" );
2169             final ProteinDomain pd3 = ( ProteinDomain ) pd2.copy();
2170             if ( !pd3.isEqual( pd3 ) ) {
2171                 return false;
2172             }
2173             if ( !pd2.isEqual( pd3 ) ) {
2174                 return false;
2175             }
2176             if ( !pd0.isEqual( pd3 ) ) {
2177                 return false;
2178             }
2179             pd3.asSimpleText();
2180             pd3.asText();
2181             // DomainArchitecture
2182             // ------------------
2183             final ProteinDomain d0 = new ProteinDomain( "domain0", 10, 20 );
2184             final ProteinDomain d1 = new ProteinDomain( "domain1", 30, 40 );
2185             final ProteinDomain d2 = new ProteinDomain( "domain2", 50, 60 );
2186             final ProteinDomain d3 = new ProteinDomain( "domain3", 70, 80 );
2187             final ProteinDomain d4 = new ProteinDomain( "domain4", 90, 100 );
2188             final ArrayList<PhylogenyData> domains0 = new ArrayList<PhylogenyData>();
2189             domains0.add( d2 );
2190             domains0.add( d0 );
2191             domains0.add( d3 );
2192             domains0.add( d1 );
2193             final DomainArchitecture ds0 = new DomainArchitecture( domains0, 110 );
2194             if ( ds0.getNumberOfDomains() != 4 ) {
2195                 return false;
2196             }
2197             final DomainArchitecture ds1 = ( DomainArchitecture ) ds0.copy();
2198             if ( !ds0.isEqual( ds0 ) ) {
2199                 return false;
2200             }
2201             if ( !ds0.isEqual( ds1 ) ) {
2202                 return false;
2203             }
2204             if ( ds1.getNumberOfDomains() != 4 ) {
2205                 return false;
2206             }
2207             final ArrayList<PhylogenyData> domains1 = new ArrayList<PhylogenyData>();
2208             domains1.add( d1 );
2209             domains1.add( d2 );
2210             domains1.add( d4 );
2211             domains1.add( d0 );
2212             final DomainArchitecture ds2 = new DomainArchitecture( domains1, 200 );
2213             if ( ds0.isEqual( ds2 ) ) {
2214                 return false;
2215             }
2216             ds1.asSimpleText();
2217             ds1.asText();
2218             ds1.toNHX();
2219             final DomainArchitecture ds3 = new DomainArchitecture( "120>30>40>0.9>b>50>60>0.4>c>10>20>0.1>a" );
2220             if ( !ds3.toNHX().toString().equals( ":DS=120>10>20>0.1>a>30>40>0.9>b>50>60>0.4>c" ) ) {
2221                 System.out.println( ds3.toNHX() );
2222                 return false;
2223             }
2224             if ( ds3.getNumberOfDomains() != 3 ) {
2225                 return false;
2226             }
2227             // Event
2228             // -----
2229             final Event e1 = new Event( Event.EventType.fusion );
2230             if ( e1.isDuplication() ) {
2231                 return false;
2232             }
2233             if ( !e1.isFusion() ) {
2234                 return false;
2235             }
2236             if ( !e1.asText().toString().equals( "fusion" ) ) {
2237                 return false;
2238             }
2239             if ( !e1.asSimpleText().toString().equals( "fusion" ) ) {
2240                 return false;
2241             }
2242             final Event e11 = new Event( Event.EventType.fusion );
2243             if ( !e11.isEqual( e1 ) ) {
2244                 return false;
2245             }
2246             if ( !e11.toNHX().toString().equals( "" ) ) {
2247                 return false;
2248             }
2249             final Event e2 = new Event( Event.EventType.speciation_or_duplication );
2250             if ( e2.isDuplication() ) {
2251                 return false;
2252             }
2253             if ( !e2.isSpeciationOrDuplication() ) {
2254                 return false;
2255             }
2256             if ( !e2.asText().toString().equals( "speciation_or_duplication" ) ) {
2257                 return false;
2258             }
2259             if ( !e2.asSimpleText().toString().equals( "?" ) ) {
2260                 return false;
2261             }
2262             if ( !e2.toNHX().toString().equals( ":D=?" ) ) {
2263                 return false;
2264             }
2265             if ( e11.isEqual( e2 ) ) {
2266                 return false;
2267             }
2268             final Event e2c = ( Event ) e2.copy();
2269             if ( !e2c.isEqual( e2 ) ) {
2270                 return false;
2271             }
2272             Event e3 = new Event( 1, 2, 3 );
2273             if ( e3.isDuplication() ) {
2274                 return false;
2275             }
2276             if ( e3.isSpeciation() ) {
2277                 return false;
2278             }
2279             if ( e3.isGeneLoss() ) {
2280                 return false;
2281             }
2282             if ( !e3.asText().toString().equals( "duplications [1] speciations [2] gene-losses [3]" ) ) {
2283                 return false;
2284             }
2285             final Event e3c = ( Event ) e3.copy();
2286             final Event e3cc = ( Event ) e3c.copy();
2287             if ( !e3c.asSimpleText().toString().equals( "D2S3L" ) ) {
2288                 return false;
2289             }
2290             e3 = null;
2291             if ( !e3c.isEqual( e3cc ) ) {
2292                 return false;
2293             }
2294             Event e4 = new Event( 1, 2, 3 );
2295             if ( !e4.asText().toString().equals( "duplications [1] speciations [2] gene-losses [3]" ) ) {
2296                 return false;
2297             }
2298             if ( !e4.asSimpleText().toString().equals( "D2S3L" ) ) {
2299                 return false;
2300             }
2301             final Event e4c = ( Event ) e4.copy();
2302             e4 = null;
2303             final Event e4cc = ( Event ) e4c.copy();
2304             if ( !e4cc.asText().toString().equals( "duplications [1] speciations [2] gene-losses [3]" ) ) {
2305                 return false;
2306             }
2307             if ( !e4c.isEqual( e4cc ) ) {
2308                 return false;
2309             }
2310             final Event e5 = new Event();
2311             if ( !e5.isUnassigned() ) {
2312                 return false;
2313             }
2314             if ( !e5.asText().toString().equals( "unassigned" ) ) {
2315                 return false;
2316             }
2317             if ( !e5.asSimpleText().toString().equals( "" ) ) {
2318                 return false;
2319             }
2320             final Event e6 = new Event( 1, 0, 0 );
2321             if ( !e6.asText().toString().equals( "duplication" ) ) {
2322                 return false;
2323             }
2324             if ( !e6.asSimpleText().toString().equals( "D" ) ) {
2325                 return false;
2326             }
2327             final Event e7 = new Event( 0, 1, 0 );
2328             if ( !e7.asText().toString().equals( "speciation" ) ) {
2329                 return false;
2330             }
2331             if ( !e7.asSimpleText().toString().equals( "S" ) ) {
2332                 return false;
2333             }
2334             final Event e8 = new Event( 0, 0, 1 );
2335             if ( !e8.asText().toString().equals( "gene-loss" ) ) {
2336                 return false;
2337             }
2338             if ( !e8.asSimpleText().toString().equals( "L" ) ) {
2339                 return false;
2340             }
2341         }
2342         catch ( final Exception e ) {
2343             e.printStackTrace( System.out );
2344             return false;
2345         }
2346         return true;
2347     }
2348
2349     private static boolean testDeletionOfExternalNodes() {
2350         try {
2351             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
2352             final Phylogeny t0 = factory.create( "A", new NHXParser() )[ 0 ];
2353             final PhylogenyWriter w = new PhylogenyWriter();
2354             if ( t0.isEmpty() ) {
2355                 return false;
2356             }
2357             if ( t0.getNumberOfExternalNodes() != 1 ) {
2358                 return false;
2359             }
2360             t0.deleteSubtree( t0.getNode( "A" ), false );
2361             if ( t0.getNumberOfExternalNodes() != 0 ) {
2362                 return false;
2363             }
2364             if ( !t0.isEmpty() ) {
2365                 return false;
2366             }
2367             final Phylogeny t1 = factory.create( "(A,B)r", new NHXParser() )[ 0 ];
2368             if ( t1.getNumberOfExternalNodes() != 2 ) {
2369                 return false;
2370             }
2371             t1.deleteSubtree( t1.getNode( "A" ), false );
2372             if ( t1.getNumberOfExternalNodes() != 1 ) {
2373                 return false;
2374             }
2375             if ( !t1.getNode( "B" ).getName().equals( "B" ) ) {
2376                 return false;
2377             }
2378             t1.deleteSubtree( t1.getNode( "B" ), false );
2379             if ( t1.getNumberOfExternalNodes() != 1 ) {
2380                 return false;
2381             }
2382             t1.deleteSubtree( t1.getNode( "r" ), false );
2383             if ( !t1.isEmpty() ) {
2384                 return false;
2385             }
2386             final Phylogeny t2 = factory.create( "((A,B),C)", new NHXParser() )[ 0 ];
2387             if ( t2.getNumberOfExternalNodes() != 3 ) {
2388                 return false;
2389             }
2390             t2.deleteSubtree( t2.getNode( "B" ), false );
2391             if ( t2.getNumberOfExternalNodes() != 2 ) {
2392                 return false;
2393             }
2394             t2.toNewHampshireX();
2395             PhylogenyNode n = t2.getNode( "A" );
2396             if ( !n.getNextExternalNode().getName().equals( "C" ) ) {
2397                 return false;
2398             }
2399             t2.deleteSubtree( t2.getNode( "A" ), false );
2400             if ( t2.getNumberOfExternalNodes() != 2 ) {
2401                 return false;
2402             }
2403             t2.deleteSubtree( t2.getNode( "C" ), true );
2404             if ( t2.getNumberOfExternalNodes() != 1 ) {
2405                 return false;
2406             }
2407             final Phylogeny t3 = factory.create( "((A,B),(C,D))", new NHXParser() )[ 0 ];
2408             if ( t3.getNumberOfExternalNodes() != 4 ) {
2409                 return false;
2410             }
2411             t3.deleteSubtree( t3.getNode( "B" ), true );
2412             if ( t3.getNumberOfExternalNodes() != 3 ) {
2413                 return false;
2414             }
2415             n = t3.getNode( "A" );
2416             if ( !n.getNextExternalNode().getName().equals( "C" ) ) {
2417                 return false;
2418             }
2419             n = n.getNextExternalNode();
2420             if ( !n.getNextExternalNode().getName().equals( "D" ) ) {
2421                 return false;
2422             }
2423             t3.deleteSubtree( t3.getNode( "A" ), true );
2424             if ( t3.getNumberOfExternalNodes() != 2 ) {
2425                 return false;
2426             }
2427             n = t3.getNode( "C" );
2428             if ( !n.getNextExternalNode().getName().equals( "D" ) ) {
2429                 return false;
2430             }
2431             t3.deleteSubtree( t3.getNode( "C" ), true );
2432             if ( t3.getNumberOfExternalNodes() != 1 ) {
2433                 return false;
2434             }
2435             t3.deleteSubtree( t3.getNode( "D" ), true );
2436             if ( t3.getNumberOfExternalNodes() != 0 ) {
2437                 return false;
2438             }
2439             final Phylogeny t4 = factory.create( "((A,((B11,B12),B2)),(C,D))", new NHXParser() )[ 0 ];
2440             if ( t4.getNumberOfExternalNodes() != 6 ) {
2441                 return false;
2442             }
2443             t4.deleteSubtree( t4.getNode( "B2" ), true );
2444             if ( t4.getNumberOfExternalNodes() != 5 ) {
2445                 return false;
2446             }
2447             String s = w.toNewHampshire( t4, false, true ).toString();
2448             if ( !s.equals( "((A,(B11,B12)),(C,D));" ) ) {
2449                 return false;
2450             }
2451             t4.deleteSubtree( t4.getNode( "B11" ), true );
2452             if ( t4.getNumberOfExternalNodes() != 4 ) {
2453                 return false;
2454             }
2455             t4.deleteSubtree( t4.getNode( "C" ), true );
2456             if ( t4.getNumberOfExternalNodes() != 3 ) {
2457                 return false;
2458             }
2459             n = t4.getNode( "A" );
2460             n = n.getNextExternalNode();
2461             if ( !n.getName().equals( "B12" ) ) {
2462                 return false;
2463             }
2464             n = n.getNextExternalNode();
2465             if ( !n.getName().equals( "D" ) ) {
2466                 return false;
2467             }
2468             s = w.toNewHampshire( t4, false, true ).toString();
2469             if ( !s.equals( "((A,B12),D);" ) ) {
2470                 return false;
2471             }
2472             final Phylogeny t5 = factory.create( "((A,((B11,B12),B2)),(C,D))", new NHXParser() )[ 0 ];
2473             t5.deleteSubtree( t5.getNode( "A" ), true );
2474             if ( t5.getNumberOfExternalNodes() != 5 ) {
2475                 return false;
2476             }
2477             s = w.toNewHampshire( t5, false, true ).toString();
2478             if ( !s.equals( "(((B11,B12),B2),(C,D));" ) ) {
2479                 return false;
2480             }
2481             final Phylogeny t6 = factory.create( "((A,((B11,B12),B2)),(C,D))", new NHXParser() )[ 0 ];
2482             t6.deleteSubtree( t6.getNode( "B11" ), true );
2483             if ( t6.getNumberOfExternalNodes() != 5 ) {
2484                 return false;
2485             }
2486             s = w.toNewHampshire( t6, false, false ).toString();
2487             if ( !s.equals( "((A,(B12,B2)),(C,D));" ) ) {
2488                 return false;
2489             }
2490             final Phylogeny t7 = factory.create( "((A,((B11,B12),B2)),(C,D))", new NHXParser() )[ 0 ];
2491             t7.deleteSubtree( t7.getNode( "B12" ), true );
2492             if ( t7.getNumberOfExternalNodes() != 5 ) {
2493                 return false;
2494             }
2495             s = w.toNewHampshire( t7, false, true ).toString();
2496             if ( !s.equals( "((A,(B11,B2)),(C,D));" ) ) {
2497                 return false;
2498             }
2499             final Phylogeny t8 = factory.create( "((A,((B11,B12),B2)),(C,D))", new NHXParser() )[ 0 ];
2500             t8.deleteSubtree( t8.getNode( "B2" ), true );
2501             if ( t8.getNumberOfExternalNodes() != 5 ) {
2502                 return false;
2503             }
2504             s = w.toNewHampshire( t8, false, false ).toString();
2505             if ( !s.equals( "((A,(B11,B12)),(C,D));" ) ) {
2506                 return false;
2507             }
2508             final Phylogeny t9 = factory.create( "((A,((B11,B12),B2)),(C,D))", new NHXParser() )[ 0 ];
2509             t9.deleteSubtree( t9.getNode( "C" ), true );
2510             if ( t9.getNumberOfExternalNodes() != 5 ) {
2511                 return false;
2512             }
2513             s = w.toNewHampshire( t9, false, true ).toString();
2514             if ( !s.equals( "((A,((B11,B12),B2)),D);" ) ) {
2515                 return false;
2516             }
2517             final Phylogeny t10 = factory.create( "((A,((B11,B12),B2)),(C,D))", new NHXParser() )[ 0 ];
2518             t10.deleteSubtree( t10.getNode( "D" ), true );
2519             if ( t10.getNumberOfExternalNodes() != 5 ) {
2520                 return false;
2521             }
2522             s = w.toNewHampshire( t10, false, true ).toString();
2523             if ( !s.equals( "((A,((B11,B12),B2)),C);" ) ) {
2524                 return false;
2525             }
2526             final Phylogeny t11 = factory.create( "(A,B,C)", new NHXParser() )[ 0 ];
2527             t11.deleteSubtree( t11.getNode( "A" ), true );
2528             if ( t11.getNumberOfExternalNodes() != 2 ) {
2529                 return false;
2530             }
2531             s = w.toNewHampshire( t11, false, true ).toString();
2532             if ( !s.equals( "(B,C);" ) ) {
2533                 return false;
2534             }
2535             t11.deleteSubtree( t11.getNode( "C" ), true );
2536             if ( t11.getNumberOfExternalNodes() != 1 ) {
2537                 return false;
2538             }
2539             s = w.toNewHampshire( t11, false, false ).toString();
2540             if ( !s.equals( "B;" ) ) {
2541                 return false;
2542             }
2543             final Phylogeny t12 = factory.create( "((A1,A2,A3),(B1,B2,B3),(C1,C2,C3))", new NHXParser() )[ 0 ];
2544             t12.deleteSubtree( t12.getNode( "B2" ), true );
2545             if ( t12.getNumberOfExternalNodes() != 8 ) {
2546                 return false;
2547             }
2548             s = w.toNewHampshire( t12, false, true ).toString();
2549             if ( !s.equals( "((A1,A2,A3),(B1,B3),(C1,C2,C3));" ) ) {
2550                 return false;
2551             }
2552             t12.deleteSubtree( t12.getNode( "B3" ), true );
2553             if ( t12.getNumberOfExternalNodes() != 7 ) {
2554                 return false;
2555             }
2556             s = w.toNewHampshire( t12, false, true ).toString();
2557             if ( !s.equals( "((A1,A2,A3),B1,(C1,C2,C3));" ) ) {
2558                 return false;
2559             }
2560             t12.deleteSubtree( t12.getNode( "C3" ), true );
2561             if ( t12.getNumberOfExternalNodes() != 6 ) {
2562                 return false;
2563             }
2564             s = w.toNewHampshire( t12, false, true ).toString();
2565             if ( !s.equals( "((A1,A2,A3),B1,(C1,C2));" ) ) {
2566                 return false;
2567             }
2568             t12.deleteSubtree( t12.getNode( "A1" ), true );
2569             if ( t12.getNumberOfExternalNodes() != 5 ) {
2570                 return false;
2571             }
2572             s = w.toNewHampshire( t12, false, true ).toString();
2573             if ( !s.equals( "((A2,A3),B1,(C1,C2));" ) ) {
2574                 return false;
2575             }
2576             t12.deleteSubtree( t12.getNode( "B1" ), true );
2577             if ( t12.getNumberOfExternalNodes() != 4 ) {
2578                 return false;
2579             }
2580             s = w.toNewHampshire( t12, false, true ).toString();
2581             if ( !s.equals( "((A2,A3),(C1,C2));" ) ) {
2582                 return false;
2583             }
2584             t12.deleteSubtree( t12.getNode( "A3" ), true );
2585             if ( t12.getNumberOfExternalNodes() != 3 ) {
2586                 return false;
2587             }
2588             s = w.toNewHampshire( t12, false, true ).toString();
2589             if ( !s.equals( "(A2,(C1,C2));" ) ) {
2590                 return false;
2591             }
2592             t12.deleteSubtree( t12.getNode( "A2" ), true );
2593             if ( t12.getNumberOfExternalNodes() != 2 ) {
2594                 return false;
2595             }
2596             s = w.toNewHampshire( t12, false, true ).toString();
2597             if ( !s.equals( "(C1,C2);" ) ) {
2598                 return false;
2599             }
2600             final Phylogeny t13 = factory.create( "(A,B,C,(D:1.0,E:2.0):3.0)", new NHXParser() )[ 0 ];
2601             t13.deleteSubtree( t13.getNode( "D" ), true );
2602             if ( t13.getNumberOfExternalNodes() != 4 ) {
2603                 return false;
2604             }
2605             s = w.toNewHampshire( t13, false, true ).toString();
2606             if ( !s.equals( "(A,B,C,E:5.0);" ) ) {
2607                 return false;
2608             }
2609             final Phylogeny t14 = factory.create( "((A,B,C,(D:0.1,E:0.4):1.0),F)", new NHXParser() )[ 0 ];
2610             t14.deleteSubtree( t14.getNode( "E" ), true );
2611             if ( t14.getNumberOfExternalNodes() != 5 ) {
2612                 return false;
2613             }
2614             s = w.toNewHampshire( t14, false, true ).toString();
2615             if ( !s.equals( "((A,B,C,D:1.1),F);" ) ) {
2616                 return false;
2617             }
2618             final Phylogeny t15 = factory.create( "((A1,A2,A3,A4),(B1,B2,B3,B4),(C1,C2,C3,C4))", new NHXParser() )[ 0 ];
2619             t15.deleteSubtree( t15.getNode( "B2" ), true );
2620             if ( t15.getNumberOfExternalNodes() != 11 ) {
2621                 return false;
2622             }
2623             t15.deleteSubtree( t15.getNode( "B1" ), true );
2624             if ( t15.getNumberOfExternalNodes() != 10 ) {
2625                 return false;
2626             }
2627             t15.deleteSubtree( t15.getNode( "B3" ), true );
2628             if ( t15.getNumberOfExternalNodes() != 9 ) {
2629                 return false;
2630             }
2631             t15.deleteSubtree( t15.getNode( "B4" ), true );
2632             if ( t15.getNumberOfExternalNodes() != 8 ) {
2633                 return false;
2634             }
2635             t15.deleteSubtree( t15.getNode( "A1" ), true );
2636             if ( t15.getNumberOfExternalNodes() != 7 ) {
2637                 return false;
2638             }
2639             t15.deleteSubtree( t15.getNode( "C4" ), true );
2640             if ( t15.getNumberOfExternalNodes() != 6 ) {
2641                 return false;
2642             }
2643         }
2644         catch ( final Exception e ) {
2645             e.printStackTrace( System.out );
2646             return false;
2647         }
2648         return true;
2649     }
2650
2651     private static boolean testDescriptiveStatistics() {
2652         try {
2653             final DescriptiveStatistics dss1 = new BasicDescriptiveStatistics();
2654             dss1.addValue( 82 );
2655             dss1.addValue( 78 );
2656             dss1.addValue( 70 );
2657             dss1.addValue( 58 );
2658             dss1.addValue( 42 );
2659             if ( dss1.getN() != 5 ) {
2660                 return false;
2661             }
2662             if ( !Test.isEqual( dss1.getMin(), 42 ) ) {
2663                 return false;
2664             }
2665             if ( !Test.isEqual( dss1.getMax(), 82 ) ) {
2666                 return false;
2667             }
2668             if ( !Test.isEqual( dss1.arithmeticMean(), 66 ) ) {
2669                 return false;
2670             }
2671             if ( !Test.isEqual( dss1.sampleStandardDeviation(), 16.24807680927192 ) ) {
2672                 return false;
2673             }
2674             if ( !Test.isEqual( dss1.median(), 70 ) ) {
2675                 return false;
2676             }
2677             if ( !Test.isEqual( dss1.midrange(), 62 ) ) {
2678                 return false;
2679             }
2680             if ( !Test.isEqual( dss1.sampleVariance(), 264 ) ) {
2681                 return false;
2682             }
2683             if ( !Test.isEqual( dss1.pearsonianSkewness(), -0.7385489458759964 ) ) {
2684                 return false;
2685             }
2686             if ( !Test.isEqual( dss1.coefficientOfVariation(), 0.24618298195866547 ) ) {
2687                 return false;
2688             }
2689             if ( !Test.isEqual( dss1.sampleStandardUnit( 66 - 16.24807680927192 ), -1.0 ) ) {
2690                 return false;
2691             }
2692             if ( !Test.isEqual( dss1.getValue( 1 ), 78 ) ) {
2693                 return false;
2694             }
2695             dss1.addValue( 123 );
2696             if ( !Test.isEqual( dss1.arithmeticMean(), 75.5 ) ) {
2697                 return false;
2698             }
2699             if ( !Test.isEqual( dss1.getMax(), 123 ) ) {
2700                 return false;
2701             }
2702             if ( !Test.isEqual( dss1.standardErrorOfMean(), 11.200446419674531 ) ) {
2703                 return false;
2704             }
2705             final DescriptiveStatistics dss2 = new BasicDescriptiveStatistics();
2706             dss2.addValue( -1.85 );
2707             dss2.addValue( 57.5 );
2708             dss2.addValue( 92.78 );
2709             dss2.addValue( 57.78 );
2710             if ( !Test.isEqual( dss2.median(), 57.64 ) ) {
2711                 return false;
2712             }
2713             if ( !Test.isEqual( dss2.sampleStandardDeviation(), 39.266984753946495 ) ) {
2714                 return false;
2715             }
2716             final double[] a = dss2.getDataAsDoubleArray();
2717             if ( !Test.isEqual( a[ 3 ], 57.78 ) ) {
2718                 return false;
2719             }
2720             dss2.addValue( -100 );
2721             if ( !Test.isEqual( dss2.sampleStandardDeviation(), 75.829111296388 ) ) {
2722                 return false;
2723             }
2724             if ( !Test.isEqual( dss2.sampleVariance(), 5750.05412 ) ) {
2725                 return false;
2726             }
2727             final double[] ds = new double[ 14 ];
2728             ds[ 0 ] = 34;
2729             ds[ 1 ] = 23;
2730             ds[ 2 ] = 1;
2731             ds[ 3 ] = 32;
2732             ds[ 4 ] = 11;
2733             ds[ 5 ] = 2;
2734             ds[ 6 ] = 12;
2735             ds[ 7 ] = 33;
2736             ds[ 8 ] = 13;
2737             ds[ 9 ] = 22;
2738             ds[ 10 ] = 21;
2739             ds[ 11 ] = 35;
2740             ds[ 12 ] = 24;
2741             ds[ 13 ] = 31;
2742             final int[] bins = BasicDescriptiveStatistics.performBinning( ds, 0, 40, 4 );
2743             if ( bins.length != 4 ) {
2744                 return false;
2745             }
2746             if ( bins[ 0 ] != 2 ) {
2747                 return false;
2748             }
2749             if ( bins[ 1 ] != 3 ) {
2750                 return false;
2751             }
2752             if ( bins[ 2 ] != 4 ) {
2753                 return false;
2754             }
2755             if ( bins[ 3 ] != 5 ) {
2756                 return false;
2757             }
2758             final double[] ds1 = new double[ 9 ];
2759             ds1[ 0 ] = 10.0;
2760             ds1[ 1 ] = 19.0;
2761             ds1[ 2 ] = 9.999;
2762             ds1[ 3 ] = 0.0;
2763             ds1[ 4 ] = 39.9;
2764             ds1[ 5 ] = 39.999;
2765             ds1[ 6 ] = 30.0;
2766             ds1[ 7 ] = 19.999;
2767             ds1[ 8 ] = 30.1;
2768             final int[] bins1 = BasicDescriptiveStatistics.performBinning( ds1, 0, 40, 4 );
2769             if ( bins1.length != 4 ) {
2770                 return false;
2771             }
2772             if ( bins1[ 0 ] != 2 ) {
2773                 return false;
2774             }
2775             if ( bins1[ 1 ] != 3 ) {
2776                 return false;
2777             }
2778             if ( bins1[ 2 ] != 0 ) {
2779                 return false;
2780             }
2781             if ( bins1[ 3 ] != 4 ) {
2782                 return false;
2783             }
2784             final int[] bins1_1 = BasicDescriptiveStatistics.performBinning( ds1, 0, 40, 3 );
2785             if ( bins1_1.length != 3 ) {
2786                 return false;
2787             }
2788             if ( bins1_1[ 0 ] != 3 ) {
2789                 return false;
2790             }
2791             if ( bins1_1[ 1 ] != 2 ) {
2792                 return false;
2793             }
2794             if ( bins1_1[ 2 ] != 4 ) {
2795                 return false;
2796             }
2797             final int[] bins1_2 = BasicDescriptiveStatistics.performBinning( ds1, 1, 39, 3 );
2798             if ( bins1_2.length != 3 ) {
2799                 return false;
2800             }
2801             if ( bins1_2[ 0 ] != 2 ) {
2802                 return false;
2803             }
2804             if ( bins1_2[ 1 ] != 2 ) {
2805                 return false;
2806             }
2807             if ( bins1_2[ 2 ] != 2 ) {
2808                 return false;
2809             }
2810             final DescriptiveStatistics dss3 = new BasicDescriptiveStatistics();
2811             dss3.addValue( 1 );
2812             dss3.addValue( 1 );
2813             dss3.addValue( 1 );
2814             dss3.addValue( 2 );
2815             dss3.addValue( 3 );
2816             dss3.addValue( 4 );
2817             dss3.addValue( 5 );
2818             dss3.addValue( 5 );
2819             dss3.addValue( 5 );
2820             dss3.addValue( 6 );
2821             dss3.addValue( 7 );
2822             dss3.addValue( 8 );
2823             dss3.addValue( 9 );
2824             dss3.addValue( 10 );
2825             dss3.addValue( 10 );
2826             dss3.addValue( 10 );
2827             final AsciiHistogram histo = new AsciiHistogram( dss3 );
2828             histo.toStringBuffer( 10, '=', 40, 5 );
2829             histo.toStringBuffer( 3, 8, 10, '=', 40, 5 );
2830         }
2831         catch ( final Exception e ) {
2832             e.printStackTrace( System.out );
2833             return false;
2834         }
2835         return true;
2836     }
2837
2838     private static boolean testDir( final String file ) {
2839         try {
2840             final File f = new File( file );
2841             if ( !f.exists() ) {
2842                 return false;
2843             }
2844             if ( !f.isDirectory() ) {
2845                 return false;
2846             }
2847             if ( !f.canRead() ) {
2848                 return false;
2849             }
2850         }
2851         catch ( final Exception e ) {
2852             return false;
2853         }
2854         return true;
2855     }
2856
2857     private static boolean testExternalNodeRelatedMethods() {
2858         try {
2859             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
2860             final Phylogeny t1 = factory.create( "((A,B),(C,D))", new NHXParser() )[ 0 ];
2861             PhylogenyNode n = t1.getNode( "A" );
2862             n = n.getNextExternalNode();
2863             if ( !n.getName().equals( "B" ) ) {
2864                 return false;
2865             }
2866             n = n.getNextExternalNode();
2867             if ( !n.getName().equals( "C" ) ) {
2868                 return false;
2869             }
2870             n = n.getNextExternalNode();
2871             if ( !n.getName().equals( "D" ) ) {
2872                 return false;
2873             }
2874             n = t1.getNode( "B" );
2875             while ( !n.isLastExternalNode() ) {
2876                 n = n.getNextExternalNode();
2877             }
2878             final Phylogeny t2 = factory.create( "(((A,B),C),D)", new NHXParser() )[ 0 ];
2879             n = t2.getNode( "A" );
2880             n = n.getNextExternalNode();
2881             if ( !n.getName().equals( "B" ) ) {
2882                 return false;
2883             }
2884             n = n.getNextExternalNode();
2885             if ( !n.getName().equals( "C" ) ) {
2886                 return false;
2887             }
2888             n = n.getNextExternalNode();
2889             if ( !n.getName().equals( "D" ) ) {
2890                 return false;
2891             }
2892             n = t2.getNode( "B" );
2893             while ( !n.isLastExternalNode() ) {
2894                 n = n.getNextExternalNode();
2895             }
2896             final Phylogeny t3 = factory.create( "(((A,B),(C,D)),((E,F),(G,H)))", new NHXParser() )[ 0 ];
2897             n = t3.getNode( "A" );
2898             n = n.getNextExternalNode();
2899             if ( !n.getName().equals( "B" ) ) {
2900                 return false;
2901             }
2902             n = n.getNextExternalNode();
2903             if ( !n.getName().equals( "C" ) ) {
2904                 return false;
2905             }
2906             n = n.getNextExternalNode();
2907             if ( !n.getName().equals( "D" ) ) {
2908                 return false;
2909             }
2910             n = n.getNextExternalNode();
2911             if ( !n.getName().equals( "E" ) ) {
2912                 return false;
2913             }
2914             n = n.getNextExternalNode();
2915             if ( !n.getName().equals( "F" ) ) {
2916                 return false;
2917             }
2918             n = n.getNextExternalNode();
2919             if ( !n.getName().equals( "G" ) ) {
2920                 return false;
2921             }
2922             n = n.getNextExternalNode();
2923             if ( !n.getName().equals( "H" ) ) {
2924                 return false;
2925             }
2926             n = t3.getNode( "B" );
2927             while ( !n.isLastExternalNode() ) {
2928                 n = n.getNextExternalNode();
2929             }
2930             final Phylogeny t4 = factory.create( "((A,B),(C,D))", new NHXParser() )[ 0 ];
2931             for( final PhylogenyNodeIterator iter = t4.iteratorExternalForward(); iter.hasNext(); ) {
2932                 final PhylogenyNode node = iter.next();
2933             }
2934             final Phylogeny t5 = factory.create( "(((A,B),(C,D)),((E,F),(G,H)))", new NHXParser() )[ 0 ];
2935             for( final PhylogenyNodeIterator iter = t5.iteratorExternalForward(); iter.hasNext(); ) {
2936                 final PhylogenyNode node = iter.next();
2937             }
2938         }
2939         catch ( final Exception e ) {
2940             e.printStackTrace( System.out );
2941             return false;
2942         }
2943         return true;
2944     }
2945
2946     private static boolean testGeneralTable() {
2947         try {
2948             final GeneralTable<Integer, String> t0 = new GeneralTable<Integer, String>();
2949             t0.setValue( 3, 2, "23" );
2950             t0.setValue( 10, 1, "error" );
2951             t0.setValue( 10, 1, "110" );
2952             t0.setValue( 9, 1, "19" );
2953             t0.setValue( 1, 10, "101" );
2954             t0.setValue( 10, 10, "1010" );
2955             t0.setValue( 100, 10, "10100" );
2956             t0.setValue( 0, 0, "00" );
2957             if ( !t0.getValue( 3, 2 ).equals( "23" ) ) {
2958                 return false;
2959             }
2960             if ( !t0.getValue( 10, 1 ).equals( "110" ) ) {
2961                 return false;
2962             }
2963             if ( !t0.getValueAsString( 1, 10 ).equals( "101" ) ) {
2964                 return false;
2965             }
2966             if ( !t0.getValueAsString( 10, 10 ).equals( "1010" ) ) {
2967                 return false;
2968             }
2969             if ( !t0.getValueAsString( 100, 10 ).equals( "10100" ) ) {
2970                 return false;
2971             }
2972             if ( !t0.getValueAsString( 9, 1 ).equals( "19" ) ) {
2973                 return false;
2974             }
2975             if ( !t0.getValueAsString( 0, 0 ).equals( "00" ) ) {
2976                 return false;
2977             }
2978             if ( !t0.getValueAsString( 49, 4 ).equals( "" ) ) {
2979                 return false;
2980             }
2981             if ( !t0.getValueAsString( 22349, 3434344 ).equals( "" ) ) {
2982                 return false;
2983             }
2984             final GeneralTable<String, String> t1 = new GeneralTable<String, String>();
2985             t1.setValue( "3", "2", "23" );
2986             t1.setValue( "10", "1", "error" );
2987             t1.setValue( "10", "1", "110" );
2988             t1.setValue( "9", "1", "19" );
2989             t1.setValue( "1", "10", "101" );
2990             t1.setValue( "10", "10", "1010" );
2991             t1.setValue( "100", "10", "10100" );
2992             t1.setValue( "0", "0", "00" );
2993             t1.setValue( "qwerty", "zxcvbnm", "asdef" );
2994             if ( !t1.getValue( "3", "2" ).equals( "23" ) ) {
2995                 return false;
2996             }
2997             if ( !t1.getValue( "10", "1" ).equals( "110" ) ) {
2998                 return false;
2999             }
3000             if ( !t1.getValueAsString( "1", "10" ).equals( "101" ) ) {
3001                 return false;
3002             }
3003             if ( !t1.getValueAsString( "10", "10" ).equals( "1010" ) ) {
3004                 return false;
3005             }
3006             if ( !t1.getValueAsString( "100", "10" ).equals( "10100" ) ) {
3007                 return false;
3008             }
3009             if ( !t1.getValueAsString( "9", "1" ).equals( "19" ) ) {
3010                 return false;
3011             }
3012             if ( !t1.getValueAsString( "0", "0" ).equals( "00" ) ) {
3013                 return false;
3014             }
3015             if ( !t1.getValueAsString( "qwerty", "zxcvbnm" ).equals( "asdef" ) ) {
3016                 return false;
3017             }
3018             if ( !t1.getValueAsString( "49", "4" ).equals( "" ) ) {
3019                 return false;
3020             }
3021             if ( !t1.getValueAsString( "22349", "3434344" ).equals( "" ) ) {
3022                 return false;
3023             }
3024         }
3025         catch ( final Exception e ) {
3026             e.printStackTrace( System.out );
3027             return false;
3028         }
3029         return true;
3030     }
3031
3032     private static boolean testGetDistance() {
3033         try {
3034             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
3035             final Phylogeny p1 = factory.create( "(((A:1,B:2,X:100)ab:3,C:4)abc:5,(D:7,(E:9,F:10)ef:8)def:6)r",
3036                                                  new NHXParser() )[ 0 ];
3037             final PhylogenyMethods pm = PhylogenyMethods.getInstance();
3038             if ( pm.calculateDistance( p1.getNode( "C" ), p1.getNode( "C" ) ) != 0 ) {
3039                 return false;
3040             }
3041             if ( pm.calculateDistance( p1.getNode( "def" ), p1.getNode( "def" ) ) != 0 ) {
3042                 return false;
3043             }
3044             if ( pm.calculateDistance( p1.getNode( "ef" ), p1.getNode( "ef" ) ) != 0 ) {
3045                 return false;
3046             }
3047             if ( pm.calculateDistance( p1.getNode( "r" ), p1.getNode( "r" ) ) != 0 ) {
3048                 return false;
3049             }
3050             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "A" ) ) != 0 ) {
3051                 return false;
3052             }
3053             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "B" ) ) != 3 ) {
3054                 return false;
3055             }
3056             if ( pm.calculateDistance( p1.getNode( "B" ), p1.getNode( "A" ) ) != 3 ) {
3057                 return false;
3058             }
3059             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "C" ) ) != 8 ) {
3060                 return false;
3061             }
3062             if ( pm.calculateDistance( p1.getNode( "C" ), p1.getNode( "A" ) ) != 8 ) {
3063                 return false;
3064             }
3065             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "D" ) ) != 22 ) {
3066                 return false;
3067             }
3068             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "E" ) ) != 32 ) {
3069                 return false;
3070             }
3071             if ( pm.calculateDistance( p1.getNode( "E" ), p1.getNode( "A" ) ) != 32 ) {
3072                 return false;
3073             }
3074             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "F" ) ) != 33 ) {
3075                 return false;
3076             }
3077             if ( pm.calculateDistance( p1.getNode( "F" ), p1.getNode( "A" ) ) != 33 ) {
3078                 return false;
3079             }
3080             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "ab" ) ) != 1 ) {
3081                 return false;
3082             }
3083             if ( pm.calculateDistance( p1.getNode( "ab" ), p1.getNode( "A" ) ) != 1 ) {
3084                 return false;
3085             }
3086             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "abc" ) ) != 4 ) {
3087                 return false;
3088             }
3089             if ( pm.calculateDistance( p1.getNode( "abc" ), p1.getNode( "A" ) ) != 4 ) {
3090                 return false;
3091             }
3092             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "r" ) ) != 9 ) {
3093                 return false;
3094             }
3095             if ( pm.calculateDistance( p1.getNode( "r" ), p1.getNode( "A" ) ) != 9 ) {
3096                 return false;
3097             }
3098             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "def" ) ) != 15 ) {
3099                 return false;
3100             }
3101             if ( pm.calculateDistance( p1.getNode( "def" ), p1.getNode( "A" ) ) != 15 ) {
3102                 return false;
3103             }
3104             if ( pm.calculateDistance( p1.getNode( "A" ), p1.getNode( "ef" ) ) != 23 ) {
3105                 return false;
3106             }
3107             if ( pm.calculateDistance( p1.getNode( "ef" ), p1.getNode( "A" ) ) != 23 ) {
3108                 return false;
3109             }
3110             if ( pm.calculateDistance( p1.getNode( "ef" ), p1.getNode( "def" ) ) != 8 ) {
3111                 return false;
3112             }
3113             if ( pm.calculateDistance( p1.getNode( "def" ), p1.getNode( "ef" ) ) != 8 ) {
3114                 return false;
3115             }
3116             if ( pm.calculateDistance( p1.getNode( "ef" ), p1.getNode( "r" ) ) != 14 ) {
3117                 return false;
3118             }
3119             if ( pm.calculateDistance( p1.getNode( "ef" ), p1.getNode( "abc" ) ) != 19 ) {
3120                 return false;
3121             }
3122             if ( pm.calculateDistance( p1.getNode( "ef" ), p1.getNode( "ab" ) ) != 22 ) {
3123                 return false;
3124             }
3125             if ( pm.calculateDistance( p1.getNode( "ab" ), p1.getNode( "ef" ) ) != 22 ) {
3126                 return false;
3127             }
3128             if ( pm.calculateDistance( p1.getNode( "def" ), p1.getNode( "abc" ) ) != 11 ) {
3129                 return false;
3130             }
3131             final Phylogeny p2 = factory.create( "((A:4,B:5,C:6)abc:1,(D:7,E:8,F:9)def:2,(G:10,H:11,I:12)ghi:3)r",
3132                                                  new NHXParser() )[ 0 ];
3133             if ( pm.calculateDistance( p2.getNode( "A" ), p2.getNode( "B" ) ) != 9 ) {
3134                 return false;
3135             }
3136             if ( pm.calculateDistance( p2.getNode( "A" ), p2.getNode( "C" ) ) != 10 ) {
3137                 return false;
3138             }
3139             if ( pm.calculateDistance( p2.getNode( "A" ), p2.getNode( "D" ) ) != 14 ) {
3140                 return false;
3141             }
3142             if ( pm.calculateDistance( p2.getNode( "A" ), p2.getNode( "ghi" ) ) != 8 ) {
3143                 return false;
3144             }
3145             if ( pm.calculateDistance( p2.getNode( "A" ), p2.getNode( "I" ) ) != 20 ) {
3146                 return false;
3147             }
3148             if ( pm.calculateDistance( p2.getNode( "G" ), p2.getNode( "ghi" ) ) != 10 ) {
3149                 return false;
3150             }
3151             if ( pm.calculateDistance( p2.getNode( "r" ), p2.getNode( "r" ) ) != 0 ) {
3152                 return false;
3153             }
3154             if ( pm.calculateDistance( p2.getNode( "r" ), p2.getNode( "G" ) ) != 13 ) {
3155                 return false;
3156             }
3157             if ( pm.calculateDistance( p2.getNode( "G" ), p2.getNode( "r" ) ) != 13 ) {
3158                 return false;
3159             }
3160             if ( pm.calculateDistance( p2.getNode( "G" ), p2.getNode( "H" ) ) != 21 ) {
3161                 return false;
3162             }
3163             if ( pm.calculateDistance( p2.getNode( "G" ), p2.getNode( "I" ) ) != 22 ) {
3164                 return false;
3165             }
3166         }
3167         catch ( final Exception e ) {
3168             e.printStackTrace( System.out );
3169             return false;
3170         }
3171         return true;
3172     }
3173
3174     private static boolean testGetLCA() {
3175         try {
3176             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
3177             final Phylogeny p1 = factory.create( "((((((A,B)ab,C)abc,D)abcd,E)abcde,F)abcdef,(G,H)gh)abcdefgh",
3178                                                  new NHXParser() )[ 0 ];
3179             final PhylogenyMethods pm = PhylogenyMethods.getInstance();
3180             final PhylogenyNode A = pm.obtainLCA( p1.getNode( "A" ), p1.getNode( "A" ) );
3181             if ( !A.getName().equals( "A" ) ) {
3182                 return false;
3183             }
3184             final PhylogenyNode gh = pm.obtainLCA( p1.getNode( "gh" ), p1.getNode( "gh" ) );
3185             if ( !gh.getName().equals( "gh" ) ) {
3186                 return false;
3187             }
3188             final PhylogenyNode ab = pm.obtainLCA( p1.getNode( "A" ), p1.getNode( "B" ) );
3189             if ( !ab.getName().equals( "ab" ) ) {
3190                 return false;
3191             }
3192             final PhylogenyNode ab2 = pm.obtainLCA( p1.getNode( "B" ), p1.getNode( "A" ) );
3193             if ( !ab2.getName().equals( "ab" ) ) {
3194                 return false;
3195             }
3196             final PhylogenyNode gh2 = pm.obtainLCA( p1.getNode( "H" ), p1.getNode( "G" ) );
3197             if ( !gh2.getName().equals( "gh" ) ) {
3198                 return false;
3199             }
3200             final PhylogenyNode gh3 = pm.obtainLCA( p1.getNode( "G" ), p1.getNode( "H" ) );
3201             if ( !gh3.getName().equals( "gh" ) ) {
3202                 return false;
3203             }
3204             final PhylogenyNode abc = pm.obtainLCA( p1.getNode( "C" ), p1.getNode( "A" ) );
3205             if ( !abc.getName().equals( "abc" ) ) {
3206                 return false;
3207             }
3208             final PhylogenyNode abc2 = pm.obtainLCA( p1.getNode( "A" ), p1.getNode( "C" ) );
3209             if ( !abc2.getName().equals( "abc" ) ) {
3210                 return false;
3211             }
3212             final PhylogenyNode abcd = pm.obtainLCA( p1.getNode( "A" ), p1.getNode( "D" ) );
3213             if ( !abcd.getName().equals( "abcd" ) ) {
3214                 return false;
3215             }
3216             final PhylogenyNode abcd2 = pm.obtainLCA( p1.getNode( "D" ), p1.getNode( "A" ) );
3217             if ( !abcd2.getName().equals( "abcd" ) ) {
3218                 return false;
3219             }
3220             final PhylogenyNode abcdef = pm.obtainLCA( p1.getNode( "A" ), p1.getNode( "F" ) );
3221             if ( !abcdef.getName().equals( "abcdef" ) ) {
3222                 return false;
3223             }
3224             final PhylogenyNode abcdef2 = pm.obtainLCA( p1.getNode( "F" ), p1.getNode( "A" ) );
3225             if ( !abcdef2.getName().equals( "abcdef" ) ) {
3226                 return false;
3227             }
3228             final PhylogenyNode abcdef3 = pm.obtainLCA( p1.getNode( "ab" ), p1.getNode( "F" ) );
3229             if ( !abcdef3.getName().equals( "abcdef" ) ) {
3230                 return false;
3231             }
3232             final PhylogenyNode abcdef4 = pm.obtainLCA( p1.getNode( "F" ), p1.getNode( "ab" ) );
3233             if ( !abcdef4.getName().equals( "abcdef" ) ) {
3234                 return false;
3235             }
3236             final PhylogenyNode abcde = pm.obtainLCA( p1.getNode( "A" ), p1.getNode( "E" ) );
3237             if ( !abcde.getName().equals( "abcde" ) ) {
3238                 return false;
3239             }
3240             final PhylogenyNode abcde2 = pm.obtainLCA( p1.getNode( "E" ), p1.getNode( "A" ) );
3241             if ( !abcde2.getName().equals( "abcde" ) ) {
3242                 return false;
3243             }
3244             final PhylogenyNode r = pm.obtainLCA( p1.getNode( "abcdefgh" ), p1.getNode( "abcdefgh" ) );
3245             if ( !r.getName().equals( "abcdefgh" ) ) {
3246                 return false;
3247             }
3248             final PhylogenyNode r2 = pm.obtainLCA( p1.getNode( "A" ), p1.getNode( "H" ) );
3249             if ( !r2.getName().equals( "abcdefgh" ) ) {
3250                 return false;
3251             }
3252             final PhylogenyNode r3 = pm.obtainLCA( p1.getNode( "H" ), p1.getNode( "A" ) );
3253             if ( !r3.getName().equals( "abcdefgh" ) ) {
3254                 return false;
3255             }
3256             final PhylogenyNode abcde3 = pm.obtainLCA( p1.getNode( "E" ), p1.getNode( "abcde" ) );
3257             if ( !abcde3.getName().equals( "abcde" ) ) {
3258                 return false;
3259             }
3260             final PhylogenyNode abcde4 = pm.obtainLCA( p1.getNode( "abcde" ), p1.getNode( "E" ) );
3261             if ( !abcde4.getName().equals( "abcde" ) ) {
3262                 return false;
3263             }
3264             final PhylogenyNode ab3 = pm.obtainLCA( p1.getNode( "ab" ), p1.getNode( "B" ) );
3265             if ( !ab3.getName().equals( "ab" ) ) {
3266                 return false;
3267             }
3268             final PhylogenyNode ab4 = pm.obtainLCA( p1.getNode( "B" ), p1.getNode( "ab" ) );
3269             if ( !ab4.getName().equals( "ab" ) ) {
3270                 return false;
3271             }
3272             final Phylogeny p2 = factory.create( "(a,b,(((c,d)cd,e)cde,f)cdef)r", new NHXParser() )[ 0 ];
3273             final PhylogenyNode cd = pm.obtainLCA( p2.getNode( "c" ), p2.getNode( "d" ) );
3274             if ( !cd.getName().equals( "cd" ) ) {
3275                 return false;
3276             }
3277             final PhylogenyNode cd2 = pm.obtainLCA( p2.getNode( "d" ), p2.getNode( "c" ) );
3278             if ( !cd2.getName().equals( "cd" ) ) {
3279                 return false;
3280             }
3281             final PhylogenyNode cde = pm.obtainLCA( p2.getNode( "c" ), p2.getNode( "e" ) );
3282             if ( !cde.getName().equals( "cde" ) ) {
3283                 return false;
3284             }
3285             final PhylogenyNode cde2 = pm.obtainLCA( p2.getNode( "e" ), p2.getNode( "c" ) );
3286             if ( !cde2.getName().equals( "cde" ) ) {
3287                 return false;
3288             }
3289             final PhylogenyNode cdef = pm.obtainLCA( p2.getNode( "c" ), p2.getNode( "f" ) );
3290             if ( !cdef.getName().equals( "cdef" ) ) {
3291                 return false;
3292             }
3293             final PhylogenyNode cdef2 = pm.obtainLCA( p2.getNode( "d" ), p2.getNode( "f" ) );
3294             if ( !cdef2.getName().equals( "cdef" ) ) {
3295                 return false;
3296             }
3297             final PhylogenyNode cdef3 = pm.obtainLCA( p2.getNode( "f" ), p2.getNode( "d" ) );
3298             if ( !cdef3.getName().equals( "cdef" ) ) {
3299                 return false;
3300             }
3301             final PhylogenyNode rt = pm.obtainLCA( p2.getNode( "c" ), p2.getNode( "a" ) );
3302             if ( !rt.getName().equals( "r" ) ) {
3303                 return false;
3304             }
3305             final Phylogeny p3 = factory
3306                     .create( "((((a,(b,c)bc)abc,(d,e)de)abcde,f)abcdef,(((g,h)gh,(i,j)ij)ghij,k)ghijk,l)",
3307                              new NHXParser() )[ 0 ];
3308             final PhylogenyNode bc_3 = pm.obtainLCA( p3.getNode( "b" ), p3.getNode( "c" ) );
3309             if ( !bc_3.getName().equals( "bc" ) ) {
3310                 return false;
3311             }
3312             final PhylogenyNode ac_3 = pm.obtainLCA( p3.getNode( "a" ), p3.getNode( "c" ) );
3313             if ( !ac_3.getName().equals( "abc" ) ) {
3314                 return false;
3315             }
3316             final PhylogenyNode ad_3 = pm.obtainLCA( p3.getNode( "a" ), p3.getNode( "d" ) );
3317             if ( !ad_3.getName().equals( "abcde" ) ) {
3318                 return false;
3319             }
3320             final PhylogenyNode af_3 = pm.obtainLCA( p3.getNode( "a" ), p3.getNode( "f" ) );
3321             if ( !af_3.getName().equals( "abcdef" ) ) {
3322                 return false;
3323             }
3324             final PhylogenyNode ag_3 = pm.obtainLCA( p3.getNode( "a" ), p3.getNode( "g" ) );
3325             if ( !ag_3.getName().equals( "" ) ) {
3326                 return false;
3327             }
3328             if ( !ag_3.isRoot() ) {
3329                 return false;
3330             }
3331             final PhylogenyNode al_3 = pm.obtainLCA( p3.getNode( "a" ), p3.getNode( "l" ) );
3332             if ( !al_3.getName().equals( "" ) ) {
3333                 return false;
3334             }
3335             if ( !al_3.isRoot() ) {
3336                 return false;
3337             }
3338             final PhylogenyNode kl_3 = pm.obtainLCA( p3.getNode( "k" ), p3.getNode( "l" ) );
3339             if ( !kl_3.getName().equals( "" ) ) {
3340                 return false;
3341             }
3342             if ( !kl_3.isRoot() ) {
3343                 return false;
3344             }
3345             final PhylogenyNode fl_3 = pm.obtainLCA( p3.getNode( "f" ), p3.getNode( "l" ) );
3346             if ( !fl_3.getName().equals( "" ) ) {
3347                 return false;
3348             }
3349             if ( !fl_3.isRoot() ) {
3350                 return false;
3351             }
3352             final PhylogenyNode gk_3 = pm.obtainLCA( p3.getNode( "g" ), p3.getNode( "k" ) );
3353             if ( !gk_3.getName().equals( "ghijk" ) ) {
3354                 return false;
3355             }
3356             final Phylogeny p4 = factory.create( "(a,b,c)r", new NHXParser() )[ 0 ];
3357             final PhylogenyNode r_4 = pm.obtainLCA( p4.getNode( "b" ), p4.getNode( "c" ) );
3358             if ( !r_4.getName().equals( "r" ) ) {
3359                 return false;
3360             }
3361             final Phylogeny p5 = factory.create( "((a,b),c,d)root", new NHXParser() )[ 0 ];
3362             final PhylogenyNode r_5 = pm.obtainLCA( p5.getNode( "a" ), p5.getNode( "c" ) );
3363             if ( !r_5.getName().equals( "root" ) ) {
3364                 return false;
3365             }
3366             final Phylogeny p6 = factory.create( "((a,b),c,d)rot", new NHXParser() )[ 0 ];
3367             final PhylogenyNode r_6 = pm.obtainLCA( p6.getNode( "c" ), p6.getNode( "a" ) );
3368             if ( !r_6.getName().equals( "rot" ) ) {
3369                 return false;
3370             }
3371             final Phylogeny p7 = factory.create( "(((a,b)x,c)x,d,e)rott", new NHXParser() )[ 0 ];
3372             final PhylogenyNode r_7 = pm.obtainLCA( p7.getNode( "a" ), p7.getNode( "e" ) );
3373             if ( !r_7.getName().equals( "rott" ) ) {
3374                 return false;
3375             }
3376         }
3377         catch ( final Exception e ) {
3378             e.printStackTrace( System.out );
3379             return false;
3380         }
3381         return true;
3382     }
3383
3384     private static boolean testHmmscanOutputParser() {
3385         final String test_dir = Test.PATH_TO_TEST_DATA;
3386         try {
3387             final HmmscanPerDomainTableParser parser1 = new HmmscanPerDomainTableParser( new File( test_dir
3388                     + ForesterUtil.getFileSeparator() + "hmmscan30b3_output_1" ), "MONBR", INDIVIDUAL_SCORE_CUTOFF.NONE );
3389             parser1.parse();
3390             final HmmscanPerDomainTableParser parser2 = new HmmscanPerDomainTableParser( new File( test_dir
3391                     + ForesterUtil.getFileSeparator() + "hmmscan30b3_output_2" ), "MONBR", INDIVIDUAL_SCORE_CUTOFF.NONE );
3392             final List<Protein> domain_collections = parser2.parse();
3393             if ( parser2.getProteinsEncountered() != 4 ) {
3394                 return false;
3395             }
3396             if ( domain_collections.size() != 4 ) {
3397                 return false;
3398             }
3399             if ( parser2.getDomainsEncountered() != 69 ) {
3400                 return false;
3401             }
3402             if ( parser2.getDomainsIgnoredDueToDuf() != 0 ) {
3403                 return false;
3404             }
3405             if ( parser2.getDomainsIgnoredDueToEval() != 0 ) {
3406                 return false;
3407             }
3408             final Protein p1 = domain_collections.get( 0 );
3409             if ( p1.getNumberOfProteinDomains() != 15 ) {
3410                 return false;
3411             }
3412             final Protein p4 = domain_collections.get( 3 );
3413             if ( p4.getNumberOfProteinDomains() != 1 ) {
3414                 return false;
3415             }
3416             if ( !p4.getProteinDomain( 0 ).getDomainId().toString().equals( "DNA_pol_B_new" ) ) {
3417                 return false;
3418             }
3419             if ( p4.getProteinDomain( 0 ).getFrom() != 51 ) {
3420                 return false;
3421             }
3422             if ( p4.getProteinDomain( 0 ).getTo() != 395 ) {
3423                 return false;
3424             }
3425             if ( !Test.isEqual( p4.getProteinDomain( 0 ).getPerDomainEvalue(), 1.2e-39 ) ) {
3426                 return false;
3427             }
3428             if ( !Test.isEqual( p4.getProteinDomain( 0 ).getPerDomainScore(), 135.7 ) ) {
3429                 return false;
3430             }
3431             if ( !Test.isEqual( p4.getProteinDomain( 0 ).getPerSequenceEvalue(), 8.3e-40 ) ) {
3432                 return false;
3433             }
3434             if ( !Test.isEqual( p4.getProteinDomain( 0 ).getPerSequenceScore(), 136.3 ) ) {
3435                 return false;
3436             }
3437             if ( !Test.isEqual( p4.getProteinDomain( 0 ).getNumber(), 1 ) ) {
3438                 return false;
3439             }
3440             if ( !Test.isEqual( p4.getProteinDomain( 0 ).getTotalCount(), 1 ) ) {
3441                 return false;
3442             }
3443         }
3444         catch ( final Exception e ) {
3445             e.printStackTrace( System.out );
3446             return false;
3447         }
3448         return true;
3449     }
3450
3451     private static boolean testLastExternalNodeMethods() {
3452         try {
3453             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
3454             final char[] a0 = { '(', '(', 'A', ',', 'B', ')', ',', '(', 'C', ',', 'D', ')', ')', };
3455             final Phylogeny t0 = factory.create( a0, new NHXParser() )[ 0 ];
3456             final PhylogenyNode n1 = t0.getNode( "A" );
3457             if ( n1.isLastExternalNode() ) {
3458                 return false;
3459             }
3460             final PhylogenyNode n2 = t0.getNode( "B" );
3461             if ( n2.isLastExternalNode() ) {
3462                 return false;
3463             }
3464             final PhylogenyNode n3 = t0.getNode( "C" );
3465             if ( n3.isLastExternalNode() ) {
3466                 return false;
3467             }
3468             final PhylogenyNode n4 = t0.getNode( "D" );
3469             if ( !n4.isLastExternalNode() ) {
3470                 return false;
3471             }
3472         }
3473         catch ( final Exception e ) {
3474             e.printStackTrace( System.out );
3475             return false;
3476         }
3477         return true;
3478     }
3479
3480     private static boolean testLevelOrderIterator() {
3481         try {
3482             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
3483             final Phylogeny t0 = factory.create( "((A,B)ab,(C,D)cd)r", new NHXParser() )[ 0 ];
3484             PhylogenyNodeIterator it0;
3485             for( it0 = t0.iteratorLevelOrder(); it0.hasNext(); ) {
3486                 it0.next();
3487             }
3488             for( it0.reset(); it0.hasNext(); ) {
3489                 it0.next();
3490             }
3491             final PhylogenyNodeIterator it = t0.iteratorLevelOrder();
3492             if ( !it.next().getName().equals( "r" ) ) {
3493                 return false;
3494             }
3495             if ( !it.next().getName().equals( "ab" ) ) {
3496                 return false;
3497             }
3498             if ( !it.next().getName().equals( "cd" ) ) {
3499                 return false;
3500             }
3501             if ( !it.next().getName().equals( "A" ) ) {
3502                 return false;
3503             }
3504             if ( !it.next().getName().equals( "B" ) ) {
3505                 return false;
3506             }
3507             if ( !it.next().getName().equals( "C" ) ) {
3508                 return false;
3509             }
3510             if ( !it.next().getName().equals( "D" ) ) {
3511                 return false;
3512             }
3513             if ( it.hasNext() ) {
3514                 return false;
3515             }
3516             final Phylogeny t2 = factory.create( "(((1,2,(a,(X,Y,Z)b)3,4,5,6)A,B,C)abc,(D,E,(f1,(f21)f2,f3)F,G)defg)r",
3517                                                  new NHXParser() )[ 0 ];
3518             PhylogenyNodeIterator it2;
3519             for( it2 = t2.iteratorLevelOrder(); it2.hasNext(); ) {
3520                 it2.next();
3521             }
3522             for( it2.reset(); it2.hasNext(); ) {
3523                 it2.next();
3524             }
3525             final PhylogenyNodeIterator it3 = t2.iteratorLevelOrder();
3526             if ( !it3.next().getName().equals( "r" ) ) {
3527                 return false;
3528             }
3529             if ( !it3.next().getName().equals( "abc" ) ) {
3530                 return false;
3531             }
3532             if ( !it3.next().getName().equals( "defg" ) ) {
3533                 return false;
3534             }
3535             if ( !it3.next().getName().equals( "A" ) ) {
3536                 return false;
3537             }
3538             if ( !it3.next().getName().equals( "B" ) ) {
3539                 return false;
3540             }
3541             if ( !it3.next().getName().equals( "C" ) ) {
3542                 return false;
3543             }
3544             if ( !it3.next().getName().equals( "D" ) ) {
3545                 return false;
3546             }
3547             if ( !it3.next().getName().equals( "E" ) ) {
3548                 return false;
3549             }
3550             if ( !it3.next().getName().equals( "F" ) ) {
3551                 return false;
3552             }
3553             if ( !it3.next().getName().equals( "G" ) ) {
3554                 return false;
3555             }
3556             if ( !it3.next().getName().equals( "1" ) ) {
3557                 return false;
3558             }
3559             if ( !it3.next().getName().equals( "2" ) ) {
3560                 return false;
3561             }
3562             if ( !it3.next().getName().equals( "3" ) ) {
3563                 return false;
3564             }
3565             if ( !it3.next().getName().equals( "4" ) ) {
3566                 return false;
3567             }
3568             if ( !it3.next().getName().equals( "5" ) ) {
3569                 return false;
3570             }
3571             if ( !it3.next().getName().equals( "6" ) ) {
3572                 return false;
3573             }
3574             if ( !it3.next().getName().equals( "f1" ) ) {
3575                 return false;
3576             }
3577             if ( !it3.next().getName().equals( "f2" ) ) {
3578                 return false;
3579             }
3580             if ( !it3.next().getName().equals( "f3" ) ) {
3581                 return false;
3582             }
3583             if ( !it3.next().getName().equals( "a" ) ) {
3584                 return false;
3585             }
3586             if ( !it3.next().getName().equals( "b" ) ) {
3587                 return false;
3588             }
3589             if ( !it3.next().getName().equals( "f21" ) ) {
3590                 return false;
3591             }
3592             if ( !it3.next().getName().equals( "X" ) ) {
3593                 return false;
3594             }
3595             if ( !it3.next().getName().equals( "Y" ) ) {
3596                 return false;
3597             }
3598             if ( !it3.next().getName().equals( "Z" ) ) {
3599                 return false;
3600             }
3601             if ( it3.hasNext() ) {
3602                 return false;
3603             }
3604             final Phylogeny t4 = factory.create( "((((D)C)B)A)r", new NHXParser() )[ 0 ];
3605             PhylogenyNodeIterator it4;
3606             for( it4 = t4.iteratorLevelOrder(); it4.hasNext(); ) {
3607                 it4.next();
3608             }
3609             for( it4.reset(); it4.hasNext(); ) {
3610                 it4.next();
3611             }
3612             final PhylogenyNodeIterator it5 = t4.iteratorLevelOrder();
3613             if ( !it5.next().getName().equals( "r" ) ) {
3614                 return false;
3615             }
3616             if ( !it5.next().getName().equals( "A" ) ) {
3617                 return false;
3618             }
3619             if ( !it5.next().getName().equals( "B" ) ) {
3620                 return false;
3621             }
3622             if ( !it5.next().getName().equals( "C" ) ) {
3623                 return false;
3624             }
3625             if ( !it5.next().getName().equals( "D" ) ) {
3626                 return false;
3627             }
3628             final Phylogeny t5 = factory.create( "A", new NHXParser() )[ 0 ];
3629             PhylogenyNodeIterator it6;
3630             for( it6 = t5.iteratorLevelOrder(); it6.hasNext(); ) {
3631                 it6.next();
3632             }
3633             for( it6.reset(); it6.hasNext(); ) {
3634                 it6.next();
3635             }
3636             final PhylogenyNodeIterator it7 = t5.iteratorLevelOrder();
3637             if ( !it7.next().getName().equals( "A" ) ) {
3638                 return false;
3639             }
3640             if ( it.hasNext() ) {
3641                 return false;
3642             }
3643         }
3644         catch ( final Exception e ) {
3645             e.printStackTrace( System.out );
3646             return false;
3647         }
3648         return true;
3649     }
3650
3651     private static boolean testMidpointrooting() {
3652         try {
3653             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
3654             final Phylogeny t1 = factory.create( "((A:1,B:2)AB:1[&&NHX:B=55],(C:3,D:4)CD:3[&&NHX:B=10])ABCD:0.5",
3655                                                  new NHXParser() )[ 0 ];
3656             if ( !t1.isRooted() ) {
3657                 return false;
3658             }
3659             PhylogenyMethods.midpointRoot( t1 );
3660             if ( !isEqual( t1.getNode( "A" ).getDistanceToParent(), 1 ) ) {
3661                 return false;
3662             }
3663             if ( !isEqual( t1.getNode( "B" ).getDistanceToParent(), 2 ) ) {
3664                 return false;
3665             }
3666             if ( !isEqual( t1.getNode( "C" ).getDistanceToParent(), 3 ) ) {
3667                 return false;
3668             }
3669             if ( !isEqual( t1.getNode( "D" ).getDistanceToParent(), 4 ) ) {
3670                 return false;
3671             }
3672             if ( !isEqual( t1.getNode( "CD" ).getDistanceToParent(), 1 ) ) {
3673                 return false;
3674             }
3675             if ( !isEqual( t1.getNode( "AB" ).getDistanceToParent(), 3 ) ) {
3676                 return false;
3677             }
3678             t1.reRoot( t1.getNode( "A" ) );
3679             PhylogenyMethods.midpointRoot( t1 );
3680             if ( !isEqual( t1.getNode( "A" ).getDistanceToParent(), 1 ) ) {
3681                 return false;
3682             }
3683             if ( !isEqual( t1.getNode( "B" ).getDistanceToParent(), 2 ) ) {
3684                 return false;
3685             }
3686             if ( !isEqual( t1.getNode( "C" ).getDistanceToParent(), 3 ) ) {
3687                 return false;
3688             }
3689             if ( !isEqual( t1.getNode( "D" ).getDistanceToParent(), 4 ) ) {
3690                 return false;
3691             }
3692             if ( !isEqual( t1.getNode( "CD" ).getDistanceToParent(), 1 ) ) {
3693                 return false;
3694             }
3695             if ( !isEqual( t1.getNode( "AB" ).getDistanceToParent(), 3 ) ) {
3696                 return false;
3697             }
3698         }
3699         catch ( final Exception e ) {
3700             e.printStackTrace( System.out );
3701             return false;
3702         }
3703         return true;
3704     }
3705
3706     private static boolean testNexusCharactersParsing() {
3707         try {
3708             final NexusCharactersParser parser = new NexusCharactersParser();
3709             parser.setSource( new File( Test.PATH_TO_TEST_DATA + "nexus_test_7.nex" ) );
3710             parser.parse();
3711             String[] labels = parser.getCharStateLabels();
3712             if ( labels.length != 7 ) {
3713                 return false;
3714             }
3715             if ( !labels[ 0 ].equals( "14-3-3" ) ) {
3716                 return false;
3717             }
3718             if ( !labels[ 1 ].equals( "2-Hacid_dh" ) ) {
3719                 return false;
3720             }
3721             if ( !labels[ 2 ].equals( "2-Hacid_dh_C" ) ) {
3722                 return false;
3723             }
3724             if ( !labels[ 3 ].equals( "2-oxoacid_dh" ) ) {
3725                 return false;
3726             }
3727             if ( !labels[ 4 ].equals( "2OG-FeII_Oxy" ) ) {
3728                 return false;
3729             }
3730             if ( !labels[ 5 ].equals( "3-HAO" ) ) {
3731                 return false;
3732             }
3733             if ( !labels[ 6 ].equals( "3_5_exonuc" ) ) {
3734                 return false;
3735             }
3736             parser.setSource( new File( Test.PATH_TO_TEST_DATA + "nexus_test_8.nex" ) );
3737             parser.parse();
3738             labels = parser.getCharStateLabels();
3739             if ( labels.length != 7 ) {
3740                 return false;
3741             }
3742             if ( !labels[ 0 ].equals( "14-3-3" ) ) {
3743                 return false;
3744             }
3745             if ( !labels[ 1 ].equals( "2-Hacid_dh" ) ) {
3746                 return false;
3747             }
3748             if ( !labels[ 2 ].equals( "2-Hacid_dh_C" ) ) {
3749                 return false;
3750             }
3751             if ( !labels[ 3 ].equals( "2-oxoacid_dh" ) ) {
3752                 return false;
3753             }
3754             if ( !labels[ 4 ].equals( "2OG-FeII_Oxy" ) ) {
3755                 return false;
3756             }
3757             if ( !labels[ 5 ].equals( "3-HAO" ) ) {
3758                 return false;
3759             }
3760             if ( !labels[ 6 ].equals( "3_5_exonuc" ) ) {
3761                 return false;
3762             }
3763         }
3764         catch ( final Exception e ) {
3765             e.printStackTrace( System.out );
3766             return false;
3767         }
3768         return true;
3769     }
3770
3771     private static boolean testNexusMatrixParsing() {
3772         try {
3773             final NexusBinaryStatesMatrixParser parser = new NexusBinaryStatesMatrixParser();
3774             parser.setSource( new File( Test.PATH_TO_TEST_DATA + "nexus_test_9.nex" ) );
3775             parser.parse();
3776             final CharacterStateMatrix<BinaryStates> m = parser.getMatrix();
3777             if ( m.getNumberOfCharacters() != 9 ) {
3778                 return false;
3779             }
3780             if ( m.getNumberOfIdentifiers() != 5 ) {
3781                 return false;
3782             }
3783             if ( m.getState( 0, 0 ) != BinaryStates.PRESENT ) {
3784                 return false;
3785             }
3786             if ( m.getState( 0, 1 ) != BinaryStates.ABSENT ) {
3787                 return false;
3788             }
3789             if ( m.getState( 1, 0 ) != BinaryStates.PRESENT ) {
3790                 return false;
3791             }
3792             if ( m.getState( 2, 0 ) != BinaryStates.ABSENT ) {
3793                 return false;
3794             }
3795             if ( m.getState( 4, 8 ) != BinaryStates.PRESENT ) {
3796                 return false;
3797             }
3798             if ( !m.getIdentifier( 0 ).equals( "MOUSE" ) ) {
3799                 return false;
3800             }
3801             if ( !m.getIdentifier( 4 ).equals( "ARATH" ) ) {
3802                 return false;
3803             }
3804             //            if ( labels.length != 7 ) {
3805             //                return false;
3806             //            }
3807             //            if ( !labels[ 0 ].equals( "14-3-3" ) ) {
3808             //                return false;
3809             //            }
3810             //            if ( !labels[ 1 ].equals( "2-Hacid_dh" ) ) {
3811             //                return false;
3812             //            }
3813             //            if ( !labels[ 2 ].equals( "2-Hacid_dh_C" ) ) {
3814             //                return false;
3815             //            }
3816             //            if ( !labels[ 3 ].equals( "2-oxoacid_dh" ) ) {
3817             //                return false;
3818             //            }
3819             //            if ( !labels[ 4 ].equals( "2OG-FeII_Oxy" ) ) {
3820             //                return false;
3821             //            }
3822             //            if ( !labels[ 5 ].equals( "3-HAO" ) ) {
3823             //                return false;
3824             //            }
3825             //            if ( !labels[ 6 ].equals( "3_5_exonuc" ) ) {
3826             //                return false;
3827             //            }
3828             //            parser.setSource( new File( Test.PATH_TO_TEST_DATA + "nexus_test_8.nex" ) );
3829             //            parser.parse();
3830             //            labels = parser.getCharStateLabels();
3831             //            if ( labels.length != 7 ) {
3832             //                return false;
3833             //            }
3834             //            if ( !labels[ 0 ].equals( "14-3-3" ) ) {
3835             //                return false;
3836             //            }
3837             //            if ( !labels[ 1 ].equals( "2-Hacid_dh" ) ) {
3838             //                return false;
3839             //            }
3840             //            if ( !labels[ 2 ].equals( "2-Hacid_dh_C" ) ) {
3841             //                return false;
3842             //            }
3843             //            if ( !labels[ 3 ].equals( "2-oxoacid_dh" ) ) {
3844             //                return false;
3845             //            }
3846             //            if ( !labels[ 4 ].equals( "2OG-FeII_Oxy" ) ) {
3847             //                return false;
3848             //            }
3849             //            if ( !labels[ 5 ].equals( "3-HAO" ) ) {
3850             //                return false;
3851             //            }
3852             //            if ( !labels[ 6 ].equals( "3_5_exonuc" ) ) {
3853             //                return false;
3854             //            }
3855         }
3856         catch ( final Exception e ) {
3857             e.printStackTrace( System.out );
3858             return false;
3859         }
3860         return true;
3861     }
3862
3863     private static boolean testNexusTreeParsing() {
3864         try {
3865             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
3866             final NexusPhylogeniesParser parser = new NexusPhylogeniesParser();
3867             Phylogeny[] phylogenies = factory.create( Test.PATH_TO_TEST_DATA + "nexus_test_1.nex", parser );
3868             if ( phylogenies.length != 1 ) {
3869                 return false;
3870             }
3871             if ( phylogenies[ 0 ].getNumberOfExternalNodes() != 25 ) {
3872                 return false;
3873             }
3874             if ( !phylogenies[ 0 ].getName().equals( "" ) ) {
3875                 return false;
3876             }
3877             phylogenies = null;
3878             phylogenies = factory.create( Test.PATH_TO_TEST_DATA + "nexus_test_2.nex", parser );
3879             if ( phylogenies.length != 1 ) {
3880                 return false;
3881             }
3882             if ( phylogenies[ 0 ].getNumberOfExternalNodes() != 10 ) {
3883                 return false;
3884             }
3885             if ( !phylogenies[ 0 ].getName().equals( "name" ) ) {
3886                 return false;
3887             }
3888             phylogenies = null;
3889             phylogenies = factory.create( Test.PATH_TO_TEST_DATA + "nexus_test_3.nex", parser );
3890             if ( phylogenies.length != 1 ) {
3891                 return false;
3892             }
3893             if ( phylogenies[ 0 ].getNumberOfExternalNodes() != 3 ) {
3894                 return false;
3895             }
3896             if ( !phylogenies[ 0 ].getName().equals( "" ) ) {
3897                 return false;
3898             }
3899             if ( phylogenies[ 0 ].isRooted() ) {
3900                 return false;
3901             }
3902             phylogenies = null;
3903             phylogenies = factory.create( Test.PATH_TO_TEST_DATA + "nexus_test_4.nex", parser );
3904             if ( phylogenies.length != 18 ) {
3905                 return false;
3906             }
3907             if ( phylogenies[ 0 ].getNumberOfExternalNodes() != 10 ) {
3908                 return false;
3909             }
3910             if ( !phylogenies[ 0 ].getName().equals( "tree 0" ) ) {
3911                 return false;
3912             }
3913             if ( !phylogenies[ 1 ].getName().equals( "tree 1" ) ) {
3914                 return false;
3915             }
3916             if ( phylogenies[ 1 ].getNumberOfExternalNodes() != 10 ) {
3917                 return false;
3918             }
3919             if ( phylogenies[ 2 ].getNumberOfExternalNodes() != 3 ) {
3920                 return false;
3921             }
3922             if ( phylogenies[ 3 ].getNumberOfExternalNodes() != 3 ) {
3923                 return false;
3924             }
3925             if ( phylogenies[ 4 ].getNumberOfExternalNodes() != 3 ) {
3926                 return false;
3927             }
3928             if ( phylogenies[ 5 ].getNumberOfExternalNodes() != 3 ) {
3929                 return false;
3930             }
3931             if ( phylogenies[ 6 ].getNumberOfExternalNodes() != 3 ) {
3932                 return false;
3933             }
3934             if ( phylogenies[ 7 ].getNumberOfExternalNodes() != 3 ) {
3935                 return false;
3936             }
3937             if ( !phylogenies[ 8 ].getName().equals( "tree 8" ) ) {
3938                 return false;
3939             }
3940             if ( phylogenies[ 8 ].isRooted() ) {
3941                 return false;
3942             }
3943             if ( phylogenies[ 8 ].getNumberOfExternalNodes() != 3 ) {
3944                 return false;
3945             }
3946             if ( !phylogenies[ 9 ].getName().equals( "tree 9" ) ) {
3947                 return false;
3948             }
3949             if ( !phylogenies[ 9 ].isRooted() ) {
3950                 return false;
3951             }
3952             if ( phylogenies[ 9 ].getNumberOfExternalNodes() != 3 ) {
3953                 return false;
3954             }
3955             if ( !phylogenies[ 10 ].getName().equals( "tree 10" ) ) {
3956                 return false;
3957             }
3958             if ( !phylogenies[ 10 ].isRooted() ) {
3959                 return false;
3960             }
3961             if ( phylogenies[ 10 ].getNumberOfExternalNodes() != 3 ) {
3962                 return false;
3963             }
3964             if ( !phylogenies[ 11 ].getName().equals( "tree 11" ) ) {
3965                 return false;
3966             }
3967             if ( phylogenies[ 11 ].isRooted() ) {
3968                 return false;
3969             }
3970             if ( phylogenies[ 11 ].getNumberOfExternalNodes() != 3 ) {
3971                 return false;
3972             }
3973             if ( !phylogenies[ 12 ].getName().equals( "tree 12" ) ) {
3974                 return false;
3975             }
3976             if ( !phylogenies[ 12 ].isRooted() ) {
3977                 return false;
3978             }
3979             if ( phylogenies[ 12 ].getNumberOfExternalNodes() != 3 ) {
3980                 return false;
3981             }
3982             if ( !phylogenies[ 13 ].getName().equals( "tree 13" ) ) {
3983                 return false;
3984             }
3985             if ( !phylogenies[ 13 ].isRooted() ) {
3986                 return false;
3987             }
3988             if ( phylogenies[ 13 ].getNumberOfExternalNodes() != 3 ) {
3989                 return false;
3990             }
3991             if ( !phylogenies[ 14 ].getName().equals( "tree 14" ) ) {
3992                 return false;
3993             }
3994             if ( !phylogenies[ 14 ].isRooted() ) {
3995                 return false;
3996             }
3997             if ( phylogenies[ 14 ].getNumberOfExternalNodes() != 10 ) {
3998                 return false;
3999             }
4000             if ( !phylogenies[ 15 ].getName().equals( "tree 15" ) ) {
4001                 return false;
4002             }
4003             if ( phylogenies[ 15 ].isRooted() ) {
4004                 return false;
4005             }
4006             if ( phylogenies[ 15 ].getNumberOfExternalNodes() != 10 ) {
4007                 return false;
4008             }
4009             if ( !phylogenies[ 16 ].getName().equals( "tree 16" ) ) {
4010                 return false;
4011             }
4012             if ( !phylogenies[ 16 ].isRooted() ) {
4013                 return false;
4014             }
4015             if ( phylogenies[ 16 ].getNumberOfExternalNodes() != 10 ) {
4016                 return false;
4017             }
4018             if ( !phylogenies[ 17 ].getName().equals( "tree 17" ) ) {
4019                 return false;
4020             }
4021             if ( phylogenies[ 17 ].isRooted() ) {
4022                 return false;
4023             }
4024             if ( phylogenies[ 17 ].getNumberOfExternalNodes() != 10 ) {
4025                 return false;
4026             }
4027         }
4028         catch ( final Exception e ) {
4029             e.printStackTrace( System.out );
4030             return false;
4031         }
4032         return true;
4033     }
4034
4035     private static boolean testNexusTreeParsingTranslating() {
4036         try {
4037             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
4038             final NexusPhylogeniesParser parser = new NexusPhylogeniesParser();
4039             Phylogeny[] phylogenies = factory.create( Test.PATH_TO_TEST_DATA + "nexus_test_5.nex", parser );
4040             if ( phylogenies.length != 1 ) {
4041                 return false;
4042             }
4043             if ( phylogenies[ 0 ].getNumberOfExternalNodes() != 3 ) {
4044                 return false;
4045             }
4046             if ( !phylogenies[ 0 ].getName().equals( "Tree0" ) ) {
4047                 return false;
4048             }
4049             if ( !phylogenies[ 0 ].getFirstExternalNode().getName().equals( "Scarabaeus" ) ) {
4050                 return false;
4051             }
4052             if ( !phylogenies[ 0 ].getFirstExternalNode().getNextExternalNode().getName().equals( "Drosophila" ) ) {
4053                 return false;
4054             }
4055             if ( !phylogenies[ 0 ].getFirstExternalNode().getNextExternalNode().getNextExternalNode().getName()
4056                     .equals( "Aranaeus" ) ) {
4057                 return false;
4058             }
4059             phylogenies = null;
4060             phylogenies = factory.create( Test.PATH_TO_TEST_DATA + "nexus_test_6.nex", parser );
4061             if ( phylogenies.length != 3 ) {
4062                 return false;
4063             }
4064             if ( phylogenies[ 0 ].getNumberOfExternalNodes() != 3 ) {
4065                 return false;
4066             }
4067             if ( !phylogenies[ 0 ].getName().equals( "Tree0" ) ) {
4068                 return false;
4069             }
4070             if ( phylogenies[ 0 ].isRooted() ) {
4071                 return false;
4072             }
4073             if ( !phylogenies[ 0 ].getFirstExternalNode().getName().equals( "Scarabaeus" ) ) {
4074                 return false;
4075             }
4076             if ( !phylogenies[ 0 ].getFirstExternalNode().getNextExternalNode().getName().equals( "Drosophila" ) ) {
4077                 return false;
4078             }
4079             if ( !phylogenies[ 0 ].getFirstExternalNode().getNextExternalNode().getNextExternalNode().getName()
4080                     .equals( "Aranaeus" ) ) {
4081                 return false;
4082             }
4083             if ( phylogenies[ 1 ].getNumberOfExternalNodes() != 3 ) {
4084                 return false;
4085             }
4086             if ( !phylogenies[ 1 ].getName().equals( "Tree1" ) ) {
4087                 return false;
4088             }
4089             if ( phylogenies[ 1 ].isRooted() ) {
4090                 return false;
4091             }
4092             if ( !phylogenies[ 1 ].getFirstExternalNode().getName().equals( "Scarabaeus" ) ) {
4093                 return false;
4094             }
4095             if ( !phylogenies[ 1 ].getFirstExternalNode().getNextExternalNode().getName().equals( "Drosophila" ) ) {
4096                 return false;
4097             }
4098             if ( !phylogenies[ 1 ].getFirstExternalNode().getNextExternalNode().getNextExternalNode().getName()
4099                     .equals( "Aranaeus" ) ) {
4100                 return false;
4101             }
4102             if ( phylogenies[ 2 ].getNumberOfExternalNodes() != 3 ) {
4103                 return false;
4104             }
4105             if ( !phylogenies[ 2 ].getName().equals( "Tree2" ) ) {
4106                 return false;
4107             }
4108             if ( !phylogenies[ 2 ].isRooted() ) {
4109                 return false;
4110             }
4111             if ( !phylogenies[ 2 ].getFirstExternalNode().getName().equals( "Scarabaeus" ) ) {
4112                 return false;
4113             }
4114             if ( !phylogenies[ 2 ].getFirstExternalNode().getNextExternalNode().getName().equals( "Drosophila" ) ) {
4115                 return false;
4116             }
4117             if ( !phylogenies[ 2 ].getFirstExternalNode().getNextExternalNode().getNextExternalNode().getName()
4118                     .equals( "Aranaeus" ) ) {
4119                 return false;
4120             }
4121             phylogenies = null;
4122             phylogenies = factory.create( Test.PATH_TO_TEST_DATA + "nexus_test_7.nex", parser );
4123             if ( phylogenies.length != 3 ) {
4124                 return false;
4125             }
4126             if ( phylogenies[ 0 ].getNumberOfExternalNodes() != 3 ) {
4127                 return false;
4128             }
4129             if ( !phylogenies[ 0 ].getName().equals( "Tree0" ) ) {
4130                 return false;
4131             }
4132             if ( phylogenies[ 0 ].isRooted() ) {
4133                 return false;
4134             }
4135             if ( !phylogenies[ 0 ].getFirstExternalNode().getName().equals( "Scarabaeus" ) ) {
4136                 return false;
4137             }
4138             if ( !phylogenies[ 0 ].getFirstExternalNode().getNextExternalNode().getName().equals( "Drosophila" ) ) {
4139                 return false;
4140             }
4141             if ( !phylogenies[ 0 ].getFirstExternalNode().getNextExternalNode().getNextExternalNode().getName()
4142                     .equals( "Aranaeus" ) ) {
4143                 return false;
4144             }
4145             if ( phylogenies[ 1 ].getNumberOfExternalNodes() != 3 ) {
4146                 return false;
4147             }
4148             if ( !phylogenies[ 1 ].getName().equals( "Tree1" ) ) {
4149                 return false;
4150             }
4151             if ( phylogenies[ 1 ].isRooted() ) {
4152                 return false;
4153             }
4154             if ( !phylogenies[ 1 ].getFirstExternalNode().getName().equals( "Scarabaeus" ) ) {
4155                 return false;
4156             }
4157             if ( !phylogenies[ 1 ].getFirstExternalNode().getNextExternalNode().getName().equals( "Drosophila" ) ) {
4158                 return false;
4159             }
4160             if ( !phylogenies[ 1 ].getFirstExternalNode().getNextExternalNode().getNextExternalNode().getName()
4161                     .equals( "Aranaeus" ) ) {
4162                 return false;
4163             }
4164             if ( phylogenies[ 2 ].getNumberOfExternalNodes() != 3 ) {
4165                 return false;
4166             }
4167             if ( !phylogenies[ 2 ].getName().equals( "Tree2" ) ) {
4168                 return false;
4169             }
4170             if ( !phylogenies[ 2 ].isRooted() ) {
4171                 return false;
4172             }
4173             if ( !phylogenies[ 2 ].getFirstExternalNode().getName().equals( "Scarabaeus" ) ) {
4174                 return false;
4175             }
4176             if ( !phylogenies[ 2 ].getFirstExternalNode().getNextExternalNode().getName().equals( "Drosophila" ) ) {
4177                 return false;
4178             }
4179             if ( !phylogenies[ 2 ].getFirstExternalNode().getNextExternalNode().getNextExternalNode().getName()
4180                     .equals( "Aranaeus" ) ) {
4181                 return false;
4182             }
4183         }
4184         catch ( final Exception e ) {
4185             e.printStackTrace( System.out );
4186             return false;
4187         }
4188         return true;
4189     }
4190
4191     private static boolean testNHParsing() {
4192         try {
4193             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
4194             final Phylogeny p1 = factory.create( "(A,B1)", new NHXParser() )[ 0 ];
4195             if ( !p1.toNewHampshireX().equals( "(A,B1)" ) ) {
4196                 return false;
4197             }
4198             final NHXParser nhxp = new NHXParser();
4199             nhxp.setTaxonomyExtraction( ForesterUtil.TAXONOMY_EXTRACTION.NO );
4200             nhxp.setReplaceUnderscores( true );
4201             final Phylogeny uc0 = factory.create( "(A__A_,_B_B)", nhxp )[ 0 ];
4202             if ( !uc0.getRoot().getChildNode( 0 ).getName().equals( "A A " ) ) {
4203                 return false;
4204             }
4205             if ( !uc0.getRoot().getChildNode( 1 ).getName().equals( " B B" ) ) {
4206                 return false;
4207             }
4208             final Phylogeny p1b = factory
4209                     .create( "   \n  \t  \b   \r \f   ; (  \n  \t  \b   \r \f; A ;  \n  \t  \b   \r \f,  \n  \t  \b   \r \f; B ;   \n  \t  \b   \r \f 1  \n  \t  \b   \r \f ;  \n  \t  \b   \r \f );;;;; \n  \t  \b   \r \f;;;  \n  \t  \b   \r \f ",
4210                              new NHXParser() )[ 0 ];
4211             if ( !p1b.toNewHampshireX().equals( "(';A;',';B;1;')" ) ) {
4212                 return false;
4213             }
4214             if ( !p1b.toNewHampshire().equals( "(';A;',';B;1;');" ) ) {
4215                 return false;
4216             }
4217             final Phylogeny p2 = factory.create( new StringBuffer( "(A,B2)" ), new NHXParser() )[ 0 ];
4218             final Phylogeny p3 = factory.create( new char[] { '(', 'A', ',', 'B', '3', ')' }, new NHXParser() )[ 0 ];
4219             final Phylogeny p4 = factory.create( "(A,B4);", new NHXParser() )[ 0 ];
4220             final Phylogeny p5 = factory.create( new StringBuffer( "(A,B5);" ), new NHXParser() )[ 0 ];
4221             final Phylogeny[] p7 = factory.create( "(A,B7);(C,D7)", new NHXParser() );
4222             final Phylogeny[] p8 = factory.create( "(A,B8) (C,D8)", new NHXParser() );
4223             final Phylogeny[] p9 = factory.create( "(A,B9)\n(C,D9)", new NHXParser() );
4224             final Phylogeny[] p10 = factory.create( "(A,B10);(C,D10);", new NHXParser() );
4225             final Phylogeny[] p11 = factory.create( "(A,B11);(C,D11) (E,F11)\t(G,H11)", new NHXParser() );
4226             final Phylogeny[] p12 = factory.create( "(A,B12) (C,D12) (E,F12) (G,H12)", new NHXParser() );
4227             final Phylogeny[] p13 = factory.create( " ; (;A; , ; B ; 1  3 ; \n)\t ( \n ;"
4228                                                             + " C ; ,; D;13;);;;;;;(;E;,;F;13 ;) ; "
4229                                                             + "; ; ( \t\n\r\b; G ;, ;H ;1 3; )  ;  ;   ;",
4230                                                     new NHXParser() );
4231             if ( !p13[ 0 ].toNewHampshireX().equals( "(';A;',';B;13;')" ) ) {
4232                 return false;
4233             }
4234             if ( !p13[ 1 ].toNewHampshireX().equals( "(';C;',';D;13;')" ) ) {
4235                 return false;
4236             }
4237             if ( !p13[ 2 ].toNewHampshireX().equals( "(';E;',';F;13;')" ) ) {
4238                 return false;
4239             }
4240             if ( !p13[ 3 ].toNewHampshireX().equals( "(';G;',';H;13;')" ) ) {
4241                 return false;
4242             }
4243             final Phylogeny[] p14 = factory.create( "(A,B14)ab", new NHXParser() );
4244             final Phylogeny[] p15 = factory.create( "(A,B15)ab;", new NHXParser() );
4245             final String p16_S = "((A,B),C)";
4246             final Phylogeny[] p16 = factory.create( p16_S, new NHXParser() );
4247             if ( !p16[ 0 ].toNewHampshireX().equals( p16_S ) ) {
4248                 return false;
4249             }
4250             final String p17_S = "(C,(A,B))";
4251             final Phylogeny[] p17 = factory.create( p17_S, new NHXParser() );
4252             if ( !p17[ 0 ].toNewHampshireX().equals( p17_S ) ) {
4253                 return false;
4254             }
4255             final String p18_S = "((A,B),(C,D))";
4256             final Phylogeny[] p18 = factory.create( p18_S, new NHXParser() );
4257             if ( !p18[ 0 ].toNewHampshireX().equals( p18_S ) ) {
4258                 return false;
4259             }
4260             final String p19_S = "(((A,B),C),D)";
4261             final Phylogeny[] p19 = factory.create( p19_S, new NHXParser() );
4262             if ( !p19[ 0 ].toNewHampshireX().equals( p19_S ) ) {
4263                 return false;
4264             }
4265             final String p20_S = "(A,(B,(C,D)))";
4266             final Phylogeny[] p20 = factory.create( p20_S, new NHXParser() );
4267             if ( !p20[ 0 ].toNewHampshireX().equals( p20_S ) ) {
4268                 return false;
4269             }
4270             final String p21_S = "(A,(B,(C,(D,E))))";
4271             final Phylogeny[] p21 = factory.create( p21_S, new NHXParser() );
4272             if ( !p21[ 0 ].toNewHampshireX().equals( p21_S ) ) {
4273                 return false;
4274             }
4275             final String p22_S = "((((A,B),C),D),E)";
4276             final Phylogeny[] p22 = factory.create( p22_S, new NHXParser() );
4277             if ( !p22[ 0 ].toNewHampshireX().equals( p22_S ) ) {
4278                 return false;
4279             }
4280             final String p23_S = "(A,(B,(C,(D,E)de)cde)bcde)abcde";
4281             final Phylogeny[] p23 = factory.create( p23_S, new NHXParser() );
4282             if ( !p23[ 0 ].toNewHampshireX().equals( p23_S ) ) {
4283                 return false;
4284             }
4285             final String p24_S = "((((A,B)ab,C)abc,D)abcd,E)abcde";
4286             final Phylogeny[] p24 = factory.create( p24_S, new NHXParser() );
4287             if ( !p24[ 0 ].toNewHampshireX().equals( p24_S ) ) {
4288                 return false;
4289             }
4290             final String p241_S1 = "(A,(B,(C,(D,E)de)cde)bcde)abcde";
4291             final String p241_S2 = "((((A,B)ab,C)abc,D)abcd,E)abcde";
4292             final Phylogeny[] p241 = factory.create( p241_S1 + p241_S2, new NHXParser() );
4293             if ( !p241[ 0 ].toNewHampshireX().equals( p241_S1 ) ) {
4294                 return false;
4295             }
4296             if ( !p241[ 1 ].toNewHampshireX().equals( p241_S2 ) ) {
4297                 return false;
4298             }
4299             final String p25_S = "((((((((((((((A,B)ab,C)abc,D)abcd,E)"
4300                     + "abcde,(B,(C,(D,E)de)cde)bcde)abcde,(B,((A,(B,(C,(D,"
4301                     + "E)de)cde)bcde)abcde,(D,E)de)cde)bcde)abcde,B)ab,C)"
4302                     + "abc,((((A,B)ab,C)abc,D)abcd,E)abcde)abcd,E)abcde,"
4303                     + "((((A,((((((((A,B)ab,C)abc,((((A,B)ab,C)abc,D)abcd,"
4304                     + "E)abcde)abcd,E)abcde,((((A,B)ab,C)abc,D)abcd,E)abcde)"
4305                     + "ab,C)abc,((((A,B)ab,C)abc,D)abcd,E)abcde)abcd,E)abcde"
4306                     + ")ab,C)abc,D)abcd,E)abcde)ab,C)abc,((((A,B)ab,C)abc,D)" + "abcd,E)abcde)abcd,E)abcde";
4307             final Phylogeny[] p25 = factory.create( p25_S, new NHXParser() );
4308             if ( !p25[ 0 ].toNewHampshireX().equals( p25_S ) ) {
4309                 return false;
4310             }
4311             final String p26_S = "(A,B)ab";
4312             final Phylogeny[] p26 = factory.create( p26_S, new NHXParser() );
4313             if ( !p26[ 0 ].toNewHampshireX().equals( p26_S ) ) {
4314                 return false;
4315             }
4316             final String p27_S = "((((A,B)ab,C)abc,D)abcd,E)abcde";
4317             final Phylogeny[] p27 = factory.create( new File( Test.PATH_TO_TEST_DATA + "phylogeny27.nhx" ),
4318                                                     new NHXParser() );
4319             if ( !p27[ 0 ].toNewHampshireX().equals( p27_S ) ) {
4320                 return false;
4321             }
4322             final String p28_S1 = "((((A,B)ab,C)abc,D)abcd,E)abcde";
4323             final String p28_S2 = "(A,(B,(C,(D,E)de)cde)bcde)abcde";
4324             final String p28_S3 = "(A,B)ab";
4325             final String p28_S4 = "((((A,B),C),D),;E;)";
4326             final Phylogeny[] p28 = factory.create( new File( Test.PATH_TO_TEST_DATA + "phylogeny28.nhx" ),
4327                                                     new NHXParser() );
4328             if ( !p28[ 0 ].toNewHampshireX().equals( p28_S1 ) ) {
4329                 return false;
4330             }
4331             if ( !p28[ 1 ].toNewHampshireX().equals( p28_S2 ) ) {
4332                 return false;
4333             }
4334             if ( !p28[ 2 ].toNewHampshireX().equals( p28_S3 ) ) {
4335                 return false;
4336             }
4337             if ( !p28[ 3 ].toNewHampshireX().equals( "((((A,B),C),D),';E;')" ) ) {
4338                 return false;
4339             }
4340             final String p29_S = "((((A:0.01,B:0.684)ab:0.345,C:0.3451)abc:0.3451,D:1.5)abcd:0.134,E:0.32)abcde:0.1345";
4341             final Phylogeny[] p29 = factory.create( p29_S, new NHXParser() );
4342             if ( !p29[ 0 ].toNewHampshireX().equals( p29_S ) ) {
4343                 return false;
4344             }
4345             final String p30_S = "((((A:0.01,B:0.02):0.93,C:0.04):0.05,D:1.4):0.06,E):0.72";
4346             final Phylogeny[] p30 = factory.create( p30_S, new NHXParser() );
4347             if ( !p30[ 0 ].toNewHampshireX().equals( p30_S ) ) {
4348                 return false;
4349             }
4350             final String p32_S = " ;   ;        \n  \t  \b   \f  \r  ;;;;;; ";
4351             final Phylogeny[] p32 = factory.create( p32_S, new NHXParser() );
4352             if ( ( p32.length != 1 ) || !p32[ 0 ].isEmpty() ) {
4353                 return false;
4354             }
4355             final String p33_S = "A";
4356             final Phylogeny[] p33 = factory.create( p33_S, new NHXParser() );
4357             if ( !p33[ 0 ].toNewHampshireX().equals( p33_S ) ) {
4358                 return false;
4359             }
4360             final String p34_S = "B;";
4361             final Phylogeny[] p34 = factory.create( p34_S, new NHXParser() );
4362             if ( !p34[ 0 ].toNewHampshireX().equals( "B" ) ) {
4363                 return false;
4364             }
4365             final String p35_S = "B:0.2";
4366             final Phylogeny[] p35 = factory.create( p35_S, new NHXParser() );
4367             if ( !p35[ 0 ].toNewHampshireX().equals( p35_S ) ) {
4368                 return false;
4369             }
4370             final String p36_S = "(A)";
4371             final Phylogeny[] p36 = factory.create( p36_S, new NHXParser() );
4372             if ( !p36[ 0 ].toNewHampshireX().equals( p36_S ) ) {
4373                 return false;
4374             }
4375             final String p37_S = "((A))";
4376             final Phylogeny[] p37 = factory.create( p37_S, new NHXParser() );
4377             if ( !p37[ 0 ].toNewHampshireX().equals( p37_S ) ) {
4378                 return false;
4379             }
4380             final String p38_S = "(((((((A:0.2):0.2):0.3):0.4):0.5):0.6):0.7):0.8";
4381             final Phylogeny[] p38 = factory.create( p38_S, new NHXParser() );
4382             if ( !p38[ 0 ].toNewHampshireX().equals( p38_S ) ) {
4383                 return false;
4384             }
4385             final String p39_S = "(((B,((((A:0.2):0.2):0.3):0.4):0.5):0.6):0.7):0.8";
4386             final Phylogeny[] p39 = factory.create( p39_S, new NHXParser() );
4387             if ( !p39[ 0 ].toNewHampshireX().equals( p39_S ) ) {
4388                 return false;
4389             }
4390             final String p40_S = "(A,B,C)";
4391             final Phylogeny[] p40 = factory.create( p40_S, new NHXParser() );
4392             if ( !p40[ 0 ].toNewHampshireX().equals( p40_S ) ) {
4393                 return false;
4394             }
4395             final String p41_S = "(A,B,C,D,E,F,G,H,I,J,K)";
4396             final Phylogeny[] p41 = factory.create( p41_S, new NHXParser() );
4397             if ( !p41[ 0 ].toNewHampshireX().equals( p41_S ) ) {
4398                 return false;
4399             }
4400             final String p42_S = "(A,B,(X,Y,Z),D,E,F,G,H,I,J,K)";
4401             final Phylogeny[] p42 = factory.create( p42_S, new NHXParser() );
4402             if ( !p42[ 0 ].toNewHampshireX().equals( p42_S ) ) {
4403                 return false;
4404             }
4405             final String p43_S = "(A,B,C,(AA,BB,CC,(CCC,DDD,EEE,(FFFF,GGGG)x)y,DD,EE,FF,GG,HH),D,E,(EE,FF),F,G,H,(((((5)4)3)2)1),I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,(XX,(YY)),Y,Z)";
4406             final Phylogeny[] p43 = factory.create( p43_S, new NHXParser() );
4407             if ( !p43[ 0 ].toNewHampshireX().equals( p43_S ) ) {
4408                 return false;
4409             }
4410             final String p44_S = "(((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)),((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)),((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)),((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)))";
4411             final Phylogeny[] p44 = factory.create( p44_S, new NHXParser() );
4412             if ( !p44[ 0 ].toNewHampshireX().equals( p44_S ) ) {
4413                 return false;
4414             }
4415             final String p45_S = "((((((((((A))))))))),(((((((((B))))))))),(((((((((C))))))))))";
4416             final Phylogeny[] p45 = factory.create( p45_S, new NHXParser() );
4417             if ( !p45[ 0 ].toNewHampshireX().equals( p45_S ) ) {
4418                 return false;
4419             }
4420             final String p46_S = "";
4421             final Phylogeny[] p46 = factory.create( p46_S, new NHXParser() );
4422             if ( ( p46.length != 1 ) || !p46[ 0 ].isEmpty() ) {
4423                 return false;
4424             }
4425         }
4426         catch ( final Exception e ) {
4427             e.printStackTrace( System.out );
4428             return false;
4429         }
4430         return true;
4431     }
4432
4433     private static boolean testNHXconversion() {
4434         try {
4435             final PhylogenyNode n1 = new PhylogenyNode();
4436             final PhylogenyNode n2 = new PhylogenyNode( "" );
4437             final PhylogenyNode n3 = new PhylogenyNode( "n3" );
4438             final PhylogenyNode n4 = new PhylogenyNode( "n4:0.01" );
4439             final PhylogenyNode n5 = new PhylogenyNode( "n5:0.1[&&NHX:S=Ecoli:E=1.1.1.1:D=Y:Co=Y:B=56:T=1:W=2:C=10.20.30:XN=S=tag1=value1=unit1]" );
4440             final PhylogenyNode n6 = new PhylogenyNode( "n6:0.000001[&&NHX:S=Ecoli:E=1.1.1.1:D=N:Co=N:B=100:T=1:W=2:C=0.0.0:XN=B=bool_tag=T]" );
4441             if ( !n1.toNewHampshireX().equals( "" ) ) {
4442                 return false;
4443             }
4444             if ( !n2.toNewHampshireX().equals( "" ) ) {
4445                 return false;
4446             }
4447             if ( !n3.toNewHampshireX().equals( "n3" ) ) {
4448                 return false;
4449             }
4450             if ( !n4.toNewHampshireX().equals( "n4:0.01" ) ) {
4451                 return false;
4452             }
4453             if ( !n5.toNewHampshireX()
4454                     .equals( "n5:0.1[&&NHX:T=1:S=Ecoli:D=Y:XN=S=tag1=value1=unit1:B=56.0:W=2.0:C=10.20.30]" ) ) {
4455                 return false;
4456             }
4457             if ( !n6.toNewHampshireX()
4458                     .equals( "n6:1.0E-6[&&NHX:T=1:S=Ecoli:D=N:XN=B=bool_tag=T:B=100.0:W=2.0:C=0.0.0]" ) ) {
4459                 return false;
4460             }
4461         }
4462         catch ( final Exception e ) {
4463             e.printStackTrace( System.out );
4464             return false;
4465         }
4466         return true;
4467     }
4468
4469     private static boolean testNHXNodeParsing() {
4470         try {
4471             final PhylogenyNode n1 = new PhylogenyNode();
4472             final PhylogenyNode n2 = new PhylogenyNode( "" );
4473             final PhylogenyNode n3 = new PhylogenyNode( "n3" );
4474             final PhylogenyNode n4 = new PhylogenyNode( "n4:0.01" );
4475             final PhylogenyNode n5 = new PhylogenyNode( "n5:0.1[&&NHX:S=Ecoli:E=1.1.1.1:D=Y:B=56:T=1:On=22:SOn=33:SNn=44:W=2:C=10.20.30:XN=S=tag1=value1=unit1:XN=S=tag3=value3=unit3]" );
4476             if ( !n3.getName().equals( "n3" ) ) {
4477                 return false;
4478             }
4479             if ( n3.getDistanceToParent() != PhylogenyNode.DISTANCE_DEFAULT ) {
4480                 return false;
4481             }
4482             if ( n3.isDuplication() ) {
4483                 return false;
4484             }
4485             if ( n3.isHasAssignedEvent() ) {
4486                 return false;
4487             }
4488             if ( PhylogenyMethods.getBranchWidthValue( n3 ) != BranchWidth.BRANCH_WIDTH_DEFAULT_VALUE ) {
4489                 return false;
4490             }
4491             if ( !n4.getName().equals( "n4" ) ) {
4492                 return false;
4493             }
4494             if ( n4.getDistanceToParent() != 0.01 ) {
4495                 return false;
4496             }
4497             if ( !n5.getName().equals( "n5" ) ) {
4498                 return false;
4499             }
4500             if ( PhylogenyMethods.getConfidenceValue( n5 ) != 56 ) {
4501                 return false;
4502             }
4503             if ( n5.getDistanceToParent() != 0.1 ) {
4504                 return false;
4505             }
4506             if ( !PhylogenyMethods.getSpecies( n5 ).equals( "Ecoli" ) ) {
4507                 return false;
4508             }
4509             if ( !n5.isDuplication() ) {
4510                 return false;
4511             }
4512             if ( !n5.isHasAssignedEvent() ) {
4513                 return false;
4514             }
4515             if ( PhylogenyMethods.getBranchWidthValue( n5 ) != 2 ) {
4516                 return false;
4517             }
4518             if ( n5.getNodeData().getProperties().getPropertyRefs().length != 2 ) {
4519                 return false;
4520             }
4521             final PhylogenyNode n8 = new PhylogenyNode( "n8_ECOLI/12:0.01",
4522                                                         ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4523             if ( !n8.getName().equals( "n8_ECOLI/12" ) ) {
4524                 return false;
4525             }
4526             if ( !PhylogenyMethods.getSpecies( n8 ).equals( "ECOLI" ) ) {
4527                 return false;
4528             }
4529             final PhylogenyNode n9 = new PhylogenyNode( "n9_ECOLI/12=12:0.01",
4530                                                         ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4531             if ( !n9.getName().equals( "n9_ECOLI/12=12" ) ) {
4532                 return false;
4533             }
4534             if ( !PhylogenyMethods.getSpecies( n9 ).equals( "ECOLI" ) ) {
4535                 return false;
4536             }
4537             final PhylogenyNode n10 = new PhylogenyNode( "n10.ECOLI", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4538             if ( !n10.getName().equals( "n10.ECOLI" ) ) {
4539                 return false;
4540             }
4541             final PhylogenyNode n20 = new PhylogenyNode( "n20_ECOLI/1-2",
4542                                                          ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4543             if ( !n20.getName().equals( "n20_ECOLI/1-2" ) ) {
4544                 return false;
4545             }
4546             if ( !PhylogenyMethods.getSpecies( n20 ).equals( "ECOLI" ) ) {
4547                 return false;
4548             }
4549             final PhylogenyNode n20x = new PhylogenyNode( "n20_ECOL1/1-2", ForesterUtil.TAXONOMY_EXTRACTION.YES );
4550             if ( !n20x.getName().equals( "n20_ECOL1/1-2" ) ) {
4551                 return false;
4552             }
4553             if ( !PhylogenyMethods.getSpecies( n20x ).equals( "ECOL1" ) ) {
4554                 return false;
4555             }
4556             final PhylogenyNode n20xx = new PhylogenyNode( "n20_eCOL1/1-2",
4557                                                            ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4558             if ( !n20xx.getName().equals( "n20_eCOL1/1-2" ) ) {
4559                 return false;
4560             }
4561             if ( PhylogenyMethods.getSpecies( n20xx ).length() > 0 ) {
4562                 return false;
4563             }
4564             final PhylogenyNode n20xxx = new PhylogenyNode( "n20_ecoli/1-2",
4565                                                             ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4566             if ( !n20xxx.getName().equals( "n20_ecoli/1-2" ) ) {
4567                 return false;
4568             }
4569             if ( PhylogenyMethods.getSpecies( n20xxx ).length() > 0 ) {
4570                 return false;
4571             }
4572             final PhylogenyNode n20xxxx = new PhylogenyNode( "n20_Ecoli/1-2",
4573                                                              ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4574             if ( !n20xxxx.getName().equals( "n20_Ecoli/1-2" ) ) {
4575                 return false;
4576             }
4577             if ( PhylogenyMethods.getSpecies( n20xxxx ).length() > 0 ) {
4578                 return false;
4579             }
4580             final PhylogenyNode n21 = new PhylogenyNode( "n21_PIG", ForesterUtil.TAXONOMY_EXTRACTION.YES );
4581             if ( !n21.getName().equals( "n21_PIG" ) ) {
4582                 return false;
4583             }
4584             if ( !PhylogenyMethods.getSpecies( n21 ).equals( "PIG" ) ) {
4585                 return false;
4586             }
4587             final PhylogenyNode n21x = new PhylogenyNode( "n21_PIG", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4588             if ( !n21x.getName().equals( "n21_PIG" ) ) {
4589                 return false;
4590             }
4591             if ( PhylogenyMethods.getSpecies( n21x ).length() > 0 ) {
4592                 return false;
4593             }
4594             final PhylogenyNode n22 = new PhylogenyNode( "n22/PIG", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4595             if ( !n22.getName().equals( "n22/PIG" ) ) {
4596                 return false;
4597             }
4598             if ( PhylogenyMethods.getSpecies( n22 ).length() > 0 ) {
4599                 return false;
4600             }
4601             final PhylogenyNode n23 = new PhylogenyNode( "n23/PIG_1", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4602             if ( !n23.getName().equals( "n23/PIG_1" ) ) {
4603                 return false;
4604             }
4605             if ( PhylogenyMethods.getSpecies( n23 ).length() > 0 ) {
4606                 return false;
4607             }
4608             if ( NHXParser.LIMIT_SPECIES_NAMES_TO_FIVE_CHARS ) {
4609                 final PhylogenyNode a = new PhylogenyNode( "n10_ECOLI/1-2",
4610                                                            ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4611                 if ( !a.getName().equals( "n10_ECOLI/1-2" ) ) {
4612                     return false;
4613                 }
4614                 if ( !PhylogenyMethods.getSpecies( a ).equals( "ECOLI" ) ) {
4615                     return false;
4616                 }
4617                 final PhylogenyNode b = new PhylogenyNode( "n10_ECOLI1/1-2",
4618                                                            ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4619                 if ( !b.getName().equals( "n10_ECOLI1/1-2" ) ) {
4620                     return false;
4621                 }
4622                 if ( !PhylogenyMethods.getSpecies( b ).equals( "ECOLI" ) ) {
4623                     return false;
4624                 }
4625                 final PhylogenyNode c = new PhylogenyNode( "n10_RATAF12/1000-2000",
4626                                                            ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4627                 if ( !c.getName().equals( "n10_RATAF12/1000-2000" ) ) {
4628                     return false;
4629                 }
4630                 if ( !PhylogenyMethods.getSpecies( c ).equals( "RATAF" ) ) {
4631                     return false;
4632                 }
4633                 final PhylogenyNode d = new PhylogenyNode( "n10_RAT1/1-2",
4634                                                            ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4635                 if ( !d.getName().equals( "n10_RAT1/1-2" ) ) {
4636                     return false;
4637                 }
4638                 if ( !PhylogenyMethods.getSpecies( d ).equals( "RAT" ) ) {
4639                     return false;
4640                 }
4641                 final PhylogenyNode e = new PhylogenyNode( "n10_RAT1", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4642                 if ( !e.getName().equals( "n10_RAT1" ) ) {
4643                     return false;
4644                 }
4645                 if ( !ForesterUtil.isEmpty( PhylogenyMethods.getSpecies( e ) ) ) {
4646                     return false;
4647                 }
4648             }
4649             final PhylogenyNode n11 = new PhylogenyNode( "n111111_ECOLI/jdj:0.4",
4650                                                          ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4651             if ( !n11.getName().equals( "n111111_ECOLI/jdj" ) ) {
4652                 return false;
4653             }
4654             if ( n11.getDistanceToParent() != 0.4 ) {
4655                 return false;
4656             }
4657             if ( !PhylogenyMethods.getSpecies( n11 ).equals( "ECOLI" ) ) {
4658                 return false;
4659             }
4660             final PhylogenyNode n12 = new PhylogenyNode( "n111111-ECOLI---/jdj:0.4",
4661                                                          ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4662             if ( !n12.getName().equals( "n111111-ECOLI---/jdj" ) ) {
4663                 return false;
4664             }
4665             if ( n12.getDistanceToParent() != 0.4 ) {
4666                 return false;
4667             }
4668             if ( PhylogenyMethods.getSpecies( n12 ).length() > 0 ) {
4669                 return false;
4670             }
4671             final Property tvu1 = n5.getNodeData().getProperties().getProperty( "tag1" );
4672             final Property tvu3 = n5.getNodeData().getProperties().getProperty( "tag3" );
4673             if ( !tvu1.getRef().equals( "tag1" ) ) {
4674                 return false;
4675             }
4676             if ( !tvu1.getDataType().equals( "xsd:string" ) ) {
4677                 return false;
4678             }
4679             if ( !tvu1.getUnit().equals( "unit1" ) ) {
4680                 return false;
4681             }
4682             if ( !tvu1.getValue().equals( "value1" ) ) {
4683                 return false;
4684             }
4685             if ( !tvu3.getRef().equals( "tag3" ) ) {
4686                 return false;
4687             }
4688             if ( !tvu3.getDataType().equals( "xsd:string" ) ) {
4689                 return false;
4690             }
4691             if ( !tvu3.getUnit().equals( "unit3" ) ) {
4692                 return false;
4693             }
4694             if ( !tvu3.getValue().equals( "value3" ) ) {
4695                 return false;
4696             }
4697             if ( n1.getName().compareTo( "" ) != 0 ) {
4698                 return false;
4699             }
4700             if ( PhylogenyMethods.getConfidenceValue( n1 ) != Confidence.CONFIDENCE_DEFAULT_VALUE ) {
4701                 return false;
4702             }
4703             if ( n1.getDistanceToParent() != PhylogenyNode.DISTANCE_DEFAULT ) {
4704                 return false;
4705             }
4706             if ( n2.getName().compareTo( "" ) != 0 ) {
4707                 return false;
4708             }
4709             if ( PhylogenyMethods.getConfidenceValue( n2 ) != Confidence.CONFIDENCE_DEFAULT_VALUE ) {
4710                 return false;
4711             }
4712             if ( n2.getDistanceToParent() != PhylogenyNode.DISTANCE_DEFAULT ) {
4713                 return false;
4714             }
4715             final PhylogenyNode n00 = new PhylogenyNode( "n7:0.000001[&&NHX:GN=gene_name:AC=accession123:ID=node_identifier:S=Ecoli:D=N:Co=N:B=100:T=1:On=100:SOn=100:SNn=100:W=2:C=0.0.0:XN=U=url_tag=www.yahoo.com]" );
4716             if ( !n00.getNodeData().getNodeIdentifier().getValue().equals( "node_identifier" ) ) {
4717                 return false;
4718             }
4719             if ( !n00.getNodeData().getSequence().getName().equals( "gene_name" ) ) {
4720                 return false;
4721             }
4722             if ( !n00.getNodeData().getSequence().getAccession().getValue().equals( "accession123" ) ) {
4723                 return false;
4724             }
4725             if ( !n00.getNodeData().getProperties().getProperty( "url_tag" ).getRef().equals( "url_tag" ) ) {
4726                 return false;
4727             }
4728             if ( n00.getNodeData().getProperties().getProperty( "url_tag" ).getAppliesTo() != Property.AppliesTo.NODE ) {
4729                 return false;
4730             }
4731             if ( !n00.getNodeData().getProperties().getProperty( "url_tag" ).getDataType().equals( "xsd:anyURI" ) ) {
4732                 return false;
4733             }
4734             if ( !n00.getNodeData().getProperties().getProperty( "url_tag" ).getValue().equals( "www.yahoo.com" ) ) {
4735                 return false;
4736             }
4737             if ( !n00.getNodeData().getProperties().getProperty( "url_tag" ).getUnit().equals( "" ) ) {
4738                 return false;
4739             }
4740             final PhylogenyNode nx = new PhylogenyNode( "n5:0.1[&&NHX:S=Ecoli:GN=gene_1]" );
4741             if ( !nx.getNodeData().getSequence().getName().equals( "gene_1" ) ) {
4742                 return false;
4743             }
4744             final PhylogenyNode nx2 = new PhylogenyNode( "n5:0.1[&&NHX:S=Ecoli:G=gene_2]" );
4745             if ( !nx2.getNodeData().getSequence().getName().equals( "gene_2" ) ) {
4746                 return false;
4747             }
4748             final PhylogenyNode n13 = new PhylogenyNode( "blah_12345/1-2",
4749                                                          ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4750             if ( !n13.getName().equals( "blah_12345/1-2" ) ) {
4751                 return false;
4752             }
4753             if ( !PhylogenyMethods.getSpecies( n13 ).equals( "" ) ) {
4754                 return false;
4755             }
4756             final PhylogenyNode n14 = new PhylogenyNode( "blah_12X45/1-2",
4757                                                          ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4758             if ( !n14.getName().equals( "blah_12X45/1-2" ) ) {
4759                 return false;
4760             }
4761             if ( !PhylogenyMethods.getSpecies( n14 ).equals( "12X45" ) ) {
4762                 return false;
4763             }
4764             final PhylogenyNode n15 = new PhylogenyNode( "something_wicked[123]",
4765                                                          ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4766             if ( !n15.getName().equals( "something_wicked" ) ) {
4767                 return false;
4768             }
4769             if ( n15.getBranchData().getNumberOfConfidences() != 1 ) {
4770                 return false;
4771             }
4772             if ( !isEqual( n15.getBranchData().getConfidence( 0 ).getValue(), 123 ) ) {
4773                 return false;
4774             }
4775             final PhylogenyNode n16 = new PhylogenyNode( "something_wicked2[9]",
4776                                                          ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4777             if ( !n16.getName().equals( "something_wicked2" ) ) {
4778                 return false;
4779             }
4780             if ( n16.getBranchData().getNumberOfConfidences() != 1 ) {
4781                 return false;
4782             }
4783             if ( !isEqual( n16.getBranchData().getConfidence( 0 ).getValue(), 9 ) ) {
4784                 return false;
4785             }
4786             final PhylogenyNode n17 = new PhylogenyNode( "something_wicked3[a]",
4787                                                          ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4788             if ( !n17.getName().equals( "something_wicked3" ) ) {
4789                 return false;
4790             }
4791             if ( n17.getBranchData().getNumberOfConfidences() != 0 ) {
4792                 return false;
4793             }
4794             final PhylogenyNode n18 = new PhylogenyNode( ":0.5[91]", ForesterUtil.TAXONOMY_EXTRACTION.PFAM_STYLE_ONLY );
4795             if ( !isEqual( n18.getDistanceToParent(), 0.5 ) ) {
4796                 return false;
4797             }
4798             if ( n18.getBranchData().getNumberOfConfidences() != 1 ) {
4799                 return false;
4800             }
4801             if ( !isEqual( n18.getBranchData().getConfidence( 0 ).getValue(), 91 ) ) {
4802                 return false;
4803             }
4804         }
4805         catch ( final Exception e ) {
4806             e.printStackTrace( System.out );
4807             return false;
4808         }
4809         return true;
4810     }
4811
4812     private static boolean testNHXParsing() {
4813         try {
4814             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
4815             final Phylogeny p1 = factory.create( "(A     [&&NHX:S=a_species],B1[&&NHX:S=b_species])", new NHXParser() )[ 0 ];
4816             if ( !p1.toNewHampshireX().equals( "(A[&&NHX:S=a_species],B1[&&NHX:S=b_species])" ) ) {
4817                 return false;
4818             }
4819             final String p2_S = "(((((((A:0.2[&&NHX:S=qwerty]):0.2[&&NHX:S=uiop]):0.3[&&NHX:S=asdf]):0.4[&&NHX:S=zxc]):0.5[&&NHX:S=a]):0.6[&&NHX:S=asd]):0.7[&&NHX:S=za]):0.8[&&NHX:S=zaq]";
4820             final Phylogeny[] p2 = factory.create( p2_S, new NHXParser() );
4821             if ( !p2[ 0 ].toNewHampshireX().equals( p2_S ) ) {
4822                 return false;
4823             }
4824             final String p2b_S = "(((((((A:0.2[&NHX:S=qwerty]):0.2[&:S=uiop]):0.3[&NHX:S=asdf]):0.4[S=zxc]):0.5[]):0.6[&&NH:S=asd]):0.7[&&HX:S=za]):0.8[&&:S=zaq]";
4825             final Phylogeny[] p2b = factory.create( p2b_S, new NHXParser() );
4826             if ( !p2b[ 0 ].toNewHampshireX().equals( "(((((((A:0.2):0.2):0.3):0.4):0.5):0.6):0.7):0.8" ) ) {
4827                 return false;
4828             }
4829             final Phylogeny[] p3 = factory
4830                     .create( "[  comment&&NHX,())))](((((((A:0.2[&&NHX:S=qwerty]):0.2[&&NHX:S=uiop]):0.3[&&NHX:S=asdf]):0.4[&&NHX:S=zxc]):0.5[&&NHX:S=a]):0.6[&&NHX:S=asd]):0.7[&&NHX:S=za]):0.8[&&NHX:S=zaq]",
4831                              new NHXParser() );
4832             if ( !p3[ 0 ].toNewHampshireX().equals( p2_S ) ) {
4833                 return false;
4834             }
4835             final Phylogeny[] p4 = factory
4836                     .create( "(((((((A:0.2[&&NHX:S=qwerty]):0.2[&&NHX:S=uiop]):0.3[&&NHX:S=asdf]):0.4[&&NHX:S=zxc]):0.5[&&NHX:S=a]):0.6[&&NHX:S=asd]):0.7[&&NHX:S=za]):0.8[&&NHX:S=zaq][comment(]",
4837                              new NHXParser() );
4838             if ( !p4[ 0 ].toNewHampshireX().equals( p2_S ) ) {
4839                 return false;
4840             }
4841             final Phylogeny[] p5 = factory
4842                     .create( "[]  (  [][ ][   ]  ([((( &&NHXcomment only![[[[[[]([]((((A:0.2[&&NHX:S=q[comment )))]werty][,,,,))]):0.2[&&NHX:S=uiop]):0.3[&&NHX:S=a[comment,,))]sdf])[comment(((]:0.4[&&NHX:S=zxc][comment(((][comment(((]):0.5[&&NHX:S=a]):0.6[&&NHX:S=a[comment(((]sd]):0.7[&&NHX:S=za]):0.8[&&NHX:S=zaq][comment(((]",
4843                              new NHXParser() );
4844             if ( !p5[ 0 ].toNewHampshireX().equals( p2_S ) ) {
4845                 return false;
4846             }
4847             final String p6_S_C = "(A[][][][1][22][333][4444][55555][666666][&&NHX:S=Aspecies],B[))],C,(AA,BB,CC,(CCC,DDD,EEE,[comment](FFFF,GGGG)x)y,D[comment]D,EE,FF,GG,HH),D,E,(EE,FF),F,G,H,(((((5)4)3)2)1),I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,(XX,(YY)),Y,Z)";
4848             final String p6_S_WO_C = "(A[&&NHX:S=Aspecies],B,C,(AA,BB,CC,(CCC,DDD,EEE,(FFFF,GGGG)x)y,DD,EE,FF,GG,HH),D,E,(EE,FF),F,G,H,(((((5)4)3)2)1),I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,(XX,(YY)),Y,Z)";
4849             final Phylogeny[] p6 = factory.create( p6_S_C, new NHXParser() );
4850             if ( !p6[ 0 ].toNewHampshireX().equals( p6_S_WO_C ) ) {
4851                 return false;
4852             }
4853             final String p7_S_C = "(((A [&&NHX:S=species_a], B [&&NHX:S=Vstorri] , C   , D),(A,B,C,D[comment])[],[c][]([xxx]A[comment],[comment]B[comment][comment],[comment][comment]C[comment][comment],[comment][comment]D[comment][comment])[comment][comment],[comment]   [comment](A,B,C,D)),((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)),((A,B,C[comment][comment][comment][comment][comment]    [comment],D),(A,B,C,D),(A,B,C,D),(A,B,C,D)),[comment][comment]((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)))";
4854             final String p7_S_WO_C = "(((A[&&NHX:S=species_a],B[&&NHX:S=Vstorri],C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)),((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)),((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)),((A,B,C,D),(A,B,C,D),(A,B,C,D),(A,B,C,D)))";
4855             final Phylogeny[] p7 = factory.create( p7_S_C, new NHXParser() );
4856             if ( !p7[ 0 ].toNewHampshireX().equals( p7_S_WO_C ) ) {
4857                 return false;
4858             }
4859             final String p8_S_C = "[cmt](((([]([))))))](((((A[&&NHX:S= [a comment] a])))))))[too many comments!:)])),(((((((((B[&&NHX[ a comment in a bad place]:S   =b])))))[] []   )))),(((((((((C[&&NHX:S=c])   ))[,,, ])))))))";
4860             final String p8_S_WO_C = "((((((((((A[&&NHX:S=a]))))))))),(((((((((B[&&NHX:S=b]))))))))),(((((((((C[&&NHX:S=c]))))))))))";
4861             final Phylogeny[] p8 = factory.create( p8_S_C, new NHXParser() );
4862             if ( !p8[ 0 ].toNewHampshireX().equals( p8_S_WO_C ) ) {
4863                 return false;
4864             }
4865             final Phylogeny p9 = factory.create( "((A:0.2,B:0.3):0.5[91],C:0.1)root:0.1[100]", new NHXParser() )[ 0 ];
4866             if ( !p9.toNewHampshireX().equals( "((A:0.2,B:0.3):0.5[&&NHX:B=91.0],C:0.1)root:0.1[&&NHX:B=100.0]" ) ) {
4867                 return false;
4868             }
4869             final Phylogeny p10 = factory
4870                     .create( " [79]   ( (A [co mment] :0 .2[comment],B:0.3[com])[com ment]: 0. 5 \t[ 9 1 ][ comment],C: 0.1)[comment]root:0.1[100] [comment]",
4871                              new NHXParser() )[ 0 ];
4872             if ( !p10.toNewHampshireX().equals( "((A:0.2,B:0.3):0.5[&&NHX:B=91.0],C:0.1)root:0.1[&&NHX:B=100.0]" ) ) {
4873                 return false;
4874             }
4875         }
4876         catch ( final Exception e ) {
4877             e.printStackTrace( System.out );
4878             return false;
4879         }
4880         return true;
4881     }
4882
4883     private static boolean testNHXParsingQuotes() {
4884         try {
4885             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
4886             final NHXParser p = new NHXParser();
4887             final Phylogeny[] phylogenies_0 = factory.create( new File( Test.PATH_TO_TEST_DATA + "quotes.nhx" ), p );
4888             if ( phylogenies_0.length != 5 ) {
4889                 return false;
4890             }
4891             final Phylogeny phy = phylogenies_0[ 4 ];
4892             if ( phy.getNumberOfExternalNodes() != 7 ) {
4893                 return false;
4894             }
4895             if ( phy.getNodes( "a name in double quotes from tree ((a,b),c)" ).size() != 1 ) {
4896                 return false;
4897             }
4898             if ( phy.getNodes( "charles darwin 'origin of species'" ).size() != 1 ) {
4899                 return false;
4900             }
4901             if ( !phy.getNodes( "charles darwin 'origin of species'" ).get( 0 ).getNodeData().getTaxonomy()
4902                     .getScientificName().equals( "hsapiens" ) ) {
4903                 return false;
4904             }
4905             if ( phy.getNodes( "shouldbetogether single quotes" ).size() != 1 ) {
4906                 return false;
4907             }
4908             if ( phy.getNodes( "'single quotes' inside double quotes" ).size() != 1 ) {
4909                 return false;
4910             }
4911             if ( phy.getNodes( "double quotes inside single quotes" ).size() != 1 ) {
4912                 return false;
4913             }
4914             if ( phy.getNodes( "noquotes" ).size() != 1 ) {
4915                 return false;
4916             }
4917             if ( phy.getNodes( "A   (  B    C '" ).size() != 1 ) {
4918                 return false;
4919             }
4920             final NHXParser p1p = new NHXParser();
4921             p1p.setIgnoreQuotes( true );
4922             final Phylogeny p1 = factory.create( "(\"A\",'B1')", p1p )[ 0 ];
4923             if ( !p1.toNewHampshire().equals( "(A,B1);" ) ) {
4924                 return false;
4925             }
4926             final NHXParser p2p = new NHXParser();
4927             p1p.setIgnoreQuotes( false );
4928             final Phylogeny p2 = factory.create( "(\"A\",'B1')", p2p )[ 0 ];
4929             if ( !p2.toNewHampshire().equals( "(A,B1);" ) ) {
4930                 return false;
4931             }
4932             final NHXParser p3p = new NHXParser();
4933             p3p.setIgnoreQuotes( false );
4934             final Phylogeny p3 = factory.create( "(\"A)\",'B1')", p3p )[ 0 ];
4935             if ( !p3.toNewHampshire().equals( "('A)',B1);" ) ) {
4936                 return false;
4937             }
4938             final NHXParser p4p = new NHXParser();
4939             p4p.setIgnoreQuotes( false );
4940             final Phylogeny p4 = factory.create( "(\"A)\",'B(),; x')", p4p )[ 0 ];
4941             if ( !p4.toNewHampshire().equals( "('A)','B(),; x');" ) ) {
4942                 return false;
4943             }
4944             final Phylogeny p10 = factory
4945                     .create( " [79]   ( (\"A \n\tB \" [co mment] :0 .2[comment],'B':0.3[com])[com ment]: 0. 5 \t[ 9 1 ][ comment],'C (or D?\\//;,))': 0.1)[comment]'\nroot is here (cool,  was! ) ':0.1[100] [comment]",
4946                              new NHXParser() )[ 0 ];
4947             final String p10_clean_str = "(('A B':0.2,B:0.3):0.5[&&NHX:B=91.0],'C (or D?\\//;,))':0.1)'root is here (cool,  was! )':0.1[&&NHX:B=100.0]";
4948             if ( !p10.toNewHampshireX().equals( p10_clean_str ) ) {
4949                 return false;
4950             }
4951             final Phylogeny p11 = factory.create( p10.toNewHampshireX(), new NHXParser() )[ 0 ];
4952             if ( !p11.toNewHampshireX().equals( p10_clean_str ) ) {
4953                 return false;
4954             }
4955             //
4956             final Phylogeny p12 = factory
4957                     .create( " [79]   ( (\"A \n\tB \" [[][] :0 .2[comment][\t&\t&\n N\tH\tX:S=mo\tnkey !],'\tB\t\b\t\n\f\rB B ':0.0\b3[])\t[com ment]: 0. 5 \t[ 9 1 ][ \ncomment],'C\t (or D?\\//;,))': 0.\b1)[comment]'\nroot \tis here (cool, \b\t\n\f\r was! ) ':0.1[100] [comment]",
4958                              new NHXParser() )[ 0 ];
4959             final String p12_clean_str = "(('A B':0.2[&&NHX:S=monkey!],'BB B':0.03):0.5[&&NHX:B=91.0],'C (or D?\\//;,))':0.1)'root is here (cool,  was! )':0.1[&&NHX:B=100.0]";
4960             if ( !p12.toNewHampshireX().equals( p12_clean_str ) ) {
4961                 return false;
4962             }
4963             final Phylogeny p13 = factory.create( p12.toNewHampshireX(), new NHXParser() )[ 0 ];
4964             if ( !p13.toNewHampshireX().equals( p12_clean_str ) ) {
4965                 return false;
4966             }
4967             final String p12_clean_str_nh = "(('A B':0.2,'BB B':0.03):0.5,'C (or D?\\//;,))':0.1)'root is here (cool,  was! )':0.1;";
4968             if ( !p13.toNewHampshire().equals( p12_clean_str_nh ) ) {
4969                 return false;
4970             }
4971             final Phylogeny p14 = factory.create( p13.toNewHampshire(), new NHXParser() )[ 0 ];
4972             if ( !p14.toNewHampshire().equals( p12_clean_str_nh ) ) {
4973                 return false;
4974             }
4975         }
4976         catch ( final Exception e ) {
4977             e.printStackTrace( System.out );
4978             return false;
4979         }
4980         return true;
4981     }
4982
4983     private static boolean testPhylogenyBranch() {
4984         try {
4985             final PhylogenyNode a1 = new PhylogenyNode( "a" );
4986             final PhylogenyNode b1 = new PhylogenyNode( "b" );
4987             final PhylogenyBranch a1b1 = new PhylogenyBranch( a1, b1 );
4988             final PhylogenyBranch b1a1 = new PhylogenyBranch( b1, a1 );
4989             if ( !a1b1.equals( a1b1 ) ) {
4990                 return false;
4991             }
4992             if ( !a1b1.equals( b1a1 ) ) {
4993                 return false;
4994             }
4995             if ( !b1a1.equals( a1b1 ) ) {
4996                 return false;
4997             }
4998             final PhylogenyBranch a1_b1 = new PhylogenyBranch( a1, b1, true );
4999             final PhylogenyBranch b1_a1 = new PhylogenyBranch( b1, a1, true );
5000             final PhylogenyBranch a1_b1_ = new PhylogenyBranch( a1, b1, false );
5001             if ( a1_b1.equals( b1_a1 ) ) {
5002                 return false;
5003             }
5004             if ( a1_b1.equals( a1_b1_ ) ) {
5005                 return false;
5006             }
5007             final PhylogenyBranch b1_a1_ = new PhylogenyBranch( b1, a1, false );
5008             if ( !a1_b1.equals( b1_a1_ ) ) {
5009                 return false;
5010             }
5011             if ( a1_b1_.equals( b1_a1_ ) ) {
5012                 return false;
5013             }
5014             if ( !a1_b1_.equals( b1_a1 ) ) {
5015                 return false;
5016             }
5017         }
5018         catch ( final Exception e ) {
5019             e.printStackTrace( System.out );
5020             return false;
5021         }
5022         return true;
5023     }
5024
5025     private static boolean testPhyloXMLparsingOfDistributionElement() {
5026         try {
5027             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
5028             PhyloXmlParser xml_parser = null;
5029             try {
5030                 xml_parser = PhyloXmlParser.createPhyloXmlParserXsdValidating();
5031             }
5032             catch ( final Exception e ) {
5033                 // Do nothing -- means were not running from jar.
5034             }
5035             if ( xml_parser == null ) {
5036                 xml_parser = new PhyloXmlParser();
5037                 if ( USE_LOCAL_PHYLOXML_SCHEMA ) {
5038                     xml_parser.setValidateAgainstSchema( PHYLOXML_LOCAL_XSD );
5039                 }
5040                 else {
5041                     xml_parser.setValidateAgainstSchema( PHYLOXML_REMOTE_XSD );
5042                 }
5043             }
5044             final Phylogeny[] phylogenies_0 = factory.create( Test.PATH_TO_TEST_DATA + "phyloxml_distribution.xml",
5045                                                               xml_parser );
5046             if ( xml_parser.getErrorCount() > 0 ) {
5047                 System.out.println( xml_parser.getErrorMessages().toString() );
5048                 return false;
5049             }
5050             if ( phylogenies_0.length != 1 ) {
5051                 return false;
5052             }
5053             final Phylogeny t1 = phylogenies_0[ 0 ];
5054             PhylogenyNode n = null;
5055             Distribution d = null;
5056             n = t1.getNode( "root node" );
5057             if ( !n.getNodeData().isHasDistribution() ) {
5058                 return false;
5059             }
5060             if ( n.getNodeData().getDistributions().size() != 1 ) {
5061                 return false;
5062             }
5063             d = n.getNodeData().getDistribution();
5064             if ( !d.getDesc().equals( "Hirschweg 38" ) ) {
5065                 return false;
5066             }
5067             if ( d.getPoints().size() != 1 ) {
5068                 return false;
5069             }
5070             if ( d.getPolygons() != null ) {
5071                 return false;
5072             }
5073             if ( !d.getPoints().get( 0 ).getAltitude().toString().equals( "472" ) ) {
5074                 return false;
5075             }
5076             if ( !d.getPoints().get( 0 ).getAltiudeUnit().equals( "m" ) ) {
5077                 return false;
5078             }
5079             if ( !d.getPoints().get( 0 ).getGeodeticDatum().equals( "WGS84" ) ) {
5080                 return false;
5081             }
5082             if ( !d.getPoints().get( 0 ).getLatitude().toString().equals( "47.48148427110029" ) ) {
5083                 return false;
5084             }
5085             if ( !d.getPoints().get( 0 ).getLongitude().toString().equals( "8.768951296806335" ) ) {
5086                 return false;
5087             }
5088             n = t1.getNode( "node a" );
5089             if ( !n.getNodeData().isHasDistribution() ) {
5090                 return false;
5091             }
5092             if ( n.getNodeData().getDistributions().size() != 2 ) {
5093                 return false;
5094             }
5095             d = n.getNodeData().getDistribution( 1 );
5096             if ( !d.getDesc().equals( "San Diego" ) ) {
5097                 return false;
5098             }
5099             if ( d.getPoints().size() != 1 ) {
5100                 return false;
5101             }
5102             if ( d.getPolygons() != null ) {
5103                 return false;
5104             }
5105             if ( !d.getPoints().get( 0 ).getAltitude().toString().equals( "104" ) ) {
5106                 return false;
5107             }
5108             if ( !d.getPoints().get( 0 ).getAltiudeUnit().equals( "m" ) ) {
5109                 return false;
5110             }
5111             if ( !d.getPoints().get( 0 ).getGeodeticDatum().equals( "WGS84" ) ) {
5112                 return false;
5113             }
5114             if ( !d.getPoints().get( 0 ).getLatitude().toString().equals( "32.880933" ) ) {
5115                 return false;
5116             }
5117             if ( !d.getPoints().get( 0 ).getLongitude().toString().equals( "-117.217543" ) ) {
5118                 return false;
5119             }
5120             n = t1.getNode( "node bb" );
5121             if ( !n.getNodeData().isHasDistribution() ) {
5122                 return false;
5123             }
5124             if ( n.getNodeData().getDistributions().size() != 1 ) {
5125                 return false;
5126             }
5127             d = n.getNodeData().getDistribution( 0 );
5128             if ( d.getPoints().size() != 3 ) {
5129                 return false;
5130             }
5131             if ( d.getPolygons().size() != 2 ) {
5132                 return false;
5133             }
5134             if ( !d.getPoints().get( 0 ).getLatitude().toString().equals( "1" ) ) {
5135                 return false;
5136             }
5137             if ( !d.getPoints().get( 0 ).getLongitude().toString().equals( "2" ) ) {
5138                 return false;
5139             }
5140             if ( !d.getPoints().get( 1 ).getLatitude().toString().equals( "3" ) ) {
5141                 return false;
5142             }
5143             if ( !d.getPoints().get( 1 ).getLongitude().toString().equals( "4" ) ) {
5144                 return false;
5145             }
5146             if ( !d.getPoints().get( 2 ).getLatitude().toString().equals( "5" ) ) {
5147                 return false;
5148             }
5149             if ( !d.getPoints().get( 2 ).getLongitude().toString().equals( "6" ) ) {
5150                 return false;
5151             }
5152             Polygon p = d.getPolygons().get( 0 );
5153             if ( p.getPoints().size() != 3 ) {
5154                 return false;
5155             }
5156             if ( !p.getPoints().get( 0 ).getLatitude().toString().equals( "0.1" ) ) {
5157                 return false;
5158             }
5159             if ( !p.getPoints().get( 0 ).getLongitude().toString().equals( "0.2" ) ) {
5160                 return false;
5161             }
5162             if ( !p.getPoints().get( 0 ).getAltitude().toString().equals( "10" ) ) {
5163                 return false;
5164             }
5165             if ( !p.getPoints().get( 2 ).getLatitude().toString().equals( "0.5" ) ) {
5166                 return false;
5167             }
5168             if ( !p.getPoints().get( 2 ).getLongitude().toString().equals( "0.6" ) ) {
5169                 return false;
5170             }
5171             if ( !p.getPoints().get( 2 ).getAltitude().toString().equals( "30" ) ) {
5172                 return false;
5173             }
5174             p = d.getPolygons().get( 1 );
5175             if ( p.getPoints().size() != 3 ) {
5176                 return false;
5177             }
5178             if ( !p.getPoints().get( 0 ).getLatitude().toString().equals( "1.49348902489947473" ) ) {
5179                 return false;
5180             }
5181             if ( !p.getPoints().get( 0 ).getLongitude().toString().equals( "2.567489393947847492" ) ) {
5182                 return false;
5183             }
5184             if ( !p.getPoints().get( 0 ).getAltitude().toString().equals( "10" ) ) {
5185                 return false;
5186             }
5187             // Roundtrip:
5188             final StringBuffer t1_sb = new StringBuffer( t1.toPhyloXML( 0 ) );
5189             final Phylogeny[] rt = factory.create( t1_sb, xml_parser );
5190             if ( rt.length != 1 ) {
5191                 return false;
5192             }
5193             final Phylogeny t1_rt = rt[ 0 ];
5194             n = t1_rt.getNode( "root node" );
5195             if ( !n.getNodeData().isHasDistribution() ) {
5196                 return false;
5197             }
5198             if ( n.getNodeData().getDistributions().size() != 1 ) {
5199                 return false;
5200             }
5201             d = n.getNodeData().getDistribution();
5202             if ( !d.getDesc().equals( "Hirschweg 38" ) ) {
5203                 return false;
5204             }
5205             if ( d.getPoints().size() != 1 ) {
5206                 return false;
5207             }
5208             if ( d.getPolygons() != null ) {
5209                 return false;
5210             }
5211             if ( !d.getPoints().get( 0 ).getAltitude().toString().equals( "472" ) ) {
5212                 return false;
5213             }
5214             if ( !d.getPoints().get( 0 ).getAltiudeUnit().equals( "m" ) ) {
5215                 return false;
5216             }
5217             if ( !d.getPoints().get( 0 ).getGeodeticDatum().equals( "WGS84" ) ) {
5218                 return false;
5219             }
5220             if ( !d.getPoints().get( 0 ).getLatitude().toString().equals( "47.48148427110029" ) ) {
5221                 return false;
5222             }
5223             if ( !d.getPoints().get( 0 ).getLongitude().toString().equals( "8.768951296806335" ) ) {
5224                 return false;
5225             }
5226             n = t1_rt.getNode( "node a" );
5227             if ( !n.getNodeData().isHasDistribution() ) {
5228                 return false;
5229             }
5230             if ( n.getNodeData().getDistributions().size() != 2 ) {
5231                 return false;
5232             }
5233             d = n.getNodeData().getDistribution( 1 );
5234             if ( !d.getDesc().equals( "San Diego" ) ) {
5235                 return false;
5236             }
5237             if ( d.getPoints().size() != 1 ) {
5238                 return false;
5239             }
5240             if ( d.getPolygons() != null ) {
5241                 return false;
5242             }
5243             if ( !d.getPoints().get( 0 ).getAltitude().toString().equals( "104" ) ) {
5244                 return false;
5245             }
5246             if ( !d.getPoints().get( 0 ).getAltiudeUnit().equals( "m" ) ) {
5247                 return false;
5248             }
5249             if ( !d.getPoints().get( 0 ).getGeodeticDatum().equals( "WGS84" ) ) {
5250                 return false;
5251             }
5252             if ( !d.getPoints().get( 0 ).getLatitude().toString().equals( "32.880933" ) ) {
5253                 return false;
5254             }
5255             if ( !d.getPoints().get( 0 ).getLongitude().toString().equals( "-117.217543" ) ) {
5256                 return false;
5257             }
5258             n = t1_rt.getNode( "node bb" );
5259             if ( !n.getNodeData().isHasDistribution() ) {
5260                 return false;
5261             }
5262             if ( n.getNodeData().getDistributions().size() != 1 ) {
5263                 return false;
5264             }
5265             d = n.getNodeData().getDistribution( 0 );
5266             if ( d.getPoints().size() != 3 ) {
5267                 return false;
5268             }
5269             if ( d.getPolygons().size() != 2 ) {
5270                 return false;
5271             }
5272             if ( !d.getPoints().get( 0 ).getLatitude().toString().equals( "1" ) ) {
5273                 return false;
5274             }
5275             if ( !d.getPoints().get( 0 ).getLongitude().toString().equals( "2" ) ) {
5276                 return false;
5277             }
5278             if ( !d.getPoints().get( 1 ).getLatitude().toString().equals( "3" ) ) {
5279                 return false;
5280             }
5281             if ( !d.getPoints().get( 1 ).getLongitude().toString().equals( "4" ) ) {
5282                 return false;
5283             }
5284             if ( !d.getPoints().get( 2 ).getLatitude().toString().equals( "5" ) ) {
5285                 return false;
5286             }
5287             if ( !d.getPoints().get( 2 ).getLongitude().toString().equals( "6" ) ) {
5288                 return false;
5289             }
5290             p = d.getPolygons().get( 0 );
5291             if ( p.getPoints().size() != 3 ) {
5292                 return false;
5293             }
5294             if ( !p.getPoints().get( 0 ).getLatitude().toString().equals( "0.1" ) ) {
5295                 return false;
5296             }
5297             if ( !p.getPoints().get( 0 ).getLongitude().toString().equals( "0.2" ) ) {
5298                 return false;
5299             }
5300             if ( !p.getPoints().get( 0 ).getAltitude().toString().equals( "10" ) ) {
5301                 return false;
5302             }
5303             if ( !p.getPoints().get( 2 ).getLatitude().toString().equals( "0.5" ) ) {
5304                 return false;
5305             }
5306             if ( !p.getPoints().get( 2 ).getLongitude().toString().equals( "0.6" ) ) {
5307                 return false;
5308             }
5309             if ( !p.getPoints().get( 2 ).getAltitude().toString().equals( "30" ) ) {
5310                 return false;
5311             }
5312             p = d.getPolygons().get( 1 );
5313             if ( p.getPoints().size() != 3 ) {
5314                 return false;
5315             }
5316             if ( !p.getPoints().get( 0 ).getLatitude().toString().equals( "1.49348902489947473" ) ) {
5317                 return false;
5318             }
5319             if ( !p.getPoints().get( 0 ).getLongitude().toString().equals( "2.567489393947847492" ) ) {
5320                 return false;
5321             }
5322             if ( !p.getPoints().get( 0 ).getAltitude().toString().equals( "10" ) ) {
5323                 return false;
5324             }
5325         }
5326         catch ( final Exception e ) {
5327             e.printStackTrace( System.out );
5328             return false;
5329         }
5330         return true;
5331     }
5332
5333     private static boolean testPostOrderIterator() {
5334         try {
5335             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
5336             final Phylogeny t0 = factory.create( "((A,B)ab,(C,D)cd)r", new NHXParser() )[ 0 ];
5337             PhylogenyNodeIterator it0;
5338             for( it0 = t0.iteratorPostorder(); it0.hasNext(); ) {
5339                 it0.next();
5340             }
5341             for( it0.reset(); it0.hasNext(); ) {
5342                 it0.next();
5343             }
5344             final Phylogeny t1 = factory.create( "(((A,B)ab,(C,D)cd)abcd,((E,F)ef,(G,H)gh)efgh)r", new NHXParser() )[ 0 ];
5345             final PhylogenyNodeIterator it = t1.iteratorPostorder();
5346             if ( !it.next().getName().equals( "A" ) ) {
5347                 return false;
5348             }
5349             if ( !it.next().getName().equals( "B" ) ) {
5350                 return false;
5351             }
5352             if ( !it.next().getName().equals( "ab" ) ) {
5353                 return false;
5354             }
5355             if ( !it.next().getName().equals( "C" ) ) {
5356                 return false;
5357             }
5358             if ( !it.next().getName().equals( "D" ) ) {
5359                 return false;
5360             }
5361             if ( !it.next().getName().equals( "cd" ) ) {
5362                 return false;
5363             }
5364             if ( !it.next().getName().equals( "abcd" ) ) {
5365                 return false;
5366             }
5367             if ( !it.next().getName().equals( "E" ) ) {
5368                 return false;
5369             }
5370             if ( !it.next().getName().equals( "F" ) ) {
5371                 return false;
5372             }
5373             if ( !it.next().getName().equals( "ef" ) ) {
5374                 return false;
5375             }
5376             if ( !it.next().getName().equals( "G" ) ) {
5377                 return false;
5378             }
5379             if ( !it.next().getName().equals( "H" ) ) {
5380                 return false;
5381             }
5382             if ( !it.next().getName().equals( "gh" ) ) {
5383                 return false;
5384             }
5385             if ( !it.next().getName().equals( "efgh" ) ) {
5386                 return false;
5387             }
5388             if ( !it.next().getName().equals( "r" ) ) {
5389                 return false;
5390             }
5391             if ( it.hasNext() ) {
5392                 return false;
5393             }
5394         }
5395         catch ( final Exception e ) {
5396             e.printStackTrace( System.out );
5397             return false;
5398         }
5399         return true;
5400     }
5401
5402     private static boolean testPreOrderIterator() {
5403         try {
5404             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
5405             final Phylogeny t0 = factory.create( "((A,B)ab,(C,D)cd)r", new NHXParser() )[ 0 ];
5406             PhylogenyNodeIterator it0;
5407             for( it0 = t0.iteratorPreorder(); it0.hasNext(); ) {
5408                 it0.next();
5409             }
5410             for( it0.reset(); it0.hasNext(); ) {
5411                 it0.next();
5412             }
5413             PhylogenyNodeIterator it = t0.iteratorPreorder();
5414             if ( !it.next().getName().equals( "r" ) ) {
5415                 return false;
5416             }
5417             if ( !it.next().getName().equals( "ab" ) ) {
5418                 return false;
5419             }
5420             if ( !it.next().getName().equals( "A" ) ) {
5421                 return false;
5422             }
5423             if ( !it.next().getName().equals( "B" ) ) {
5424                 return false;
5425             }
5426             if ( !it.next().getName().equals( "cd" ) ) {
5427                 return false;
5428             }
5429             if ( !it.next().getName().equals( "C" ) ) {
5430                 return false;
5431             }
5432             if ( !it.next().getName().equals( "D" ) ) {
5433                 return false;
5434             }
5435             if ( it.hasNext() ) {
5436                 return false;
5437             }
5438             final Phylogeny t1 = factory.create( "(((A,B)ab,(C,D)cd)abcd,((E,F)ef,(G,H)gh)efgh)r", new NHXParser() )[ 0 ];
5439             it = t1.iteratorPreorder();
5440             if ( !it.next().getName().equals( "r" ) ) {
5441                 return false;
5442             }
5443             if ( !it.next().getName().equals( "abcd" ) ) {
5444                 return false;
5445             }
5446             if ( !it.next().getName().equals( "ab" ) ) {
5447                 return false;
5448             }
5449             if ( !it.next().getName().equals( "A" ) ) {
5450                 return false;
5451             }
5452             if ( !it.next().getName().equals( "B" ) ) {
5453                 return false;
5454             }
5455             if ( !it.next().getName().equals( "cd" ) ) {
5456                 return false;
5457             }
5458             if ( !it.next().getName().equals( "C" ) ) {
5459                 return false;
5460             }
5461             if ( !it.next().getName().equals( "D" ) ) {
5462                 return false;
5463             }
5464             if ( !it.next().getName().equals( "efgh" ) ) {
5465                 return false;
5466             }
5467             if ( !it.next().getName().equals( "ef" ) ) {
5468                 return false;
5469             }
5470             if ( !it.next().getName().equals( "E" ) ) {
5471                 return false;
5472             }
5473             if ( !it.next().getName().equals( "F" ) ) {
5474                 return false;
5475             }
5476             if ( !it.next().getName().equals( "gh" ) ) {
5477                 return false;
5478             }
5479             if ( !it.next().getName().equals( "G" ) ) {
5480                 return false;
5481             }
5482             if ( !it.next().getName().equals( "H" ) ) {
5483                 return false;
5484             }
5485             if ( it.hasNext() ) {
5486                 return false;
5487             }
5488         }
5489         catch ( final Exception e ) {
5490             e.printStackTrace( System.out );
5491             return false;
5492         }
5493         return true;
5494     }
5495
5496     private static boolean testPropertiesMap() {
5497         try {
5498             final PropertiesMap pm = new PropertiesMap();
5499             final Property p0 = new Property( "dimensions:diameter", "1", "metric:mm", "xsd:decimal", AppliesTo.NODE );
5500             final Property p1 = new Property( "dimensions:length", "2", "metric:mm", "xsd:decimal", AppliesTo.NODE );
5501             final Property p2 = new Property( "something:else",
5502                                               "?",
5503                                               "improbable:research",
5504                                               "xsd:decimal",
5505                                               AppliesTo.NODE );
5506             pm.addProperty( p0 );
5507             pm.addProperty( p1 );
5508             pm.addProperty( p2 );
5509             if ( !pm.getProperty( "dimensions:diameter" ).getValue().equals( "1" ) ) {
5510                 return false;
5511             }
5512             if ( !pm.getProperty( "dimensions:length" ).getValue().equals( "2" ) ) {
5513                 return false;
5514             }
5515             if ( pm.getProperties().size() != 3 ) {
5516                 return false;
5517             }
5518             if ( pm.getPropertiesWithGivenReferencePrefix( "dimensions" ).size() != 2 ) {
5519                 return false;
5520             }
5521             if ( pm.getPropertiesWithGivenReferencePrefix( "something" ).size() != 1 ) {
5522                 return false;
5523             }
5524             if ( pm.getProperties().size() != 3 ) {
5525                 return false;
5526             }
5527             pm.removeProperty( "dimensions:diameter" );
5528             if ( pm.getProperties().size() != 2 ) {
5529                 return false;
5530             }
5531             if ( pm.getPropertiesWithGivenReferencePrefix( "dimensions" ).size() != 1 ) {
5532                 return false;
5533             }
5534             if ( pm.getPropertiesWithGivenReferencePrefix( "something" ).size() != 1 ) {
5535                 return false;
5536             }
5537         }
5538         catch ( final Exception e ) {
5539             e.printStackTrace( System.out );
5540             return false;
5541         }
5542         return true;
5543     }
5544
5545     private static boolean testReIdMethods() {
5546         try {
5547             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
5548             final Phylogeny p = factory.create( "((1,2)A,(((X,Y,Z)a,b)3)B,(4,5,6)C)r", new NHXParser() )[ 0 ];
5549             final int count = PhylogenyNode.getNodeCount();
5550             p.levelOrderReID();
5551             if ( p.getNode( "r" ).getId() != count ) {
5552                 return false;
5553             }
5554             if ( p.getNode( "A" ).getId() != count + 1 ) {
5555                 return false;
5556             }
5557             if ( p.getNode( "B" ).getId() != count + 1 ) {
5558                 return false;
5559             }
5560             if ( p.getNode( "C" ).getId() != count + 1 ) {
5561                 return false;
5562             }
5563             if ( p.getNode( "1" ).getId() != count + 2 ) {
5564                 return false;
5565             }
5566             if ( p.getNode( "2" ).getId() != count + 2 ) {
5567                 return false;
5568             }
5569             if ( p.getNode( "3" ).getId() != count + 2 ) {
5570                 return false;
5571             }
5572             if ( p.getNode( "4" ).getId() != count + 2 ) {
5573                 return false;
5574             }
5575             if ( p.getNode( "5" ).getId() != count + 2 ) {
5576                 return false;
5577             }
5578             if ( p.getNode( "6" ).getId() != count + 2 ) {
5579                 return false;
5580             }
5581             if ( p.getNode( "a" ).getId() != count + 3 ) {
5582                 return false;
5583             }
5584             if ( p.getNode( "b" ).getId() != count + 3 ) {
5585                 return false;
5586             }
5587             if ( p.getNode( "X" ).getId() != count + 4 ) {
5588                 return false;
5589             }
5590             if ( p.getNode( "Y" ).getId() != count + 4 ) {
5591                 return false;
5592             }
5593             if ( p.getNode( "Z" ).getId() != count + 4 ) {
5594                 return false;
5595             }
5596         }
5597         catch ( final Exception e ) {
5598             e.printStackTrace( System.out );
5599             return false;
5600         }
5601         return true;
5602     }
5603
5604     private static boolean testRerooting() {
5605         try {
5606             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
5607             final Phylogeny t1 = factory.create( "((A:1,B:2)AB:1[&&NHX:B=55],(C:3,D:5)CD:3[&&NHX:B=10])ABCD:0.5",
5608                                                  new NHXParser() )[ 0 ];
5609             if ( !t1.isRooted() ) {
5610                 return false;
5611             }
5612             t1.reRoot( t1.getNode( "D" ) );
5613             t1.reRoot( t1.getNode( "CD" ) );
5614             t1.reRoot( t1.getNode( "A" ) );
5615             t1.reRoot( t1.getNode( "B" ) );
5616             t1.reRoot( t1.getNode( "AB" ) );
5617             t1.reRoot( t1.getNode( "D" ) );
5618             t1.reRoot( t1.getNode( "C" ) );
5619             t1.reRoot( t1.getNode( "CD" ) );
5620             t1.reRoot( t1.getNode( "A" ) );
5621             t1.reRoot( t1.getNode( "B" ) );
5622             t1.reRoot( t1.getNode( "AB" ) );
5623             t1.reRoot( t1.getNode( "D" ) );
5624             t1.reRoot( t1.getNode( "D" ) );
5625             t1.reRoot( t1.getNode( "C" ) );
5626             t1.reRoot( t1.getNode( "A" ) );
5627             t1.reRoot( t1.getNode( "B" ) );
5628             t1.reRoot( t1.getNode( "AB" ) );
5629             t1.reRoot( t1.getNode( "C" ) );
5630             t1.reRoot( t1.getNode( "D" ) );
5631             t1.reRoot( t1.getNode( "CD" ) );
5632             t1.reRoot( t1.getNode( "D" ) );
5633             t1.reRoot( t1.getNode( "A" ) );
5634             t1.reRoot( t1.getNode( "B" ) );
5635             t1.reRoot( t1.getNode( "AB" ) );
5636             t1.reRoot( t1.getNode( "C" ) );
5637             t1.reRoot( t1.getNode( "D" ) );
5638             t1.reRoot( t1.getNode( "CD" ) );
5639             t1.reRoot( t1.getNode( "D" ) );
5640             if ( !isEqual( t1.getNode( "A" ).getDistanceToParent(), 1 ) ) {
5641                 return false;
5642             }
5643             if ( !isEqual( t1.getNode( "B" ).getDistanceToParent(), 2 ) ) {
5644                 return false;
5645             }
5646             if ( !isEqual( t1.getNode( "C" ).getDistanceToParent(), 3 ) ) {
5647                 return false;
5648             }
5649             if ( !isEqual( t1.getNode( "D" ).getDistanceToParent(), 2.5 ) ) {
5650                 return false;
5651             }
5652             if ( !isEqual( t1.getNode( "CD" ).getDistanceToParent(), 2.5 ) ) {
5653                 return false;
5654             }
5655             if ( !isEqual( t1.getNode( "AB" ).getDistanceToParent(), 4 ) ) {
5656                 return false;
5657             }
5658             final Phylogeny t2 = factory.create( "(((A:1,B:2)AB:10[&&NHX:B=55],C)ABC:3[&&NHX:B=33],D:5)ABCD:0.5",
5659                                                  new NHXParser() )[ 0 ];
5660             t2.reRoot( t2.getNode( "A" ) );
5661             t2.reRoot( t2.getNode( "D" ) );
5662             t2.reRoot( t2.getNode( "ABC" ) );
5663             t2.reRoot( t2.getNode( "A" ) );
5664             t2.reRoot( t2.getNode( "B" ) );
5665             t2.reRoot( t2.getNode( "D" ) );
5666             t2.reRoot( t2.getNode( "C" ) );
5667             t2.reRoot( t2.getNode( "ABC" ) );
5668             t2.reRoot( t2.getNode( "A" ) );
5669             t2.reRoot( t2.getNode( "B" ) );
5670             t2.reRoot( t2.getNode( "AB" ) );
5671             t2.reRoot( t2.getNode( "AB" ) );
5672             t2.reRoot( t2.getNode( "D" ) );
5673             t2.reRoot( t2.getNode( "C" ) );
5674             t2.reRoot( t2.getNode( "B" ) );
5675             t2.reRoot( t2.getNode( "AB" ) );
5676             t2.reRoot( t2.getNode( "D" ) );
5677             t2.reRoot( t2.getNode( "D" ) );
5678             t2.reRoot( t2.getNode( "ABC" ) );
5679             t2.reRoot( t2.getNode( "A" ) );
5680             t2.reRoot( t2.getNode( "B" ) );
5681             t2.reRoot( t2.getNode( "AB" ) );
5682             t2.reRoot( t2.getNode( "D" ) );
5683             t2.reRoot( t2.getNode( "C" ) );
5684             t2.reRoot( t2.getNode( "ABC" ) );
5685             t2.reRoot( t2.getNode( "A" ) );
5686             t2.reRoot( t2.getNode( "B" ) );
5687             t2.reRoot( t2.getNode( "AB" ) );
5688             t2.reRoot( t2.getNode( "D" ) );
5689             t2.reRoot( t2.getNode( "D" ) );
5690             t2.reRoot( t2.getNode( "C" ) );
5691             t2.reRoot( t2.getNode( "A" ) );
5692             t2.reRoot( t2.getNode( "B" ) );
5693             t2.reRoot( t2.getNode( "AB" ) );
5694             t2.reRoot( t2.getNode( "C" ) );
5695             t2.reRoot( t2.getNode( "D" ) );
5696             t2.reRoot( t2.getNode( "ABC" ) );
5697             t2.reRoot( t2.getNode( "D" ) );
5698             t2.reRoot( t2.getNode( "A" ) );
5699             t2.reRoot( t2.getNode( "B" ) );
5700             t2.reRoot( t2.getNode( "AB" ) );
5701             t2.reRoot( t2.getNode( "C" ) );
5702             t2.reRoot( t2.getNode( "D" ) );
5703             t2.reRoot( t2.getNode( "ABC" ) );
5704             t2.reRoot( t2.getNode( "D" ) );
5705             if ( !isEqual( t2.getNode( "AB" ).getBranchData().getConfidence( 0 ).getValue(), 55 ) ) {
5706                 return false;
5707             }
5708             if ( !isEqual( t2.getNode( "ABC" ).getBranchData().getConfidence( 0 ).getValue(), 33 ) ) {
5709                 return false;
5710             }
5711             t2.reRoot( t2.getNode( "ABC" ) );
5712             if ( !isEqual( t2.getNode( "AB" ).getBranchData().getConfidence( 0 ).getValue(), 55 ) ) {
5713                 return false;
5714             }
5715             if ( !isEqual( t2.getNode( "ABC" ).getBranchData().getConfidence( 0 ).getValue(), 33 ) ) {
5716                 return false;
5717             }
5718             t2.reRoot( t2.getNode( "AB" ) );
5719             if ( !isEqual( t2.getNode( "AB" ).getBranchData().getConfidence( 0 ).getValue(), 55 ) ) {
5720                 return false;
5721             }
5722             if ( !isEqual( t2.getNode( "ABC" ).getBranchData().getConfidence( 0 ).getValue(), 55 ) ) {
5723                 return false;
5724             }
5725             if ( !isEqual( t2.getNode( "D" ).getBranchData().getConfidence( 0 ).getValue(), 33 ) ) {
5726                 return false;
5727             }
5728             t2.reRoot( t2.getNode( "AB" ) );
5729             if ( !isEqual( t2.getNode( "AB" ).getBranchData().getConfidence( 0 ).getValue(), 55 ) ) {
5730                 return false;
5731             }
5732             if ( !isEqual( t2.getNode( "ABC" ).getBranchData().getConfidence( 0 ).getValue(), 55 ) ) {
5733                 return false;
5734             }
5735             if ( !isEqual( t2.getNode( "D" ).getBranchData().getConfidence( 0 ).getValue(), 33 ) ) {
5736                 return false;
5737             }
5738             t2.reRoot( t2.getNode( "D" ) );
5739             if ( !isEqual( t2.getNode( "AB" ).getBranchData().getConfidence( 0 ).getValue(), 55 ) ) {
5740                 return false;
5741             }
5742             if ( !isEqual( t2.getNode( "ABC" ).getBranchData().getConfidence( 0 ).getValue(), 33 ) ) {
5743                 return false;
5744             }
5745             t2.reRoot( t2.getNode( "ABC" ) );
5746             if ( !isEqual( t2.getNode( "AB" ).getBranchData().getConfidence( 0 ).getValue(), 55 ) ) {
5747                 return false;
5748             }
5749             if ( !isEqual( t2.getNode( "ABC" ).getBranchData().getConfidence( 0 ).getValue(), 33 ) ) {
5750                 return false;
5751             }
5752             final Phylogeny t3 = factory.create( "(A[&&NHX:B=10],B[&&NHX:B=20],C[&&NHX:B=30],D[&&NHX:B=40])",
5753                                                  new NHXParser() )[ 0 ];
5754             t3.reRoot( t3.getNode( "B" ) );
5755             if ( t3.getNode( "B" ).getBranchData().getConfidence( 0 ).getValue() != 20 ) {
5756                 return false;
5757             }
5758             if ( t3.getNode( "A" ).getParent().getBranchData().getConfidence( 0 ).getValue() != 20 ) {
5759                 return false;
5760             }
5761             if ( t3.getNode( "A" ).getParent().getNumberOfDescendants() != 3 ) {
5762                 return false;
5763             }
5764             t3.reRoot( t3.getNode( "B" ) );
5765             if ( t3.getNode( "B" ).getBranchData().getConfidence( 0 ).getValue() != 20 ) {
5766                 return false;
5767             }
5768             if ( t3.getNode( "A" ).getParent().getBranchData().getConfidence( 0 ).getValue() != 20 ) {
5769                 return false;
5770             }
5771             if ( t3.getNode( "A" ).getParent().getNumberOfDescendants() != 3 ) {
5772                 return false;
5773             }
5774             t3.reRoot( t3.getRoot() );
5775             if ( t3.getNode( "B" ).getBranchData().getConfidence( 0 ).getValue() != 20 ) {
5776                 return false;
5777             }
5778             if ( t3.getNode( "A" ).getParent().getBranchData().getConfidence( 0 ).getValue() != 20 ) {
5779                 return false;
5780             }
5781             if ( t3.getNode( "A" ).getParent().getNumberOfDescendants() != 3 ) {
5782                 return false;
5783             }
5784         }
5785         catch ( final Exception e ) {
5786             e.printStackTrace( System.out );
5787             return false;
5788         }
5789         return true;
5790     }
5791
5792     private static boolean testSDIse() {
5793         try {
5794             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
5795             final Phylogeny species1 = factory.create( "[&&NHX:S=yeast]", new NHXParser() )[ 0 ];
5796             final Phylogeny gene1 = factory.create( "(A1[&&NHX:S=yeast],A2[&&NHX:S=yeast])", new NHXParser() )[ 0 ];
5797             gene1.setRooted( true );
5798             species1.setRooted( true );
5799             final SDI sdi = new SDIse( gene1, species1 );
5800             if ( !gene1.getRoot().isDuplication() ) {
5801                 return false;
5802             }
5803             final Phylogeny species2 = factory
5804                     .create( "(((([&&NHX:S=A],[&&NHX:S=B]),[&&NHX:S=C]),[&&NHX:S=D]),([&&NHX:S=E],[&&NHX:S=F]))",
5805                              new NHXParser() )[ 0 ];
5806             final Phylogeny gene2 = factory
5807                     .create( "(((([&&NHX:S=A],[&&NHX:S=B])ab,[&&NHX:S=C])abc,[&&NHX:S=D])abcd,([&&NHX:S=E],[&&NHX:S=F])ef)r",
5808                              new NHXParser() )[ 0 ];
5809             species2.setRooted( true );
5810             gene2.setRooted( true );
5811             final SDI sdi2 = new SDIse( gene2, species2 );
5812             if ( sdi2.getDuplicationsSum() != 0 ) {
5813                 return false;
5814             }
5815             if ( !gene2.getNode( "ab" ).isSpeciation() ) {
5816                 return false;
5817             }
5818             if ( !gene2.getNode( "ab" ).isHasAssignedEvent() ) {
5819                 return false;
5820             }
5821             if ( !gene2.getNode( "abc" ).isSpeciation() ) {
5822                 return false;
5823             }
5824             if ( !gene2.getNode( "abc" ).isHasAssignedEvent() ) {
5825                 return false;
5826             }
5827             if ( !gene2.getNode( "r" ).isSpeciation() ) {
5828                 return false;
5829             }
5830             if ( !gene2.getNode( "r" ).isHasAssignedEvent() ) {
5831                 return false;
5832             }
5833             final Phylogeny species3 = factory
5834                     .create( "(((([&&NHX:S=A],[&&NHX:S=B]),[&&NHX:S=C]),[&&NHX:S=D]),([&&NHX:S=E],[&&NHX:S=F]))",
5835                              new NHXParser() )[ 0 ];
5836             final Phylogeny gene3 = factory
5837                     .create( "(((([&&NHX:S=A],[&&NHX:S=A])aa,[&&NHX:S=C])abc,[&&NHX:S=D])abcd,([&&NHX:S=E],[&&NHX:S=F])ef)r",
5838                              new NHXParser() )[ 0 ];
5839             species3.setRooted( true );
5840             gene3.setRooted( true );
5841             final SDI sdi3 = new SDIse( gene3, species3 );
5842             if ( sdi3.getDuplicationsSum() != 1 ) {
5843                 return false;
5844             }
5845             if ( !gene3.getNode( "aa" ).isDuplication() ) {
5846                 return false;
5847             }
5848             if ( !gene3.getNode( "aa" ).isHasAssignedEvent() ) {
5849                 return false;
5850             }
5851             final Phylogeny species4 = factory
5852                     .create( "(((([&&NHX:S=A],[&&NHX:S=B]),[&&NHX:S=C]),[&&NHX:S=D]),([&&NHX:S=E],[&&NHX:S=F]))",
5853                              new NHXParser() )[ 0 ];
5854             final Phylogeny gene4 = factory
5855                     .create( "(((([&&NHX:S=A],[&&NHX:S=C])ac,[&&NHX:S=B])abc,[&&NHX:S=D])abcd,([&&NHX:S=E],[&&NHX:S=F])ef)r",
5856                              new NHXParser() )[ 0 ];
5857             species4.setRooted( true );
5858             gene4.setRooted( true );
5859             final SDI sdi4 = new SDIse( gene4, species4 );
5860             if ( sdi4.getDuplicationsSum() != 1 ) {
5861                 return false;
5862             }
5863             if ( !gene4.getNode( "ac" ).isSpeciation() ) {
5864                 return false;
5865             }
5866             if ( !gene4.getNode( "abc" ).isDuplication() ) {
5867                 return false;
5868             }
5869             if ( gene4.getNode( "abcd" ).isDuplication() ) {
5870                 return false;
5871             }
5872             if ( species4.getNumberOfExternalNodes() != 6 ) {
5873                 return false;
5874             }
5875             if ( gene4.getNumberOfExternalNodes() != 6 ) {
5876                 return false;
5877             }
5878             final Phylogeny species5 = factory
5879                     .create( "(((([&&NHX:S=A],[&&NHX:S=B]),[&&NHX:S=C]),[&&NHX:S=D]),([&&NHX:S=E],[&&NHX:S=F]))",
5880                              new NHXParser() )[ 0 ];
5881             final Phylogeny gene5 = factory
5882                     .create( "(((([&&NHX:S=A],[&&NHX:S=D])ad,[&&NHX:S=C])adc,[&&NHX:S=B])abcd,([&&NHX:S=E],[&&NHX:S=F])ef)r",
5883                              new NHXParser() )[ 0 ];
5884             species5.setRooted( true );
5885             gene5.setRooted( true );
5886             final SDI sdi5 = new SDIse( gene5, species5 );
5887             if ( sdi5.getDuplicationsSum() != 2 ) {
5888                 return false;
5889             }
5890             if ( !gene5.getNode( "ad" ).isSpeciation() ) {
5891                 return false;
5892             }
5893             if ( !gene5.getNode( "adc" ).isDuplication() ) {
5894                 return false;
5895             }
5896             if ( !gene5.getNode( "abcd" ).isDuplication() ) {
5897                 return false;
5898             }
5899             if ( species5.getNumberOfExternalNodes() != 6 ) {
5900                 return false;
5901             }
5902             if ( gene5.getNumberOfExternalNodes() != 6 ) {
5903                 return false;
5904             }
5905             // Trees from Louxin Zhang 1997 "On a Mirkin-Muchnik-Smith
5906             // Conjecture for Comparing Molecular Phylogenies"
5907             // J. of Comput Bio. Vol. 4, No 2, pp.177-187
5908             final Phylogeny species6 = factory
5909                     .create( "(((1:[&&NHX:S=1],5:[&&NHX:S=5])1-5,((4:[&&NHX:S=4],6:[&&NHX:S=6])4-6,2:[&&NHX:S=2])4-6-2)1-5-4-6-2,"
5910                                      + "((9:[&&NHX:S=9],3:[&&NHX:S=3])9-3,(8:[&&NHX:S=8],7:[&&NHX:S=7])8-7)9-3-8-7)",
5911                              new NHXParser() )[ 0 ];
5912             final Phylogeny gene6 = factory
5913                     .create( "(((1:0.1[&&NHX:S=1],2:0.1[&&NHX:S=2])1-2:0.1,3:0.1[&&NHX:S=3])1-2-3:0.1,"
5914                                      + "((4:0.1[&&NHX:S=4],(5:0.1[&&NHX:S=5],6:0.1[&&NHX:S=6])5-6:0.1)4-5-6:0.1,"
5915                                      + "(7:0.1[&&NHX:S=7],(8:0.1[&&NHX:S=8],9:0.1[&&NHX:S=9])8-9:0.1)7-8-9:0.1)4-5-6-7-8-9:0.1)r;",
5916                              new NHXParser() )[ 0 ];
5917             species6.setRooted( true );
5918             gene6.setRooted( true );
5919             final SDI sdi6 = new SDIse( gene6, species6 );
5920             if ( sdi6.getDuplicationsSum() != 3 ) {
5921                 return false;
5922             }
5923             if ( !gene6.getNode( "r" ).isDuplication() ) {
5924                 return false;
5925             }
5926             if ( !gene6.getNode( "4-5-6" ).isDuplication() ) {
5927                 return false;
5928             }
5929             if ( !gene6.getNode( "7-8-9" ).isDuplication() ) {
5930                 return false;
5931             }
5932             if ( !gene6.getNode( "1-2" ).isSpeciation() ) {
5933                 return false;
5934             }
5935             if ( !gene6.getNode( "1-2-3" ).isSpeciation() ) {
5936                 return false;
5937             }
5938             if ( !gene6.getNode( "5-6" ).isSpeciation() ) {
5939                 return false;
5940             }
5941             if ( !gene6.getNode( "8-9" ).isSpeciation() ) {
5942                 return false;
5943             }
5944             if ( !gene6.getNode( "4-5-6-7-8-9" ).isSpeciation() ) {
5945                 return false;
5946             }
5947             sdi6.computeMappingCostL();
5948             if ( sdi6.computeMappingCostL() != 17 ) {
5949                 return false;
5950             }
5951             if ( species6.getNumberOfExternalNodes() != 9 ) {
5952                 return false;
5953             }
5954             if ( gene6.getNumberOfExternalNodes() != 9 ) {
5955                 return false;
5956             }
5957             final Phylogeny species7 = Test.createPhylogeny( "(((((((" + "([&&NHX:S=a1],[&&NHX:S=a2]),"
5958                     + "([&&NHX:S=b1],[&&NHX:S=b2])" + "),[&&NHX:S=x]),(" + "([&&NHX:S=m1],[&&NHX:S=m2]),"
5959                     + "([&&NHX:S=n1],[&&NHX:S=n2])" + ")),(" + "([&&NHX:S=i1],[&&NHX:S=i2]),"
5960                     + "([&&NHX:S=j1],[&&NHX:S=j2])" + ")),(" + "([&&NHX:S=e1],[&&NHX:S=e2]),"
5961                     + "([&&NHX:S=f1],[&&NHX:S=f2])" + ")),[&&NHX:S=y]),[&&NHX:S=z])" );
5962             species7.setRooted( true );
5963             final Phylogeny gene7_1 = Test
5964                     .createPhylogeny( "((((((((a1[&&NHX:S=a1],a2[&&NHX:S=a2]),b1[&&NHX:S=b1]),x[&&NHX:S=x]),m1[&&NHX:S=m1]),i1[&&NHX:S=i1]),e1[&&NHX:S=e1]),y[&&NHX:S=y]),z[&&NHX:S=z])" );
5965             gene7_1.setRooted( true );
5966             final SDI sdi7 = new SDIse( gene7_1, species7 );
5967             if ( sdi7.getDuplicationsSum() != 0 ) {
5968                 return false;
5969             }
5970             if ( !Test.getEvent( gene7_1, "a1", "a2" ).isSpeciation() ) {
5971                 return false;
5972             }
5973             if ( !Test.getEvent( gene7_1, "a1", "b1" ).isSpeciation() ) {
5974                 return false;
5975             }
5976             if ( !Test.getEvent( gene7_1, "a1", "x" ).isSpeciation() ) {
5977                 return false;
5978             }
5979             if ( !Test.getEvent( gene7_1, "a1", "m1" ).isSpeciation() ) {
5980                 return false;
5981             }
5982             if ( !Test.getEvent( gene7_1, "a1", "i1" ).isSpeciation() ) {
5983                 return false;
5984             }
5985             if ( !Test.getEvent( gene7_1, "a1", "e1" ).isSpeciation() ) {
5986                 return false;
5987             }
5988             if ( !Test.getEvent( gene7_1, "a1", "y" ).isSpeciation() ) {
5989                 return false;
5990             }
5991             if ( !Test.getEvent( gene7_1, "a1", "z" ).isSpeciation() ) {
5992                 return false;
5993             }
5994             final Phylogeny gene7_2 = Test
5995                     .createPhylogeny( "(((((((((a1[&&NHX:S=a1],a2[&&NHX:S=a2]),b1[&&NHX:S=b1]),x[&&NHX:S=x]),m1[&&NHX:S=m1]),i1[&&NHX:S=i1]),j2[&&NHX:S=j2]),e1[&&NHX:S=e1]),y[&&NHX:S=y]),z[&&NHX:S=z])" );
5996             gene7_2.setRooted( true );
5997             final SDI sdi7_2 = new SDIse( gene7_2, species7 );
5998             if ( sdi7_2.getDuplicationsSum() != 1 ) {
5999                 return false;
6000             }
6001             if ( !Test.getEvent( gene7_2, "a1", "a2" ).isSpeciation() ) {
6002                 return false;
6003             }
6004             if ( !Test.getEvent( gene7_2, "a1", "b1" ).isSpeciation() ) {
6005                 return false;
6006             }
6007             if ( !Test.getEvent( gene7_2, "a1", "x" ).isSpeciation() ) {
6008                 return false;
6009             }
6010             if ( !Test.getEvent( gene7_2, "a1", "m1" ).isSpeciation() ) {
6011                 return false;
6012             }
6013             if ( !Test.getEvent( gene7_2, "a1", "i1" ).isSpeciation() ) {
6014                 return false;
6015             }
6016             if ( !Test.getEvent( gene7_2, "a1", "j2" ).isDuplication() ) {
6017                 return false;
6018             }
6019             if ( !Test.getEvent( gene7_2, "a1", "e1" ).isSpeciation() ) {
6020                 return false;
6021             }
6022             if ( !Test.getEvent( gene7_2, "a1", "y" ).isSpeciation() ) {
6023                 return false;
6024             }
6025             if ( !Test.getEvent( gene7_2, "a1", "z" ).isSpeciation() ) {
6026                 return false;
6027             }
6028         }
6029         catch ( final Exception e ) {
6030             return false;
6031         }
6032         return true;
6033     }
6034
6035     private static boolean testSDIunrooted() {
6036         try {
6037             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
6038             final Phylogeny p0 = factory.create( "((((A,B)ab,(C1,C2)cc)abc,D)abcd,(E,F)ef)abcdef", new NHXParser() )[ 0 ];
6039             final List<PhylogenyBranch> l = SDIR.getBranchesInPreorder( p0 );
6040             final Iterator<PhylogenyBranch> iter = l.iterator();
6041             PhylogenyBranch br = iter.next();
6042             if ( !br.getFirstNode().getName().equals( "abcd" ) && !br.getFirstNode().getName().equals( "ef" ) ) {
6043                 return false;
6044             }
6045             if ( !br.getSecondNode().getName().equals( "abcd" ) && !br.getSecondNode().getName().equals( "ef" ) ) {
6046                 return false;
6047             }
6048             br = iter.next();
6049             if ( !br.getFirstNode().getName().equals( "abcd" ) && !br.getFirstNode().getName().equals( "abc" ) ) {
6050                 return false;
6051             }
6052             if ( !br.getSecondNode().getName().equals( "abcd" ) && !br.getSecondNode().getName().equals( "abc" ) ) {
6053                 return false;
6054             }
6055             br = iter.next();
6056             if ( !br.getFirstNode().getName().equals( "abc" ) && !br.getFirstNode().getName().equals( "ab" ) ) {
6057                 return false;
6058             }
6059             if ( !br.getSecondNode().getName().equals( "abc" ) && !br.getSecondNode().getName().equals( "ab" ) ) {
6060                 return false;
6061             }
6062             br = iter.next();
6063             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "A" ) ) {
6064                 return false;
6065             }
6066             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "A" ) ) {
6067                 return false;
6068             }
6069             br = iter.next();
6070             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "B" ) ) {
6071                 return false;
6072             }
6073             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "B" ) ) {
6074                 return false;
6075             }
6076             br = iter.next();
6077             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "abc" ) ) {
6078                 return false;
6079             }
6080             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "abc" ) ) {
6081                 return false;
6082             }
6083             br = iter.next();
6084             if ( !br.getFirstNode().getName().equals( "abc" ) && !br.getFirstNode().getName().equals( "cc" ) ) {
6085                 return false;
6086             }
6087             if ( !br.getSecondNode().getName().equals( "abc" ) && !br.getSecondNode().getName().equals( "cc" ) ) {
6088                 return false;
6089             }
6090             br = iter.next();
6091             if ( !br.getFirstNode().getName().equals( "C1" ) && !br.getFirstNode().getName().equals( "cc" ) ) {
6092                 return false;
6093             }
6094             if ( !br.getSecondNode().getName().equals( "C1" ) && !br.getSecondNode().getName().equals( "cc" ) ) {
6095                 return false;
6096             }
6097             br = iter.next();
6098             if ( !br.getFirstNode().getName().equals( "C2" ) && !br.getFirstNode().getName().equals( "cc" ) ) {
6099                 return false;
6100             }
6101             if ( !br.getSecondNode().getName().equals( "C2" ) && !br.getSecondNode().getName().equals( "cc" ) ) {
6102                 return false;
6103             }
6104             br = iter.next();
6105             if ( !br.getFirstNode().getName().equals( "abc" ) && !br.getFirstNode().getName().equals( "cc" ) ) {
6106                 return false;
6107             }
6108             if ( !br.getSecondNode().getName().equals( "abc" ) && !br.getSecondNode().getName().equals( "cc" ) ) {
6109                 return false;
6110             }
6111             br = iter.next();
6112             if ( !br.getFirstNode().getName().equals( "abc" ) && !br.getFirstNode().getName().equals( "abcd" ) ) {
6113                 return false;
6114             }
6115             if ( !br.getSecondNode().getName().equals( "abc" ) && !br.getSecondNode().getName().equals( "abcd" ) ) {
6116                 return false;
6117             }
6118             br = iter.next();
6119             if ( !br.getFirstNode().getName().equals( "abcd" ) && !br.getFirstNode().getName().equals( "D" ) ) {
6120                 return false;
6121             }
6122             if ( !br.getSecondNode().getName().equals( "abcd" ) && !br.getSecondNode().getName().equals( "D" ) ) {
6123                 return false;
6124             }
6125             br = iter.next();
6126             if ( !br.getFirstNode().getName().equals( "ef" ) && !br.getFirstNode().getName().equals( "abcd" ) ) {
6127                 return false;
6128             }
6129             if ( !br.getSecondNode().getName().equals( "ef" ) && !br.getSecondNode().getName().equals( "abcd" ) ) {
6130                 return false;
6131             }
6132             br = iter.next();
6133             if ( !br.getFirstNode().getName().equals( "ef" ) && !br.getFirstNode().getName().equals( "E" ) ) {
6134                 return false;
6135             }
6136             if ( !br.getSecondNode().getName().equals( "ef" ) && !br.getSecondNode().getName().equals( "E" ) ) {
6137                 return false;
6138             }
6139             br = iter.next();
6140             if ( !br.getFirstNode().getName().equals( "ef" ) && !br.getFirstNode().getName().equals( "F" ) ) {
6141                 return false;
6142             }
6143             if ( !br.getSecondNode().getName().equals( "ef" ) && !br.getSecondNode().getName().equals( "F" ) ) {
6144                 return false;
6145             }
6146             if ( iter.hasNext() ) {
6147                 return false;
6148             }
6149             final Phylogeny p1 = factory.create( "(C,(A,B)ab)abc", new NHXParser() )[ 0 ];
6150             final List<PhylogenyBranch> l1 = SDIR.getBranchesInPreorder( p1 );
6151             final Iterator<PhylogenyBranch> iter1 = l1.iterator();
6152             br = iter1.next();
6153             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "C" ) ) {
6154                 return false;
6155             }
6156             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "C" ) ) {
6157                 return false;
6158             }
6159             br = iter1.next();
6160             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "A" ) ) {
6161                 return false;
6162             }
6163             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "A" ) ) {
6164                 return false;
6165             }
6166             br = iter1.next();
6167             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "B" ) ) {
6168                 return false;
6169             }
6170             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "B" ) ) {
6171                 return false;
6172             }
6173             if ( iter1.hasNext() ) {
6174                 return false;
6175             }
6176             final Phylogeny p2 = factory.create( "((A,B)ab,C)abc", new NHXParser() )[ 0 ];
6177             final List<PhylogenyBranch> l2 = SDIR.getBranchesInPreorder( p2 );
6178             final Iterator<PhylogenyBranch> iter2 = l2.iterator();
6179             br = iter2.next();
6180             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "C" ) ) {
6181                 return false;
6182             }
6183             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "C" ) ) {
6184                 return false;
6185             }
6186             br = iter2.next();
6187             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "A" ) ) {
6188                 return false;
6189             }
6190             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "A" ) ) {
6191                 return false;
6192             }
6193             br = iter2.next();
6194             if ( !br.getFirstNode().getName().equals( "ab" ) && !br.getFirstNode().getName().equals( "B" ) ) {
6195                 return false;
6196             }
6197             if ( !br.getSecondNode().getName().equals( "ab" ) && !br.getSecondNode().getName().equals( "B" ) ) {
6198                 return false;
6199             }
6200             if ( iter2.hasNext() ) {
6201                 return false;
6202             }
6203             final Phylogeny species0 = factory
6204                     .create( "(((([&&NHX:S=A],[&&NHX:S=B]),[&&NHX:S=C]),[&&NHX:S=D]),([&&NHX:S=E],[&&NHX:S=F]))",
6205                              new NHXParser() )[ 0 ];
6206             final Phylogeny gene1 = factory
6207                     .create( "(((((A:0.6[&&NHX:S=A],B:0.1[&&NHX:S=B])ab:0.1,C:0.1[&&NHX:S=C])abc:0.3,D:1.0[&&NHX:S=D])abcd:0.2,E:0.1[&&NHX:S=E])abcde:0.2,F:0.2[&&NHX:S=F])",
6208                              new NHXParser() )[ 0 ];
6209             species0.setRooted( true );
6210             gene1.setRooted( true );
6211             final SDIR sdi_unrooted = new SDIR();
6212             sdi_unrooted.infer( gene1, species0, false, true, true, true, 10 );
6213             if ( sdi_unrooted.getCount() != 1 ) {
6214                 return false;
6215             }
6216             if ( sdi_unrooted.getMinimalDuplications() != 0 ) {
6217                 return false;
6218             }
6219             if ( !Test.isEqual( sdi_unrooted.getMinimalDiffInSubTreeHeights(), 0.4 ) ) {
6220                 return false;
6221             }
6222             if ( !Test.isEqual( sdi_unrooted.getMinimalTreeHeight(), 1.0 ) ) {
6223                 return false;
6224             }
6225             if ( sdi_unrooted.getMinimalMappingCost() != Integer.MAX_VALUE ) {
6226                 return false;
6227             }
6228             final Phylogeny gene2 = factory
6229                     .create( "(((((A:2.6[&&NHX:S=A],B:0.1[&&NHX:S=B])ab:0.1,C:0.1[&&NHX:S=C])abc:0.3,D:1.0[&&NHX:S=D])abcd:0.2,E:0.1[&&NHX:S=E])abcde:0.2,F:0.2[&&NHX:S=F])",
6230                              new NHXParser() )[ 0 ];
6231             gene2.setRooted( true );
6232             sdi_unrooted.infer( gene2, species0, false, false, true, true, 10 );
6233             if ( sdi_unrooted.getCount() != 1 ) {
6234                 return false;
6235             }
6236             if ( sdi_unrooted.getMinimalDuplications() != 3 ) {
6237                 return false;
6238             }
6239             if ( !Test.isEqual( sdi_unrooted.getMinimalDiffInSubTreeHeights(), 0.0 ) ) {
6240                 return false;
6241             }
6242             if ( !Test.isEqual( sdi_unrooted.getMinimalTreeHeight(), 2.0 ) ) {
6243                 return false;
6244             }
6245             if ( sdi_unrooted.getMinimalMappingCost() != Integer.MAX_VALUE ) {
6246                 return false;
6247             }
6248             final Phylogeny species6 = factory
6249                     .create( "(((1:[&&NHX:S=1],5:[&&NHX:S=5])1-5,((4:[&&NHX:S=4],6:[&&NHX:S=6])4-6,2:[&&NHX:S=2])4-6-2)1-5-4-6-2,"
6250                                      + "((9:[&&NHX:S=9],3:[&&NHX:S=3])9-3,(8:[&&NHX:S=8],7:[&&NHX:S=7])8-7)9-3-8-7)",
6251                              new NHXParser() )[ 0 ];
6252             final Phylogeny gene6 = factory
6253                     .create( "((5:0.1[&&NHX:S=5],6:0.1[&&NHX:S=6])5-6:0.05[&&NHX:S=6],(4:0.1[&&NHX:S=4],"
6254                                      + "(((1:0.1[&&NHX:S=1],2:0.1[&&NHX:S=2])1-2:0.1[&&NHX:S=2],3:0.25[&&NHX:S=3])1-2-3:0.2[&&NHX:S=2],"
6255                                      + "(7:0.1[&&NHX:S=7],(8:0.1[&&NHX:S=8],"
6256                                      + "9:0.1[&&NHX:S=9])8-9:0.1[&&NHX:S=9])7-8-9:0.1[&&NHX:S=8])"
6257                                      + "4-5-6-7-8-9:0.1[&&NHX:S=5])4-5-6:0.05[&&NHX:S=5])",
6258                              new NHXParser() )[ 0 ];
6259             species6.setRooted( true );
6260             gene6.setRooted( true );
6261             Phylogeny[] p6 = sdi_unrooted.infer( gene6, species6, false, true, true, true, 10 );
6262             if ( sdi_unrooted.getCount() != 1 ) {
6263                 return false;
6264             }
6265             if ( !Test.isEqual( sdi_unrooted.getMinimalDiffInSubTreeHeights(), 0.0 ) ) {
6266                 return false;
6267             }
6268             if ( !Test.isEqual( sdi_unrooted.getMinimalTreeHeight(), 0.375 ) ) {
6269                 return false;
6270             }
6271             if ( sdi_unrooted.getMinimalDuplications() != 3 ) {
6272                 return false;
6273             }
6274             if ( sdi_unrooted.getMinimalMappingCost() != Integer.MAX_VALUE ) {
6275                 return false;
6276             }
6277             if ( !p6[ 0 ].getRoot().isDuplication() ) {
6278                 return false;
6279             }
6280             if ( !p6[ 0 ].getNode( "4-5-6" ).isDuplication() ) {
6281                 return false;
6282             }
6283             if ( !p6[ 0 ].getNode( "7-8-9" ).isDuplication() ) {
6284                 return false;
6285             }
6286             if ( p6[ 0 ].getNode( "1-2" ).isDuplication() ) {
6287                 return false;
6288             }
6289             if ( p6[ 0 ].getNode( "1-2-3" ).isDuplication() ) {
6290                 return false;
6291             }
6292             if ( p6[ 0 ].getNode( "5-6" ).isDuplication() ) {
6293                 return false;
6294             }
6295             if ( p6[ 0 ].getNode( "8-9" ).isDuplication() ) {
6296                 return false;
6297             }
6298             if ( p6[ 0 ].getNode( "4-5-6-7-8-9" ).isDuplication() ) {
6299                 return false;
6300             }
6301             p6 = null;
6302             final Phylogeny species7 = factory
6303                     .create( "(((1:[&&NHX:S=1],5:[&&NHX:S=5])1-5,((4:[&&NHX:S=4],6:[&&NHX:S=6])4-6,2:[&&NHX:S=2])4-6-2)1-5-4-6-2,"
6304                                      + "((9:[&&NHX:S=9],3:[&&NHX:S=3])9-3,(8:[&&NHX:S=8],7:[&&NHX:S=7])8-7)9-3-8-7)",
6305                              new NHXParser() )[ 0 ];
6306             final Phylogeny gene7 = factory
6307                     .create( "((5:0.1[&&NHX:S=5],6:0.1[&&NHX:S=6])5-6:0.05[&&NHX:S=6],(4:0.1[&&NHX:S=4],"
6308                                      + "(((1:0.1[&&NHX:S=1],2:0.1[&&NHX:S=2])1-2:0.1[&&NHX:S=2],3:0.25[&&NHX:S=3])1-2-3:0.2[&&NHX:S=2],"
6309                                      + "(7:0.1[&&NHX:S=7],(8:0.1[&&NHX:S=8],"
6310                                      + "9:0.1[&&NHX:S=9])8-9:0.1[&&NHX:S=9])7-8-9:0.1[&&NHX:S=8])"
6311                                      + "4-5-6-7-8-9:0.1[&&NHX:S=5])4-5-6:0.05[&&NHX:S=5])",
6312                              new NHXParser() )[ 0 ];
6313             species7.setRooted( true );
6314             gene7.setRooted( true );
6315             Phylogeny[] p7 = sdi_unrooted.infer( gene7, species7, true, true, true, true, 10 );
6316             if ( sdi_unrooted.getCount() != 1 ) {
6317                 return false;
6318             }
6319             if ( !Test.isEqual( sdi_unrooted.getMinimalDiffInSubTreeHeights(), 0.0 ) ) {
6320                 return false;
6321             }
6322             if ( !Test.isEqual( sdi_unrooted.getMinimalTreeHeight(), 0.375 ) ) {
6323                 return false;
6324             }
6325             if ( sdi_unrooted.getMinimalDuplications() != 3 ) {
6326                 return false;
6327             }
6328             if ( sdi_unrooted.getMinimalMappingCost() != 17 ) {
6329                 return false;
6330             }
6331             if ( !p7[ 0 ].getRoot().isDuplication() ) {
6332                 return false;
6333             }
6334             if ( !p7[ 0 ].getNode( "4-5-6" ).isDuplication() ) {
6335                 return false;
6336             }
6337             if ( !p7[ 0 ].getNode( "7-8-9" ).isDuplication() ) {
6338                 return false;
6339             }
6340             if ( p7[ 0 ].getNode( "1-2" ).isDuplication() ) {
6341                 return false;
6342             }
6343             if ( p7[ 0 ].getNode( "1-2-3" ).isDuplication() ) {
6344                 return false;
6345             }
6346             if ( p7[ 0 ].getNode( "5-6" ).isDuplication() ) {
6347                 return false;
6348             }
6349             if ( p7[ 0 ].getNode( "8-9" ).isDuplication() ) {
6350                 return false;
6351             }
6352             if ( p7[ 0 ].getNode( "4-5-6-7-8-9" ).isDuplication() ) {
6353                 return false;
6354             }
6355             p7 = null;
6356             final Phylogeny species8 = factory
6357                     .create( "(((1:[&&NHX:S=1],5:[&&NHX:S=5])1-5,((4:[&&NHX:S=4],6:[&&NHX:S=6])4-6,2:[&&NHX:S=2])4-6-2)1-5-4-6-2,"
6358                                      + "((9:[&&NHX:S=9],3:[&&NHX:S=3])9-3,(8:[&&NHX:S=8],7:[&&NHX:S=7])8-7)9-3-8-7)",
6359                              new NHXParser() )[ 0 ];
6360             final Phylogeny gene8 = factory
6361                     .create( "((5:0.1[&&NHX:S=5],6:0.1[&&NHX:S=6])5-6:0.05[&&NHX:S=6],(4:0.1[&&NHX:S=4],"
6362                                      + "(((1:0.1[&&NHX:S=1],2:0.1[&&NHX:S=2])1-2:0.1[&&NHX:S=2],3:0.25[&&NHX:S=3])1-2-3:0.2[&&NHX:S=2],"
6363                                      + "(7:0.1[&&NHX:S=7],(8:0.1[&&NHX:S=8],"
6364                                      + "9:0.1[&&NHX:S=9])8-9:0.1[&&NHX:S=9])7-8-9:0.1[&&NHX:S=8])"
6365                                      + "4-5-6-7-8-9:0.1[&&NHX:S=5])4-5-6:0.05[&&NHX:S=5])",
6366                              new NHXParser() )[ 0 ];
6367             species8.setRooted( true );
6368             gene8.setRooted( true );
6369             Phylogeny[] p8 = sdi_unrooted.infer( gene8, species8, false, false, true, true, 10 );
6370             if ( sdi_unrooted.getCount() != 1 ) {
6371                 return false;
6372             }
6373             if ( !Test.isEqual( sdi_unrooted.getMinimalDiffInSubTreeHeights(), 0.0 ) ) {
6374                 return false;
6375             }
6376             if ( !Test.isEqual( sdi_unrooted.getMinimalTreeHeight(), 0.375 ) ) {
6377                 return false;
6378             }
6379             if ( sdi_unrooted.getMinimalDuplications() != 3 ) {
6380                 return false;
6381             }
6382             if ( sdi_unrooted.getMinimalMappingCost() != Integer.MAX_VALUE ) {
6383                 return false;
6384             }
6385             if ( !p8[ 0 ].getRoot().isDuplication() ) {
6386                 return false;
6387             }
6388             if ( !p8[ 0 ].getNode( "4-5-6" ).isDuplication() ) {
6389                 return false;
6390             }
6391             if ( !p8[ 0 ].getNode( "7-8-9" ).isDuplication() ) {
6392                 return false;
6393             }
6394             if ( p8[ 0 ].getNode( "1-2" ).isDuplication() ) {
6395                 return false;
6396             }
6397             if ( p8[ 0 ].getNode( "1-2-3" ).isDuplication() ) {
6398                 return false;
6399             }
6400             if ( p8[ 0 ].getNode( "5-6" ).isDuplication() ) {
6401                 return false;
6402             }
6403             if ( p8[ 0 ].getNode( "8-9" ).isDuplication() ) {
6404                 return false;
6405             }
6406             if ( p8[ 0 ].getNode( "4-5-6-7-8-9" ).isDuplication() ) {
6407                 return false;
6408             }
6409             p8 = null;
6410         }
6411         catch ( final Exception e ) {
6412             e.printStackTrace( System.out );
6413             return false;
6414         }
6415         return true;
6416     }
6417
6418     private static boolean testSplit() {
6419         try {
6420             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
6421             final Phylogeny p0 = factory.create( "(((A,B,C),D),(E,(F,G)))R", new NHXParser() )[ 0 ];
6422             //Archaeopteryx.createApplication( p0 );
6423             final Set<PhylogenyNode> ex = new HashSet<PhylogenyNode>();
6424             ex.add( new PhylogenyNode( "A" ) );
6425             ex.add( new PhylogenyNode( "B" ) );
6426             ex.add( new PhylogenyNode( "C" ) );
6427             ex.add( new PhylogenyNode( "D" ) );
6428             ex.add( new PhylogenyNode( "E" ) );
6429             ex.add( new PhylogenyNode( "F" ) );
6430             ex.add( new PhylogenyNode( "G" ) );
6431             ex.add( new PhylogenyNode( "X" ) );
6432             ex.add( new PhylogenyNode( "Y" ) );
6433             final TreeSplitMatrix s0 = new TreeSplitMatrix( p0, false, ex );
6434             // System.out.println( s0.toString() );
6435             //
6436             Set<PhylogenyNode> query_nodes = new HashSet<PhylogenyNode>();
6437             query_nodes.add( new PhylogenyNode( "A" ) );
6438             query_nodes.add( new PhylogenyNode( "B" ) );
6439             if ( s0.match( query_nodes ) ) {
6440                 return false;
6441             }
6442             query_nodes = new HashSet<PhylogenyNode>();
6443             query_nodes.add( new PhylogenyNode( "A" ) );
6444             query_nodes.add( new PhylogenyNode( "B" ) );
6445             query_nodes.add( new PhylogenyNode( "C" ) );
6446             query_nodes.add( new PhylogenyNode( "D" ) );
6447             query_nodes.add( new PhylogenyNode( "E" ) );
6448             query_nodes.add( new PhylogenyNode( "F" ) );
6449             query_nodes.add( new PhylogenyNode( "G" ) );
6450             if ( !s0.match( query_nodes ) ) {
6451                 return false;
6452             }
6453             //
6454             query_nodes = new HashSet<PhylogenyNode>();
6455             query_nodes.add( new PhylogenyNode( "A" ) );
6456             query_nodes.add( new PhylogenyNode( "B" ) );
6457             query_nodes.add( new PhylogenyNode( "C" ) );
6458             if ( !s0.match( query_nodes ) ) {
6459                 return false;
6460             }
6461             //
6462             query_nodes = new HashSet<PhylogenyNode>();
6463             query_nodes.add( new PhylogenyNode( "D" ) );
6464             query_nodes.add( new PhylogenyNode( "E" ) );
6465             query_nodes.add( new PhylogenyNode( "F" ) );
6466             query_nodes.add( new PhylogenyNode( "G" ) );
6467             if ( !s0.match( query_nodes ) ) {
6468                 return false;
6469             }
6470             //
6471             query_nodes = new HashSet<PhylogenyNode>();
6472             query_nodes.add( new PhylogenyNode( "A" ) );
6473             query_nodes.add( new PhylogenyNode( "B" ) );
6474             query_nodes.add( new PhylogenyNode( "C" ) );
6475             query_nodes.add( new PhylogenyNode( "D" ) );
6476             if ( !s0.match( query_nodes ) ) {
6477                 return false;
6478             }
6479             //
6480             query_nodes = new HashSet<PhylogenyNode>();
6481             query_nodes.add( new PhylogenyNode( "E" ) );
6482             query_nodes.add( new PhylogenyNode( "F" ) );
6483             query_nodes.add( new PhylogenyNode( "G" ) );
6484             if ( !s0.match( query_nodes ) ) {
6485                 return false;
6486             }
6487             //
6488             query_nodes = new HashSet<PhylogenyNode>();
6489             query_nodes.add( new PhylogenyNode( "F" ) );
6490             query_nodes.add( new PhylogenyNode( "G" ) );
6491             if ( !s0.match( query_nodes ) ) {
6492                 return false;
6493             }
6494             //
6495             query_nodes = new HashSet<PhylogenyNode>();
6496             query_nodes.add( new PhylogenyNode( "E" ) );
6497             query_nodes.add( new PhylogenyNode( "D" ) );
6498             query_nodes.add( new PhylogenyNode( "C" ) );
6499             query_nodes.add( new PhylogenyNode( "B" ) );
6500             query_nodes.add( new PhylogenyNode( "A" ) );
6501             if ( !s0.match( query_nodes ) ) {
6502                 return false;
6503             }
6504             //
6505             query_nodes = new HashSet<PhylogenyNode>();
6506             query_nodes.add( new PhylogenyNode( "F" ) );
6507             query_nodes.add( new PhylogenyNode( "G" ) );
6508             query_nodes.add( new PhylogenyNode( "E" ) );
6509             if ( !s0.match( query_nodes ) ) {
6510                 return false;
6511             }
6512             //
6513             query_nodes = new HashSet<PhylogenyNode>();
6514             query_nodes.add( new PhylogenyNode( "F" ) );
6515             query_nodes.add( new PhylogenyNode( "G" ) );
6516             query_nodes.add( new PhylogenyNode( "E" ) );
6517             query_nodes.add( new PhylogenyNode( "D" ) );
6518             if ( !s0.match( query_nodes ) ) {
6519                 return false;
6520             }
6521             //
6522             query_nodes = new HashSet<PhylogenyNode>();
6523             query_nodes.add( new PhylogenyNode( "F" ) );
6524             query_nodes.add( new PhylogenyNode( "A" ) );
6525             if ( s0.match( query_nodes ) ) {
6526                 return false;
6527             }
6528             //
6529             query_nodes = new HashSet<PhylogenyNode>();
6530             query_nodes.add( new PhylogenyNode( "A" ) );
6531             query_nodes.add( new PhylogenyNode( "E" ) );
6532             query_nodes.add( new PhylogenyNode( "B" ) );
6533             query_nodes.add( new PhylogenyNode( "C" ) );
6534             if ( s0.match( query_nodes ) ) {
6535                 return false;
6536             }
6537             //
6538             query_nodes = new HashSet<PhylogenyNode>();
6539             query_nodes.add( new PhylogenyNode( "F" ) );
6540             query_nodes.add( new PhylogenyNode( "G" ) );
6541             query_nodes.add( new PhylogenyNode( "E" ) );
6542             query_nodes.add( new PhylogenyNode( "D" ) );
6543             query_nodes.add( new PhylogenyNode( "C" ) );
6544             if ( s0.match( query_nodes ) ) {
6545                 return false;
6546             }
6547             //
6548             query_nodes = new HashSet<PhylogenyNode>();
6549             query_nodes.add( new PhylogenyNode( "A" ) );
6550             query_nodes.add( new PhylogenyNode( "B" ) );
6551             query_nodes.add( new PhylogenyNode( "D" ) );
6552             if ( s0.match( query_nodes ) ) {
6553                 return false;
6554             }
6555             //
6556             query_nodes = new HashSet<PhylogenyNode>();
6557             query_nodes.add( new PhylogenyNode( "A" ) );
6558             query_nodes.add( new PhylogenyNode( "D" ) );
6559             if ( s0.match( query_nodes ) ) {
6560                 return false;
6561             }
6562             //
6563             query_nodes = new HashSet<PhylogenyNode>();
6564             query_nodes.add( new PhylogenyNode( "A" ) );
6565             query_nodes.add( new PhylogenyNode( "B" ) );
6566             if ( s0.match( query_nodes ) ) {
6567                 return false;
6568             }
6569             //
6570             query_nodes = new HashSet<PhylogenyNode>();
6571             query_nodes.add( new PhylogenyNode( "A" ) );
6572             query_nodes.add( new PhylogenyNode( "C" ) );
6573             if ( s0.match( query_nodes ) ) {
6574                 return false;
6575             }
6576             //
6577             query_nodes = new HashSet<PhylogenyNode>();
6578             query_nodes.add( new PhylogenyNode( "A" ) );
6579             query_nodes.add( new PhylogenyNode( "E" ) );
6580             if ( s0.match( query_nodes ) ) {
6581                 return false;
6582             }
6583             //
6584             query_nodes = new HashSet<PhylogenyNode>();
6585             query_nodes.add( new PhylogenyNode( "A" ) );
6586             query_nodes.add( new PhylogenyNode( "F" ) );
6587             if ( s0.match( query_nodes ) ) {
6588                 return false;
6589             }
6590             //
6591             query_nodes = new HashSet<PhylogenyNode>();
6592             query_nodes.add( new PhylogenyNode( "A" ) );
6593             query_nodes.add( new PhylogenyNode( "G" ) );
6594             if ( s0.match( query_nodes ) ) {
6595                 return false;
6596             }
6597             //
6598             query_nodes = new HashSet<PhylogenyNode>();
6599             query_nodes.add( new PhylogenyNode( "A" ) );
6600             query_nodes.add( new PhylogenyNode( "F" ) );
6601             query_nodes.add( new PhylogenyNode( "G" ) );
6602             if ( s0.match( query_nodes ) ) {
6603                 return false;
6604             }
6605             //
6606             query_nodes = new HashSet<PhylogenyNode>();
6607             query_nodes.add( new PhylogenyNode( "A" ) );
6608             query_nodes.add( new PhylogenyNode( "B" ) );
6609             query_nodes.add( new PhylogenyNode( "D" ) );
6610             if ( s0.match( query_nodes ) ) {
6611                 return false;
6612             }
6613             //
6614             query_nodes = new HashSet<PhylogenyNode>();
6615             query_nodes.add( new PhylogenyNode( "E" ) );
6616             query_nodes.add( new PhylogenyNode( "D" ) );
6617             query_nodes.add( new PhylogenyNode( "A" ) );
6618             if ( s0.match( query_nodes ) ) {
6619                 return false;
6620             }
6621             //
6622             query_nodes = new HashSet<PhylogenyNode>();
6623             query_nodes.add( new PhylogenyNode( "E" ) );
6624             query_nodes.add( new PhylogenyNode( "D" ) );
6625             query_nodes.add( new PhylogenyNode( "A" ) );
6626             query_nodes.add( new PhylogenyNode( "G" ) );
6627             if ( s0.match( query_nodes ) ) {
6628                 return false;
6629             }
6630             /////////
6631             //            query_nodes = new HashSet<PhylogenyNode>();
6632             //            query_nodes.add( new PhylogenyNode( "X" ) );
6633             //            query_nodes.add( new PhylogenyNode( "Y" ) );
6634             //            query_nodes.add( new PhylogenyNode( "A" ) );
6635             //            query_nodes.add( new PhylogenyNode( "B" ) );
6636             //            query_nodes.add( new PhylogenyNode( "C" ) );
6637             //            query_nodes.add( new PhylogenyNode( "D" ) );
6638             //            query_nodes.add( new PhylogenyNode( "E" ) );
6639             //            query_nodes.add( new PhylogenyNode( "F" ) );
6640             //            query_nodes.add( new PhylogenyNode( "G" ) );
6641             //            if ( !s0.match( query_nodes ) ) {
6642             //                return false;
6643             //            }
6644             //            query_nodes = new HashSet<PhylogenyNode>();
6645             //            query_nodes.add( new PhylogenyNode( "X" ) );
6646             //            query_nodes.add( new PhylogenyNode( "Y" ) );
6647             //            query_nodes.add( new PhylogenyNode( "A" ) );
6648             //            query_nodes.add( new PhylogenyNode( "B" ) );
6649             //            query_nodes.add( new PhylogenyNode( "C" ) );
6650             //            if ( !s0.match( query_nodes ) ) {
6651             //                return false;
6652             //            }
6653             //            //
6654             //            query_nodes = new HashSet<PhylogenyNode>();
6655             //            query_nodes.add( new PhylogenyNode( "X" ) );
6656             //            query_nodes.add( new PhylogenyNode( "Y" ) );
6657             //            query_nodes.add( new PhylogenyNode( "D" ) );
6658             //            query_nodes.add( new PhylogenyNode( "E" ) );
6659             //            query_nodes.add( new PhylogenyNode( "F" ) );
6660             //            query_nodes.add( new PhylogenyNode( "G" ) );
6661             //            if ( !s0.match( query_nodes ) ) {
6662             //                return false;
6663             //            }
6664             //            //
6665             //            query_nodes = new HashSet<PhylogenyNode>();
6666             //            query_nodes.add( new PhylogenyNode( "X" ) );
6667             //            query_nodes.add( new PhylogenyNode( "Y" ) );
6668             //            query_nodes.add( new PhylogenyNode( "A" ) );
6669             //            query_nodes.add( new PhylogenyNode( "B" ) );
6670             //            query_nodes.add( new PhylogenyNode( "C" ) );
6671             //            query_nodes.add( new PhylogenyNode( "D" ) );
6672             //            if ( !s0.match( query_nodes ) ) {
6673             //                return false;
6674             //            }
6675             //            //
6676             //            query_nodes = new HashSet<PhylogenyNode>();
6677             //            query_nodes.add( new PhylogenyNode( "X" ) );
6678             //            query_nodes.add( new PhylogenyNode( "Y" ) );
6679             //            query_nodes.add( new PhylogenyNode( "E" ) );
6680             //            query_nodes.add( new PhylogenyNode( "F" ) );
6681             //            query_nodes.add( new PhylogenyNode( "G" ) );
6682             //            if ( !s0.match( query_nodes ) ) {
6683             //                return false;
6684             //            }
6685             //            //
6686             //            query_nodes = new HashSet<PhylogenyNode>();
6687             //            query_nodes.add( new PhylogenyNode( "X" ) );
6688             //            query_nodes.add( new PhylogenyNode( "Y" ) );
6689             //            query_nodes.add( new PhylogenyNode( "F" ) );
6690             //            query_nodes.add( new PhylogenyNode( "G" ) );
6691             //            if ( !s0.match( query_nodes ) ) {
6692             //                return false;
6693             //            }
6694             //
6695             query_nodes = new HashSet<PhylogenyNode>();
6696             query_nodes.add( new PhylogenyNode( "X" ) );
6697             query_nodes.add( new PhylogenyNode( "Y" ) );
6698             query_nodes.add( new PhylogenyNode( "E" ) );
6699             query_nodes.add( new PhylogenyNode( "G" ) );
6700             if ( s0.match( query_nodes ) ) {
6701                 return false;
6702             }
6703             //
6704             query_nodes = new HashSet<PhylogenyNode>();
6705             query_nodes.add( new PhylogenyNode( "X" ) );
6706             query_nodes.add( new PhylogenyNode( "Y" ) );
6707             query_nodes.add( new PhylogenyNode( "A" ) );
6708             query_nodes.add( new PhylogenyNode( "B" ) );
6709             if ( s0.match( query_nodes ) ) {
6710                 return false;
6711             }
6712             ///////////////////////////
6713             //
6714             query_nodes = new HashSet<PhylogenyNode>();
6715             query_nodes.add( new PhylogenyNode( "X" ) );
6716             query_nodes.add( new PhylogenyNode( "Y" ) );
6717             query_nodes.add( new PhylogenyNode( "A" ) );
6718             query_nodes.add( new PhylogenyNode( "D" ) );
6719             if ( s0.match( query_nodes ) ) {
6720                 return false;
6721             }
6722             //
6723             query_nodes = new HashSet<PhylogenyNode>();
6724             query_nodes.add( new PhylogenyNode( "X" ) );
6725             query_nodes.add( new PhylogenyNode( "Y" ) );
6726             query_nodes.add( new PhylogenyNode( "A" ) );
6727             query_nodes.add( new PhylogenyNode( "B" ) );
6728             if ( s0.match( query_nodes ) ) {
6729                 return false;
6730             }
6731             //
6732             query_nodes = new HashSet<PhylogenyNode>();
6733             query_nodes.add( new PhylogenyNode( "X" ) );
6734             query_nodes.add( new PhylogenyNode( "Y" ) );
6735             query_nodes.add( new PhylogenyNode( "A" ) );
6736             query_nodes.add( new PhylogenyNode( "C" ) );
6737             if ( s0.match( query_nodes ) ) {
6738                 return false;
6739             }
6740             //
6741             query_nodes = new HashSet<PhylogenyNode>();
6742             query_nodes.add( new PhylogenyNode( "X" ) );
6743             query_nodes.add( new PhylogenyNode( "Y" ) );
6744             query_nodes.add( new PhylogenyNode( "A" ) );
6745             query_nodes.add( new PhylogenyNode( "E" ) );
6746             if ( s0.match( query_nodes ) ) {
6747                 return false;
6748             }
6749             //
6750             query_nodes = new HashSet<PhylogenyNode>();
6751             query_nodes.add( new PhylogenyNode( "X" ) );
6752             query_nodes.add( new PhylogenyNode( "Y" ) );
6753             query_nodes.add( new PhylogenyNode( "A" ) );
6754             query_nodes.add( new PhylogenyNode( "F" ) );
6755             if ( s0.match( query_nodes ) ) {
6756                 return false;
6757             }
6758             //
6759             query_nodes = new HashSet<PhylogenyNode>();
6760             query_nodes.add( new PhylogenyNode( "Y" ) );
6761             query_nodes.add( new PhylogenyNode( "A" ) );
6762             query_nodes.add( new PhylogenyNode( "G" ) );
6763             if ( s0.match( query_nodes ) ) {
6764                 return false;
6765             }
6766             //
6767             query_nodes = new HashSet<PhylogenyNode>();
6768             query_nodes.add( new PhylogenyNode( "X" ) );
6769             query_nodes.add( new PhylogenyNode( "Y" ) );
6770             query_nodes.add( new PhylogenyNode( "A" ) );
6771             query_nodes.add( new PhylogenyNode( "F" ) );
6772             query_nodes.add( new PhylogenyNode( "G" ) );
6773             if ( s0.match( query_nodes ) ) {
6774                 return false;
6775             }
6776             //
6777             query_nodes = new HashSet<PhylogenyNode>();
6778             query_nodes.add( new PhylogenyNode( "X" ) );
6779             query_nodes.add( new PhylogenyNode( "Y" ) );
6780             query_nodes.add( new PhylogenyNode( "A" ) );
6781             query_nodes.add( new PhylogenyNode( "B" ) );
6782             query_nodes.add( new PhylogenyNode( "D" ) );
6783             if ( s0.match( query_nodes ) ) {
6784                 return false;
6785             }
6786             //
6787             query_nodes = new HashSet<PhylogenyNode>();
6788             query_nodes.add( new PhylogenyNode( "X" ) );
6789             query_nodes.add( new PhylogenyNode( "Y" ) );
6790             query_nodes.add( new PhylogenyNode( "E" ) );
6791             query_nodes.add( new PhylogenyNode( "D" ) );
6792             query_nodes.add( new PhylogenyNode( "A" ) );
6793             if ( s0.match( query_nodes ) ) {
6794                 return false;
6795             }
6796             //
6797             query_nodes = new HashSet<PhylogenyNode>();
6798             query_nodes.add( new PhylogenyNode( "X" ) );
6799             query_nodes.add( new PhylogenyNode( "Y" ) );
6800             query_nodes.add( new PhylogenyNode( "E" ) );
6801             query_nodes.add( new PhylogenyNode( "D" ) );
6802             query_nodes.add( new PhylogenyNode( "A" ) );
6803             query_nodes.add( new PhylogenyNode( "G" ) );
6804             if ( s0.match( query_nodes ) ) {
6805                 return false;
6806             }
6807         }
6808         catch ( final Exception e ) {
6809             e.printStackTrace();
6810             return false;
6811         }
6812         return true;
6813     }
6814
6815     private static boolean testSplitStrict() {
6816         try {
6817             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
6818             final Phylogeny p0 = factory.create( "(((A,B,C),D),(E,(F,G)))R", new NHXParser() )[ 0 ];
6819             final Set<PhylogenyNode> ex = new HashSet<PhylogenyNode>();
6820             ex.add( new PhylogenyNode( "A" ) );
6821             ex.add( new PhylogenyNode( "B" ) );
6822             ex.add( new PhylogenyNode( "C" ) );
6823             ex.add( new PhylogenyNode( "D" ) );
6824             ex.add( new PhylogenyNode( "E" ) );
6825             ex.add( new PhylogenyNode( "F" ) );
6826             ex.add( new PhylogenyNode( "G" ) );
6827             final TreeSplitMatrix s0 = new TreeSplitMatrix( p0, true, ex );
6828             Set<PhylogenyNode> query_nodes = new HashSet<PhylogenyNode>();
6829             query_nodes.add( new PhylogenyNode( "A" ) );
6830             query_nodes.add( new PhylogenyNode( "B" ) );
6831             if ( s0.match( query_nodes ) ) {
6832                 return false;
6833             }
6834             query_nodes = new HashSet<PhylogenyNode>();
6835             query_nodes.add( new PhylogenyNode( "A" ) );
6836             query_nodes.add( new PhylogenyNode( "B" ) );
6837             query_nodes.add( new PhylogenyNode( "C" ) );
6838             query_nodes.add( new PhylogenyNode( "D" ) );
6839             query_nodes.add( new PhylogenyNode( "E" ) );
6840             query_nodes.add( new PhylogenyNode( "F" ) );
6841             query_nodes.add( new PhylogenyNode( "G" ) );
6842             if ( !s0.match( query_nodes ) ) {
6843                 return false;
6844             }
6845             //
6846             query_nodes = new HashSet<PhylogenyNode>();
6847             query_nodes.add( new PhylogenyNode( "A" ) );
6848             query_nodes.add( new PhylogenyNode( "B" ) );
6849             query_nodes.add( new PhylogenyNode( "C" ) );
6850             if ( !s0.match( query_nodes ) ) {
6851                 return false;
6852             }
6853             //
6854             query_nodes = new HashSet<PhylogenyNode>();
6855             query_nodes.add( new PhylogenyNode( "D" ) );
6856             query_nodes.add( new PhylogenyNode( "E" ) );
6857             query_nodes.add( new PhylogenyNode( "F" ) );
6858             query_nodes.add( new PhylogenyNode( "G" ) );
6859             if ( !s0.match( query_nodes ) ) {
6860                 return false;
6861             }
6862             //
6863             query_nodes = new HashSet<PhylogenyNode>();
6864             query_nodes.add( new PhylogenyNode( "A" ) );
6865             query_nodes.add( new PhylogenyNode( "B" ) );
6866             query_nodes.add( new PhylogenyNode( "C" ) );
6867             query_nodes.add( new PhylogenyNode( "D" ) );
6868             if ( !s0.match( query_nodes ) ) {
6869                 return false;
6870             }
6871             //
6872             query_nodes = new HashSet<PhylogenyNode>();
6873             query_nodes.add( new PhylogenyNode( "E" ) );
6874             query_nodes.add( new PhylogenyNode( "F" ) );
6875             query_nodes.add( new PhylogenyNode( "G" ) );
6876             if ( !s0.match( query_nodes ) ) {
6877                 return false;
6878             }
6879             //
6880             query_nodes = new HashSet<PhylogenyNode>();
6881             query_nodes.add( new PhylogenyNode( "F" ) );
6882             query_nodes.add( new PhylogenyNode( "G" ) );
6883             if ( !s0.match( query_nodes ) ) {
6884                 return false;
6885             }
6886             //
6887             query_nodes = new HashSet<PhylogenyNode>();
6888             query_nodes.add( new PhylogenyNode( "E" ) );
6889             query_nodes.add( new PhylogenyNode( "D" ) );
6890             query_nodes.add( new PhylogenyNode( "C" ) );
6891             query_nodes.add( new PhylogenyNode( "B" ) );
6892             query_nodes.add( new PhylogenyNode( "A" ) );
6893             if ( !s0.match( query_nodes ) ) {
6894                 return false;
6895             }
6896             //
6897             query_nodes = new HashSet<PhylogenyNode>();
6898             query_nodes.add( new PhylogenyNode( "F" ) );
6899             query_nodes.add( new PhylogenyNode( "G" ) );
6900             query_nodes.add( new PhylogenyNode( "E" ) );
6901             if ( !s0.match( query_nodes ) ) {
6902                 return false;
6903             }
6904             //
6905             query_nodes = new HashSet<PhylogenyNode>();
6906             query_nodes.add( new PhylogenyNode( "F" ) );
6907             query_nodes.add( new PhylogenyNode( "G" ) );
6908             query_nodes.add( new PhylogenyNode( "E" ) );
6909             query_nodes.add( new PhylogenyNode( "D" ) );
6910             if ( !s0.match( query_nodes ) ) {
6911                 return false;
6912             }
6913             //
6914             query_nodes = new HashSet<PhylogenyNode>();
6915             query_nodes.add( new PhylogenyNode( "F" ) );
6916             query_nodes.add( new PhylogenyNode( "A" ) );
6917             if ( s0.match( query_nodes ) ) {
6918                 return false;
6919             }
6920             //
6921             query_nodes = new HashSet<PhylogenyNode>();
6922             query_nodes.add( new PhylogenyNode( "A" ) );
6923             query_nodes.add( new PhylogenyNode( "E" ) );
6924             query_nodes.add( new PhylogenyNode( "B" ) );
6925             query_nodes.add( new PhylogenyNode( "C" ) );
6926             if ( s0.match( query_nodes ) ) {
6927                 return false;
6928             }
6929             //
6930             query_nodes = new HashSet<PhylogenyNode>();
6931             query_nodes.add( new PhylogenyNode( "F" ) );
6932             query_nodes.add( new PhylogenyNode( "G" ) );
6933             query_nodes.add( new PhylogenyNode( "E" ) );
6934             query_nodes.add( new PhylogenyNode( "D" ) );
6935             query_nodes.add( new PhylogenyNode( "C" ) );
6936             if ( s0.match( query_nodes ) ) {
6937                 return false;
6938             }
6939             //
6940             query_nodes = new HashSet<PhylogenyNode>();
6941             query_nodes.add( new PhylogenyNode( "A" ) );
6942             query_nodes.add( new PhylogenyNode( "B" ) );
6943             query_nodes.add( new PhylogenyNode( "D" ) );
6944             if ( s0.match( query_nodes ) ) {
6945                 return false;
6946             }
6947             //
6948             query_nodes = new HashSet<PhylogenyNode>();
6949             query_nodes.add( new PhylogenyNode( "A" ) );
6950             query_nodes.add( new PhylogenyNode( "D" ) );
6951             if ( s0.match( query_nodes ) ) {
6952                 return false;
6953             }
6954             //
6955             query_nodes = new HashSet<PhylogenyNode>();
6956             query_nodes.add( new PhylogenyNode( "A" ) );
6957             query_nodes.add( new PhylogenyNode( "B" ) );
6958             if ( s0.match( query_nodes ) ) {
6959                 return false;
6960             }
6961             //
6962             query_nodes = new HashSet<PhylogenyNode>();
6963             query_nodes.add( new PhylogenyNode( "A" ) );
6964             query_nodes.add( new PhylogenyNode( "C" ) );
6965             if ( s0.match( query_nodes ) ) {
6966                 return false;
6967             }
6968             //
6969             query_nodes = new HashSet<PhylogenyNode>();
6970             query_nodes.add( new PhylogenyNode( "A" ) );
6971             query_nodes.add( new PhylogenyNode( "E" ) );
6972             if ( s0.match( query_nodes ) ) {
6973                 return false;
6974             }
6975             //
6976             query_nodes = new HashSet<PhylogenyNode>();
6977             query_nodes.add( new PhylogenyNode( "A" ) );
6978             query_nodes.add( new PhylogenyNode( "F" ) );
6979             if ( s0.match( query_nodes ) ) {
6980                 return false;
6981             }
6982             //
6983             query_nodes = new HashSet<PhylogenyNode>();
6984             query_nodes.add( new PhylogenyNode( "A" ) );
6985             query_nodes.add( new PhylogenyNode( "G" ) );
6986             if ( s0.match( query_nodes ) ) {
6987                 return false;
6988             }
6989             //
6990             query_nodes = new HashSet<PhylogenyNode>();
6991             query_nodes.add( new PhylogenyNode( "A" ) );
6992             query_nodes.add( new PhylogenyNode( "F" ) );
6993             query_nodes.add( new PhylogenyNode( "G" ) );
6994             if ( s0.match( query_nodes ) ) {
6995                 return false;
6996             }
6997             //
6998             query_nodes = new HashSet<PhylogenyNode>();
6999             query_nodes.add( new PhylogenyNode( "A" ) );
7000             query_nodes.add( new PhylogenyNode( "B" ) );
7001             query_nodes.add( new PhylogenyNode( "D" ) );
7002             if ( s0.match( query_nodes ) ) {
7003                 return false;
7004             }
7005             //
7006             query_nodes = new HashSet<PhylogenyNode>();
7007             query_nodes.add( new PhylogenyNode( "E" ) );
7008             query_nodes.add( new PhylogenyNode( "D" ) );
7009             query_nodes.add( new PhylogenyNode( "A" ) );
7010             if ( s0.match( query_nodes ) ) {
7011                 return false;
7012             }
7013             //
7014             query_nodes = new HashSet<PhylogenyNode>();
7015             query_nodes.add( new PhylogenyNode( "E" ) );
7016             query_nodes.add( new PhylogenyNode( "D" ) );
7017             query_nodes.add( new PhylogenyNode( "A" ) );
7018             query_nodes.add( new PhylogenyNode( "G" ) );
7019             if ( s0.match( query_nodes ) ) {
7020                 return false;
7021             }
7022         }
7023         catch ( final Exception e ) {
7024             e.printStackTrace();
7025             return false;
7026         }
7027         return true;
7028     }
7029
7030     private static boolean testSubtreeDeletion() {
7031         try {
7032             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
7033             final Phylogeny t1 = factory.create( "((A,B,C)abc,(D,E,F)def)r", new NHXParser() )[ 0 ];
7034             t1.deleteSubtree( t1.getNode( "A" ), false );
7035             if ( t1.getNumberOfExternalNodes() != 5 ) {
7036                 return false;
7037             }
7038             t1.toNewHampshireX();
7039             t1.deleteSubtree( t1.getNode( "E" ), false );
7040             if ( t1.getNumberOfExternalNodes() != 4 ) {
7041                 return false;
7042             }
7043             t1.toNewHampshireX();
7044             t1.deleteSubtree( t1.getNode( "F" ), false );
7045             if ( t1.getNumberOfExternalNodes() != 3 ) {
7046                 return false;
7047             }
7048             t1.toNewHampshireX();
7049             t1.deleteSubtree( t1.getNode( "D" ), false );
7050             t1.toNewHampshireX();
7051             if ( t1.getNumberOfExternalNodes() != 3 ) {
7052                 return false;
7053             }
7054             t1.deleteSubtree( t1.getNode( "def" ), false );
7055             t1.toNewHampshireX();
7056             if ( t1.getNumberOfExternalNodes() != 2 ) {
7057                 return false;
7058             }
7059             t1.deleteSubtree( t1.getNode( "B" ), false );
7060             t1.toNewHampshireX();
7061             if ( t1.getNumberOfExternalNodes() != 1 ) {
7062                 return false;
7063             }
7064             t1.deleteSubtree( t1.getNode( "C" ), false );
7065             t1.toNewHampshireX();
7066             if ( t1.getNumberOfExternalNodes() != 1 ) {
7067                 return false;
7068             }
7069             t1.deleteSubtree( t1.getNode( "abc" ), false );
7070             t1.toNewHampshireX();
7071             if ( t1.getNumberOfExternalNodes() != 1 ) {
7072                 return false;
7073             }
7074             t1.deleteSubtree( t1.getNode( "r" ), false );
7075             if ( t1.getNumberOfExternalNodes() != 0 ) {
7076                 return false;
7077             }
7078             if ( !t1.isEmpty() ) {
7079                 return false;
7080             }
7081             final Phylogeny t2 = factory.create( "(((1,2,3)A,B,C)abc,(D,E,F)def)r", new NHXParser() )[ 0 ];
7082             t2.deleteSubtree( t2.getNode( "A" ), false );
7083             t2.toNewHampshireX();
7084             if ( t2.getNumberOfExternalNodes() != 5 ) {
7085                 return false;
7086             }
7087             t2.deleteSubtree( t2.getNode( "abc" ), false );
7088             t2.toNewHampshireX();
7089             if ( t2.getNumberOfExternalNodes() != 3 ) {
7090                 return false;
7091             }
7092             t2.deleteSubtree( t2.getNode( "def" ), false );
7093             t2.toNewHampshireX();
7094             if ( t2.getNumberOfExternalNodes() != 1 ) {
7095                 return false;
7096             }
7097         }
7098         catch ( final Exception e ) {
7099             e.printStackTrace( System.out );
7100             return false;
7101         }
7102         return true;
7103     }
7104
7105     private static boolean testSupportCount() {
7106         try {
7107             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
7108             final Phylogeny t0_1 = factory.create( "(((A,B),C),(D,E))", new NHXParser() )[ 0 ];
7109             final Phylogeny[] phylogenies_1 = factory.create( "(((A,B),C),(D,E)) " + "(((C,B),A),(D,E))"
7110                                                                       + "(((A,B),C),(D,E)) " + "(((A,B),C),(D,E))"
7111                                                                       + "(((A,B),C),(D,E))" + "(((C,B),A),(D,E))"
7112                                                                       + "(((E,B),D),(C,A))" + "(((C,B),A),(D,E))"
7113                                                                       + "(((A,B),C),(D,E))" + "(((A,B),C),(D,E))",
7114                                                               new NHXParser() );
7115             SupportCount.count( t0_1, phylogenies_1, true, false );
7116             final Phylogeny t0_2 = factory.create( "(((((A,B),C),D),E),(F,G))", new NHXParser() )[ 0 ];
7117             final Phylogeny[] phylogenies_2 = factory.create( "(((((A,B),C),D),E),(F,G))"
7118                                                                       + "(((((A,B),C),D),E),((F,G),X))"
7119                                                                       + "(((((A,Y),B),C),D),((F,G),E))"
7120                                                                       + "(((((A,B),C),D),E),(F,G))"
7121                                                                       + "(((((A,B),C),D),E),(F,G))"
7122                                                                       + "(((((A,B),C),D),E),(F,G))"
7123                                                                       + "(((((A,B),C),D),E),(F,G),Z)"
7124                                                                       + "(((((A,B),C),D),E),(F,G))"
7125                                                                       + "((((((A,B),C),D),E),F),G)"
7126                                                                       + "(((((X,Y),F,G),E),((A,B),C)),D)",
7127                                                               new NHXParser() );
7128             SupportCount.count( t0_2, phylogenies_2, true, false );
7129             final PhylogenyNodeIterator it = t0_2.iteratorPostorder();
7130             while ( it.hasNext() ) {
7131                 final PhylogenyNode n = it.next();
7132                 if ( !n.isExternal() && ( PhylogenyMethods.getConfidenceValue( n ) != 10 ) ) {
7133                     return false;
7134                 }
7135             }
7136             final Phylogeny t0_3 = factory.create( "(((A,B)ab,C)abc,((D,E)de,F)def)", new NHXParser() )[ 0 ];
7137             final Phylogeny[] phylogenies_3 = factory.create( "(((A,B),C),((D,E),F))" + "(((A,C),B),((D,F),E))"
7138                     + "(((C,A),B),((F,D),E))" + "(((A,B),F),((D,E),C))" + "(((((A,B),C),D),E),F)", new NHXParser() );
7139             SupportCount.count( t0_3, phylogenies_3, true, false );
7140             t0_3.reRoot( t0_3.getNode( "def" ).getId() );
7141             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "ab" ) ) != 3 ) {
7142                 return false;
7143             }
7144             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "abc" ) ) != 4 ) {
7145                 return false;
7146             }
7147             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "def" ) ) != 4 ) {
7148                 return false;
7149             }
7150             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "de" ) ) != 2 ) {
7151                 return false;
7152             }
7153             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "A" ) ) != 5 ) {
7154                 return false;
7155             }
7156             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "B" ) ) != 5 ) {
7157                 return false;
7158             }
7159             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "C" ) ) != 5 ) {
7160                 return false;
7161             }
7162             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "D" ) ) != 5 ) {
7163                 return false;
7164             }
7165             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "E" ) ) != 5 ) {
7166                 return false;
7167             }
7168             if ( PhylogenyMethods.getConfidenceValue( t0_3.getNode( "F" ) ) != 5 ) {
7169                 return false;
7170             }
7171             final Phylogeny t0_4 = factory.create( "(((((A,B)1,C)2,D)3,E)4,F)", new NHXParser() )[ 0 ];
7172             final Phylogeny[] phylogenies_4 = factory.create( "((((((A,X),C),B),D),E),F) "
7173                     + "(((A,B,Z),C,Q),(((D,Y),E),F))", new NHXParser() );
7174             SupportCount.count( t0_4, phylogenies_4, true, false );
7175             t0_4.reRoot( t0_4.getNode( "F" ).getId() );
7176             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "1" ) ) != 1 ) {
7177                 return false;
7178             }
7179             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "2" ) ) != 2 ) {
7180                 return false;
7181             }
7182             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "3" ) ) != 1 ) {
7183                 return false;
7184             }
7185             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "4" ) ) != 2 ) {
7186                 return false;
7187             }
7188             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "A" ) ) != 2 ) {
7189                 return false;
7190             }
7191             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "B" ) ) != 2 ) {
7192                 return false;
7193             }
7194             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "C" ) ) != 2 ) {
7195                 return false;
7196             }
7197             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "D" ) ) != 2 ) {
7198                 return false;
7199             }
7200             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "E" ) ) != 2 ) {
7201                 return false;
7202             }
7203             if ( PhylogenyMethods.getConfidenceValue( t0_4.getNode( "F" ) ) != 2 ) {
7204                 return false;
7205             }
7206             Phylogeny a = factory.create( "(((((A,B)1,C)2,D)3,E)4,F)", new NHXParser() )[ 0 ];
7207             final Phylogeny b1 = factory.create( "(((((B,A)1,C)2,D)3,E)4,F)", new NHXParser() )[ 0 ];
7208             double d = SupportCount.compare( b1, a, true, true, true );
7209             if ( !Test.isEqual( d, 5.0 / 5.0 ) ) {
7210                 return false;
7211             }
7212             a = factory.create( "(((((A,B)1,C)2,D)3,E)4,F)", new NHXParser() )[ 0 ];
7213             final Phylogeny b2 = factory.create( "(((((C,B)1,A)2,D)3,E)4,F)", new NHXParser() )[ 0 ];
7214             d = SupportCount.compare( b2, a, true, true, true );
7215             if ( !Test.isEqual( d, 4.0 / 5.0 ) ) {
7216                 return false;
7217             }
7218             a = factory.create( "(((((A,B)1,C)2,D)3,E)4,F)", new NHXParser() )[ 0 ];
7219             final Phylogeny b3 = factory.create( "(((((F,C)1,A)2,B)3,D)4,E)", new NHXParser() )[ 0 ];
7220             d = SupportCount.compare( b3, a, true, true, true );
7221             if ( !Test.isEqual( d, 2.0 / 5.0 ) ) {
7222                 return false;
7223             }
7224             a = factory.create( "(((((A,B)1,C)2,D)3,E)4,F)r", new NHXParser() )[ 0 ];
7225             final Phylogeny b4 = factory.create( "(((((F,C)1,A)2,B)3,D)4,E)r", new NHXParser() )[ 0 ];
7226             d = SupportCount.compare( b4, a, true, true, false );
7227             if ( !Test.isEqual( d, 1.0 / 5.0 ) ) {
7228                 return false;
7229             }
7230         }
7231         catch ( final Exception e ) {
7232             e.printStackTrace( System.out );
7233             return false;
7234         }
7235         return true;
7236     }
7237
7238     private static boolean testSupportTransfer() {
7239         try {
7240             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
7241             final Phylogeny p1 = factory.create( "(((A,B)ab:97,C)abc:57,((D,E)de:10,(F,G)fg:50,(H,I)hi:64)defghi)",
7242                                                  new NHXParser() )[ 0 ];
7243             final Phylogeny p2 = factory
7244                     .create( "(((A:0.1,B:0.3)ab:0.4,C)abc:0.5,((D,E)de,(F,G)fg,(H,I)hi:0.59)defghi)", new NHXParser() )[ 0 ];
7245             if ( PhylogenyMethods.getConfidenceValue( p2.getNode( "ab" ) ) >= 0.0 ) {
7246                 return false;
7247             }
7248             if ( PhylogenyMethods.getConfidenceValue( p2.getNode( "abc" ) ) >= 0.0 ) {
7249                 return false;
7250             }
7251             support_transfer.moveBranchLengthsToBootstrap( p1 );
7252             support_transfer.transferSupportValues( p1, p2 );
7253             if ( p2.getNode( "ab" ).getDistanceToParent() != 0.4 ) {
7254                 return false;
7255             }
7256             if ( p2.getNode( "abc" ).getDistanceToParent() != 0.5 ) {
7257                 return false;
7258             }
7259             if ( p2.getNode( "hi" ).getDistanceToParent() != 0.59 ) {
7260                 return false;
7261             }
7262             if ( PhylogenyMethods.getConfidenceValue( p2.getNode( "ab" ) ) != 97 ) {
7263                 return false;
7264             }
7265             if ( PhylogenyMethods.getConfidenceValue( p2.getNode( "abc" ) ) != 57 ) {
7266                 return false;
7267             }
7268             if ( PhylogenyMethods.getConfidenceValue( p2.getNode( "de" ) ) != 10 ) {
7269                 return false;
7270             }
7271             if ( PhylogenyMethods.getConfidenceValue( p2.getNode( "fg" ) ) != 50 ) {
7272                 return false;
7273             }
7274             if ( PhylogenyMethods.getConfidenceValue( p2.getNode( "hi" ) ) != 64 ) {
7275                 return false;
7276             }
7277         }
7278         catch ( final Exception e ) {
7279             e.printStackTrace( System.out );
7280             return false;
7281         }
7282         return true;
7283     }
7284
7285     private static boolean testTaxonomyAssigner() {
7286         try {
7287             String s0_str = "(((([&&NHX:S=A],[&&NHX:S=B])[&&NHX:S=AB],[&&NHX:S=C])[&&NHX:S=ABC],[&&NHX:S=D])[&&NHX:S=ABCD],[&&NHX:S=E])[&&NHX:S=ABCDE]";
7288             String g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=A])a,[&&NHX:S=B])b,[&&NHX:S=C])c";
7289             Phylogeny s0 = ParserBasedPhylogenyFactory.getInstance().create( s0_str, new NHXParser() )[ 0 ];
7290             Phylogeny g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7291             s0.setRooted( true );
7292             g0.setRooted( true );
7293             TaxonomyAssigner.execute( g0, s0 );
7294             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7295                 return false;
7296             }
7297             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "AB" ) ) {
7298                 return false;
7299             }
7300             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "ABC" ) ) {
7301                 return false;
7302             }
7303             g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=A])a,[&&NHX:S=A])b,[&&NHX:S=A])c";
7304             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7305             g0.setRooted( true );
7306             TaxonomyAssigner.execute( g0, s0 );
7307             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7308                 return false;
7309             }
7310             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7311                 return false;
7312             }
7313             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7314                 return false;
7315             }
7316             g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=B])a,[&&NHX:S=A])b,[&&NHX:S=A])c";
7317             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7318             g0.setRooted( true );
7319             TaxonomyAssigner.execute( g0, s0 );
7320             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "AB" ) ) {
7321                 return false;
7322             }
7323             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "AB" ) ) {
7324                 return false;
7325             }
7326             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "AB" ) ) {
7327                 return false;
7328             }
7329             g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=B])a,[&&NHX:S=C])b,[&&NHX:S=A])c";
7330             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7331             g0.setRooted( true );
7332             TaxonomyAssigner.execute( g0, s0 );
7333             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "AB" ) ) {
7334                 return false;
7335             }
7336             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ABC" ) ) {
7337                 return false;
7338             }
7339             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "ABC" ) ) {
7340                 return false;
7341             }
7342             g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=B])a,[&&NHX:S=C])b,[&&NHX:S=D])c";
7343             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7344             g0.setRooted( true );
7345             TaxonomyAssigner.execute( g0, s0 );
7346             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "AB" ) ) {
7347                 return false;
7348             }
7349             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ABC" ) ) {
7350                 return false;
7351             }
7352             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7353                 return false;
7354             }
7355             g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=E])a,[&&NHX:S=C])b,[&&NHX:S=D])c";
7356             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7357             g0.setRooted( true );
7358             TaxonomyAssigner.execute( g0, s0 );
7359             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCDE" ) ) {
7360                 return false;
7361             }
7362             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCDE" ) ) {
7363                 return false;
7364             }
7365             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCDE" ) ) {
7366                 return false;
7367             }
7368             g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=E])a,[&&NHX:S=A])b,[&&NHX:S=A])c";
7369             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7370             g0.setRooted( true );
7371             TaxonomyAssigner.execute( g0, s0 );
7372             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCDE" ) ) {
7373                 return false;
7374             }
7375             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCDE" ) ) {
7376                 return false;
7377             }
7378             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCDE" ) ) {
7379                 return false;
7380             }
7381             s0_str = "(([&&NHX:S=A],[&&NHX:S=B],[&&NHX:S=C],[&&NHX:S=D])[&&NHX:S=ABCD],"
7382                     + "([&&NHX:S=E],[&&NHX:S=F],[&&NHX:S=G],[&&NHX:S=H])[&&NHX:S=EFGH],"
7383                     + "([&&NHX:S=I],[&&NHX:S=J],[&&NHX:S=K],[&&NHX:S=L])[&&NHX:S=IJKL], "
7384                     + "([&&NHX:S=M],[&&NHX:S=N],[&&NHX:S=O],[&&NHX:S=P])[&&NHX:S=MNOP])[&&NHX:S=ROOT]";
7385             s0 = ParserBasedPhylogenyFactory.getInstance().create( s0_str, new NHXParser() )[ 0 ];
7386             s0.setRooted( true );
7387             g0_str = "(([&&NHX:S=A],[&&NHX:S=B],[&&NHX:S=C],[&&NHX:S=D])a,"
7388                     + "([&&NHX:S=E],[&&NHX:S=F],[&&NHX:S=G],[&&NHX:S=H])b,"
7389                     + "([&&NHX:S=I],[&&NHX:S=J],[&&NHX:S=K],[&&NHX:S=L])c, "
7390                     + "([&&NHX:S=M],[&&NHX:S=N],[&&NHX:S=O],[&&NHX:S=P])d)r";
7391             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7392             g0.setRooted( true );
7393             TaxonomyAssigner.execute( g0, s0 );
7394             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7395                 return false;
7396             }
7397             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "EFGH" ) ) {
7398                 return false;
7399             }
7400             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "IJKL" ) ) {
7401                 return false;
7402             }
7403             if ( !g0.getNode( "d" ).getNodeData().getTaxonomy().getScientificName().equals( "MNOP" ) ) {
7404                 return false;
7405             }
7406             if ( !g0.getNode( "r" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7407                 return false;
7408             }
7409             g0_str = "(([&&NHX:S=A],[&&NHX:S=B],[&&NHX:S=A],[&&NHX:S=B])a,"
7410                     + "([&&NHX:S=E],[&&NHX:S=F],[&&NHX:S=F],[&&NHX:S=F])b,"
7411                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=I])c, "
7412                     + "([&&NHX:S=M],[&&NHX:S=N],[&&NHX:S=O],[&&NHX:S=O])d)r";
7413             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7414             g0.setRooted( true );
7415             TaxonomyAssigner.execute( g0, s0 );
7416             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7417                 return false;
7418             }
7419             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "EFGH" ) ) {
7420                 return false;
7421             }
7422             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "IJKL" ) ) {
7423                 return false;
7424             }
7425             if ( !g0.getNode( "d" ).getNodeData().getTaxonomy().getScientificName().equals( "MNOP" ) ) {
7426                 return false;
7427             }
7428             if ( !g0.getNode( "r" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7429                 return false;
7430             }
7431             g0_str = "(([&&NHX:S=A],[&&NHX:S=B],[&&NHX:S=A],[&&NHX:S=B])a,"
7432                     + "([&&NHX:S=E],[&&NHX:S=F],[&&NHX:S=F],[&&NHX:S=F])b,"
7433                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])c, "
7434                     + "([&&NHX:S=M],[&&NHX:S=N],[&&NHX:S=A],[&&NHX:S=O])d)r";
7435             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7436             g0.setRooted( true );
7437             TaxonomyAssigner.execute( g0, s0 );
7438             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7439                 return false;
7440             }
7441             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "EFGH" ) ) {
7442                 return false;
7443             }
7444             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7445                 return false;
7446             }
7447             if ( !g0.getNode( "d" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7448                 return false;
7449             }
7450             if ( !g0.getNode( "r" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7451                 return false;
7452             }
7453             g0_str = "(([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])a,"
7454                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])b,"
7455                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])c, "
7456                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])d)r";
7457             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7458             g0.setRooted( true );
7459             TaxonomyAssigner.execute( g0, s0 );
7460             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7461                 return false;
7462             }
7463             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7464                 return false;
7465             }
7466             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7467                 return false;
7468             }
7469             if ( !g0.getNode( "d" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7470                 return false;
7471             }
7472             if ( !g0.getNode( "r" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7473                 return false;
7474             }
7475             g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=A])a,[&&NHX:S=A])b,[&&NHX:S=A])c";
7476             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7477             g0.setRooted( true );
7478             TaxonomyAssigner.execute( g0, s0 );
7479             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7480                 return false;
7481             }
7482             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7483                 return false;
7484             }
7485             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7486                 return false;
7487             }
7488             g0_str = "((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=B])a,[&&NHX:S=I])b,[&&NHX:S=J])c";
7489             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7490             g0.setRooted( true );
7491             TaxonomyAssigner.execute( g0, s0 );
7492             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7493                 return false;
7494             }
7495             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7496                 return false;
7497             }
7498             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7499                 return false;
7500             }
7501             g0_str = "(((([&&NHX:S=A],[&&NHX:S=B],[&&NHX:S=C],[&&NHX:S=D])a,"
7502                     + "([&&NHX:S=D],[&&NHX:S=C],[&&NHX:S=B],[&&NHX:S=A])b)ab,"
7503                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])c)abc, "
7504                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])d)r";
7505             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7506             g0.setRooted( true );
7507             TaxonomyAssigner.execute( g0, s0 );
7508             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7509                 return false;
7510             }
7511             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7512                 return false;
7513             }
7514             if ( !g0.getNode( "ab" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7515                 return false;
7516             }
7517             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7518                 return false;
7519             }
7520             if ( !g0.getNode( "abc" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7521                 return false;
7522             }
7523             if ( !g0.getNode( "d" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7524                 return false;
7525             }
7526             if ( !g0.getNode( "r" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7527                 return false;
7528             }
7529             g0_str = "(((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=C],[&&NHX:S=D])a,"
7530                     + "([&&NHX:S=D],[&&NHX:S=D],[&&NHX:S=B],[&&NHX:S=A])b)ab,"
7531                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])c)abc, "
7532                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])d)r";
7533             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7534             g0.setRooted( true );
7535             TaxonomyAssigner.execute( g0, s0 );
7536             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7537                 return false;
7538             }
7539             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7540                 return false;
7541             }
7542             if ( !g0.getNode( "ab" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7543                 return false;
7544             }
7545             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7546                 return false;
7547             }
7548             if ( !g0.getNode( "abc" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7549                 return false;
7550             }
7551             if ( !g0.getNode( "d" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7552                 return false;
7553             }
7554             if ( !g0.getNode( "r" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7555                 return false;
7556             }
7557             g0_str = "(((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=C],[&&NHX:S=D])a,"
7558                     + "([&&NHX:S=D],[&&NHX:S=D],[&&NHX:S=B],[&&NHX:S=A])b)ab,"
7559                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L])c)abc, "
7560                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=A])d)r";
7561             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7562             g0.setRooted( true );
7563             TaxonomyAssigner.execute( g0, s0 );
7564             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7565                 return false;
7566             }
7567             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7568                 return false;
7569             }
7570             if ( !g0.getNode( "ab" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7571                 return false;
7572             }
7573             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "L" ) ) {
7574                 return false;
7575             }
7576             if ( !g0.getNode( "abc" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7577                 return false;
7578             }
7579             if ( !g0.getNode( "d" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7580                 return false;
7581             }
7582             if ( !g0.getNode( "r" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7583                 return false;
7584             }
7585             g0_str = "(((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=C],[&&NHX:S=D])a,"
7586                     + "([&&NHX:S=D],[&&NHX:S=D],[&&NHX:S=B],[&&NHX:S=A])b)ab,"
7587                     + "([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=A])c)abc, "
7588                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=A])d)r";
7589             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7590             g0.setRooted( true );
7591             TaxonomyAssigner.execute( g0, s0 );
7592             if ( !g0.getNode( "a" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7593                 return false;
7594             }
7595             if ( !g0.getNode( "b" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7596                 return false;
7597             }
7598             if ( !g0.getNode( "ab" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7599                 return false;
7600             }
7601             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7602                 return false;
7603             }
7604             if ( !g0.getNode( "abc" ).getNodeData().getTaxonomy().getScientificName().equals( "ABCD" ) ) {
7605                 return false;
7606             }
7607             if ( !g0.getNode( "d" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7608                 return false;
7609             }
7610             if ( !g0.getNode( "r" ).getNodeData().getTaxonomy().getScientificName().equals( "ROOT" ) ) {
7611                 return false;
7612             }
7613             s0_str = "(([&&NHX:S=A],[&&NHX:S=B],[&&NHX:S=C],[&&NHX:S=D]),"
7614                     + "([&&NHX:S=E],[&&NHX:S=F],[&&NHX:S=G],[&&NHX:S=H]),"
7615                     + "([&&NHX:S=I],[&&NHX:S=J],[&&NHX:S=K],[&&NHX:S=L]), "
7616                     + "([&&NHX:S=M],[&&NHX:S=N],[&&NHX:S=O],[&&NHX:S=P]))";
7617             s0 = ParserBasedPhylogenyFactory.getInstance().create( s0_str, new NHXParser() )[ 0 ];
7618             s0.setRooted( true );
7619             g0_str = "(((([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=C],[&&NHX:S=D])a,"
7620                     + "([&&NHX:S=D],[&&NHX:S=D],[&&NHX:S=B],[&&NHX:S=A])b)ab,"
7621                     + "([&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=A],[&&NHX:S=A])c)abc, "
7622                     + "([&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=L],[&&NHX:S=A])d)r";
7623             g0 = ParserBasedPhylogenyFactory.getInstance().create( g0_str, new NHXParser() )[ 0 ];
7624             g0.setRooted( true );
7625             TaxonomyAssigner.execute( g0, s0 );
7626             if ( g0.getNode( "a" ).getNodeData().isHasTaxonomy() ) {
7627                 return false;
7628             }
7629             if ( !g0.getNode( "c" ).getNodeData().getTaxonomy().getScientificName().equals( "A" ) ) {
7630                 return false;
7631             }
7632         }
7633         catch ( final Exception e ) {
7634             e.printStackTrace( System.out );
7635             return false;
7636         }
7637         return true;
7638     }
7639
7640     private static boolean testUniprotTaxonomySearch() {
7641         try {
7642             List<UniProtTaxonomy> results = UniProtWsTools
7643                     .getTaxonomiesFromCommonNameStrict( "starlet sea anemone", 10 );
7644             if ( results.size() != 1 ) {
7645                 return false;
7646             }
7647             if ( !results.get( 0 ).getCode().equals( "NEMVE" ) ) {
7648                 return false;
7649             }
7650             if ( !results.get( 0 ).getCommonName().equalsIgnoreCase( "starlet sea anemone" ) ) {
7651                 return false;
7652             }
7653             if ( !results.get( 0 ).getId().equalsIgnoreCase( "45351" ) ) {
7654                 return false;
7655             }
7656             if ( !results.get( 0 ).getRank().equalsIgnoreCase( "species" ) ) {
7657                 return false;
7658             }
7659             if ( !results.get( 0 ).getScientificName().equals( "Nematostella vectensis" ) ) {
7660                 return false;
7661             }
7662             results = null;
7663             results = UniProtWsTools.getTaxonomiesFromScientificNameStrict( "Nematostella vectensis", 10 );
7664             if ( results.size() != 1 ) {
7665                 return false;
7666             }
7667             if ( !results.get( 0 ).getCode().equals( "NEMVE" ) ) {
7668                 return false;
7669             }
7670             if ( !results.get( 0 ).getCommonName().equalsIgnoreCase( "starlet sea anemone" ) ) {
7671                 return false;
7672             }
7673             if ( !results.get( 0 ).getId().equalsIgnoreCase( "45351" ) ) {
7674                 return false;
7675             }
7676             if ( !results.get( 0 ).getRank().equalsIgnoreCase( "species" ) ) {
7677                 return false;
7678             }
7679             if ( !results.get( 0 ).getScientificName().equals( "Nematostella vectensis" ) ) {
7680                 return false;
7681             }
7682             results = null;
7683             results = UniProtWsTools.getTaxonomiesFromId( "45351", 10 );
7684             if ( results.size() != 1 ) {
7685                 return false;
7686             }
7687             if ( !results.get( 0 ).getCode().equals( "NEMVE" ) ) {
7688                 return false;
7689             }
7690             if ( !results.get( 0 ).getCommonName().equalsIgnoreCase( "starlet sea anemone" ) ) {
7691                 return false;
7692             }
7693             if ( !results.get( 0 ).getId().equalsIgnoreCase( "45351" ) ) {
7694                 return false;
7695             }
7696             if ( !results.get( 0 ).getRank().equalsIgnoreCase( "species" ) ) {
7697                 return false;
7698             }
7699             if ( !results.get( 0 ).getScientificName().equals( "Nematostella vectensis" ) ) {
7700                 return false;
7701             }
7702             results = null;
7703             results = UniProtWsTools.getTaxonomiesFromTaxonomyCode( "NEMVE", 10 );
7704             if ( results.size() != 1 ) {
7705                 return false;
7706             }
7707             if ( !results.get( 0 ).getCode().equals( "NEMVE" ) ) {
7708                 return false;
7709             }
7710             if ( !results.get( 0 ).getCommonName().equalsIgnoreCase( "starlet sea anemone" ) ) {
7711                 return false;
7712             }
7713             if ( !results.get( 0 ).getId().equalsIgnoreCase( "45351" ) ) {
7714                 return false;
7715             }
7716             if ( !results.get( 0 ).getRank().equalsIgnoreCase( "species" ) ) {
7717                 return false;
7718             }
7719             if ( !results.get( 0 ).getScientificName().equals( "Nematostella vectensis" ) ) {
7720                 return false;
7721             }
7722             if ( !results.get( 0 ).getLineage()[ 0 ].equals( "Eukaryota" ) ) {
7723                 return false;
7724             }
7725             if ( !results.get( 0 ).getLineage()[ 1 ].equals( "Metazoa" ) ) {
7726                 return false;
7727             }
7728             if ( !results.get( 0 ).getLineage()[ results.get( 0 ).getLineage().length - 1 ].equals( "Nematostella" ) ) {
7729                 return false;
7730             }
7731         }
7732         catch ( final IOException e ) {
7733             System.out.println();
7734             System.out.println( "the following might be due to absence internet connection:" );
7735             e.printStackTrace( System.out );
7736             return true;
7737         }
7738         catch ( final Exception e ) {
7739             return false;
7740         }
7741         return true;
7742     }
7743
7744     private static boolean testEmblEntryRetrieval() {
7745         //The format for GenBank Accession numbers are:
7746         //Nucleotide: 1 letter + 5 numerals OR 2 letters + 6 numerals
7747         //Protein:    3 letters + 5 numerals
7748         //http://www.ncbi.nlm.nih.gov/Sequin/acc.html
7749         if ( !DatabaseTools.parseGenbankAccessor( "AY423861" ).equals( "AY423861" ) ) {
7750             return false;
7751         }
7752         if ( !DatabaseTools.parseGenbankAccessor( ".AY423861." ).equals( "AY423861" ) ) {
7753             return false;
7754         }
7755         if ( DatabaseTools.parseGenbankAccessor( "AAY423861" ) != null ) {
7756             return false;
7757         }
7758         if ( DatabaseTools.parseGenbankAccessor( "AY4238612" ) != null ) {
7759             return false;
7760         }
7761         if ( DatabaseTools.parseGenbankAccessor( "AAY4238612" ) != null ) {
7762             return false;
7763         }
7764         if ( DatabaseTools.parseGenbankAccessor( "Y423861" ) != null ) {
7765             return false;
7766         }
7767         if ( !DatabaseTools.parseGenbankAccessor( "S12345" ).equals( "S12345" ) ) {
7768             return false;
7769         }
7770         if ( !DatabaseTools.parseGenbankAccessor( "|S12345|" ).equals( "S12345" ) ) {
7771             return false;
7772         }
7773         if ( DatabaseTools.parseGenbankAccessor( "|S123456" ) != null ) {
7774             return false;
7775         }
7776         if ( DatabaseTools.parseGenbankAccessor( "ABC123456" ) != null ) {
7777             return false;
7778         }
7779         if ( !DatabaseTools.parseGenbankAccessor( "ABC12345" ).equals( "ABC12345" ) ) {
7780             return false;
7781         }
7782         if ( !DatabaseTools.parseGenbankAccessor( "&ABC12345&" ).equals( "ABC12345" ) ) {
7783             return false;
7784         }
7785         if ( DatabaseTools.parseGenbankAccessor( "ABCD12345" ) != null ) {
7786             return false;
7787         }
7788         return true;
7789     }
7790
7791     private static boolean testUniprotEntryRetrieval() {
7792         if ( !UniProtWsTools.parseUniProtAccessor( "P12345" ).equals( "P12345" ) ) {
7793             return false;
7794         }
7795         if ( UniProtWsTools.parseUniProtAccessor( "EP12345" ) != null ) {
7796             return false;
7797         }
7798         if ( UniProtWsTools.parseUniProtAccessor( "3 4P12345" ) != null ) {
7799             return false;
7800         }
7801         if ( UniProtWsTools.parseUniProtAccessor( "P12345E" ) != null ) {
7802             return false;
7803         }
7804         if ( UniProtWsTools.parseUniProtAccessor( "P123455" ) != null ) {
7805             return false;
7806         }
7807         if ( UniProtWsTools.parseUniProtAccessor( "EP12345E" ) != null ) {
7808             return false;
7809         }
7810         if ( UniProtWsTools.parseUniProtAccessor( "AY423861" ) != null ) {
7811             return false;
7812         }
7813         if ( !UniProtWsTools.parseUniProtAccessor( "P1DDD5" ).equals( "P1DDD5" ) ) {
7814             return false;
7815         }
7816         if ( UniProtWsTools.parseUniProtAccessor( "P1DDDD" ) != null ) {
7817             return false;
7818         }
7819         if ( !UniProtWsTools.parseUniProtAccessor( "P1234X/P12345/12-42" ).equals( "P12345" ) ) {
7820             return false;
7821         }
7822         if ( !UniProtWsTools.parseUniProtAccessor( "P1234X P12345 12-42" ).equals( "P12345" ) ) {
7823             return false;
7824         }
7825         if ( !UniProtWsTools.parseUniProtAccessor( "P12345/12-42" ).equals( "P12345" ) ) {
7826             return false;
7827         }
7828         if ( !UniProtWsTools.parseUniProtAccessor( "P1234X/P12345" ).equals( "P12345" ) ) {
7829             return false;
7830         }
7831         try {
7832             final SequenceDatabaseEntry entry = UniProtWsTools.obtainUniProtEntry( "P12345", 200 );
7833             if ( !entry.getAccession().equals( "P12345" ) ) {
7834                 return false;
7835             }
7836             if ( !entry.getTaxonomyScientificName().equals( "Oryctolagus cuniculus" ) ) {
7837                 return false;
7838             }
7839             if ( !entry.getSequenceName().equals( "Aspartate aminotransferase, mitochondrial" ) ) {
7840                 return false;
7841             }
7842             if ( !entry.getSequenceSymbol().equals( "GOT2" ) ) {
7843                 return false;
7844             }
7845             if ( !entry.getTaxonomyIdentifier().equals( "9986" ) ) {
7846                 return false;
7847             }
7848         }
7849         catch ( final IOException e ) {
7850             System.out.println();
7851             System.out.println( "the following might be due to absence internet connection:" );
7852             e.printStackTrace( System.out );
7853             return true;
7854         }
7855         catch ( final Exception e ) {
7856             return false;
7857         }
7858         return true;
7859     }
7860
7861     private static boolean testWabiTxSearch() {
7862         try {
7863             String result = "";
7864             result = TxSearch.searchSimple( "nematostella" );
7865             result = TxSearch.getTxId( "nematostella" );
7866             if ( !result.equals( "45350" ) ) {
7867                 return false;
7868             }
7869             result = TxSearch.getTxName( "45350" );
7870             if ( !result.equals( "Nematostella" ) ) {
7871                 return false;
7872             }
7873             result = TxSearch.getTxId( "nematostella vectensis" );
7874             if ( !result.equals( "45351" ) ) {
7875                 return false;
7876             }
7877             result = TxSearch.getTxName( "45351" );
7878             if ( !result.equals( "Nematostella vectensis" ) ) {
7879                 return false;
7880             }
7881             result = TxSearch.getTxId( "Bacillus subtilis subsp. subtilis str. N170" );
7882             if ( !result.equals( "536089" ) ) {
7883                 return false;
7884             }
7885             result = TxSearch.getTxName( "536089" );
7886             if ( !result.equals( "Bacillus subtilis subsp. subtilis str. N170" ) ) {
7887                 return false;
7888             }
7889             final List<String> queries = new ArrayList<String>();
7890             queries.add( "Campylobacter coli" );
7891             queries.add( "Escherichia coli" );
7892             queries.add( "Arabidopsis" );
7893             queries.add( "Trichoplax" );
7894             queries.add( "Samanea saman" );
7895             queries.add( "Kluyveromyces marxianus" );
7896             queries.add( "Bacillus subtilis subsp. subtilis str. N170" );
7897             queries.add( "Bornavirus parrot/PDD/2008" );
7898             final List<RANKS> ranks = new ArrayList<RANKS>();
7899             ranks.add( RANKS.SUPERKINGDOM );
7900             ranks.add( RANKS.KINGDOM );
7901             ranks.add( RANKS.FAMILY );
7902             ranks.add( RANKS.GENUS );
7903             ranks.add( RANKS.TRIBE );
7904             result = TxSearch.searchLineage( queries, ranks );
7905             result = TxSearch.searchParam( "Homo sapiens", TAX_NAME_CLASS.ALL, TAX_RANK.SPECIES, 10, true );
7906             result = TxSearch.searchParam( "Samanea saman", TAX_NAME_CLASS.SCIENTIFIC_NAME, TAX_RANK.ALL, 10, true );
7907         }
7908         catch ( final Exception e ) {
7909             System.out.println();
7910             System.out.println( "the following might be due to absence internet connection:" );
7911             e.printStackTrace( System.out );
7912             return false;
7913         }
7914         return true;
7915     }
7916
7917     private static boolean testAminoAcidSequence() {
7918         try {
7919             final Sequence aa1 = BasicSequence.createAaSequence( "aa1", "aAklm-?xX*z$#" );
7920             if ( aa1.getLength() != 13 ) {
7921                 return false;
7922             }
7923             if ( aa1.getResidueAt( 0 ) != 'A' ) {
7924                 return false;
7925             }
7926             if ( aa1.getResidueAt( 2 ) != 'K' ) {
7927                 return false;
7928             }
7929             if ( !new String( aa1.getMolecularSequence() ).equals( "AAKLM-XXX*ZXX" ) ) {
7930                 return false;
7931             }
7932             final Sequence aa2 = BasicSequence.createAaSequence( "aa3", "ARNDCQEGHILKMFPSTWYVX*-BZOJU" );
7933             if ( !new String( aa2.getMolecularSequence() ).equals( "ARNDCQEGHILKMFPSTWYVX*-BZXXU" ) ) {
7934                 return false;
7935             }
7936             final Sequence dna1 = BasicSequence.createDnaSequence( "dna1", "ACGTUX*-?RYMKWSN" );
7937             if ( !new String( dna1.getMolecularSequence() ).equals( "ACGTNN*-NRYMKWSN" ) ) {
7938                 return false;
7939             }
7940             final Sequence rna1 = BasicSequence.createRnaSequence( "rna1", "..ACGUTX*-?RYMKWSN" );
7941             if ( !new String( rna1.getMolecularSequence() ).equals( "--ACGUNN*-NRYMKWSN" ) ) {
7942                 return false;
7943             }
7944         }
7945         catch ( final Exception e ) {
7946             e.printStackTrace();
7947             return false;
7948         }
7949         return true;
7950     }
7951
7952     private static boolean testCreateBalancedPhylogeny() {
7953         try {
7954             final Phylogeny p0 = DevelopmentTools.createBalancedPhylogeny( 6, 5 );
7955             if ( p0.getRoot().getNumberOfDescendants() != 5 ) {
7956                 return false;
7957             }
7958             if ( p0.getNumberOfExternalNodes() != 15625 ) {
7959                 return false;
7960             }
7961             final Phylogeny p1 = DevelopmentTools.createBalancedPhylogeny( 2, 10 );
7962             if ( p1.getRoot().getNumberOfDescendants() != 10 ) {
7963                 return false;
7964             }
7965             if ( p1.getNumberOfExternalNodes() != 100 ) {
7966                 return false;
7967             }
7968         }
7969         catch ( final Exception e ) {
7970             e.printStackTrace();
7971             return false;
7972         }
7973         return true;
7974     }
7975
7976     private static boolean testFastaParser() {
7977         try {
7978             if ( !FastaParser.isLikelyFasta( new FileInputStream( PATH_TO_TEST_DATA + "fasta_0.fasta" ) ) ) {
7979                 return false;
7980             }
7981             if ( FastaParser.isLikelyFasta( new FileInputStream( PATH_TO_TEST_DATA + "msa_3.txt" ) ) ) {
7982                 return false;
7983             }
7984             final Msa msa_0 = FastaParser.parseMsa( new FileInputStream( PATH_TO_TEST_DATA + "fasta_0.fasta" ) );
7985             if ( !msa_0.getSequenceAsString( 0 ).toString().equalsIgnoreCase( "ACGTGKXFMFDMXEXXXSFMFMF" ) ) {
7986                 return false;
7987             }
7988             if ( !msa_0.getIdentifier( 0 ).equals( "one dumb" ) ) {
7989                 return false;
7990             }
7991             if ( !msa_0.getSequenceAsString( 1 ).toString().equalsIgnoreCase( "DKXASDFXSFXFKFKSXDFKSLX" ) ) {
7992                 return false;
7993             }
7994             if ( !msa_0.getSequenceAsString( 2 ).toString().equalsIgnoreCase( "SXDFKSXLFSFPWEXPRXWXERR" ) ) {
7995                 return false;
7996             }
7997             if ( !msa_0.getSequenceAsString( 3 ).toString().equalsIgnoreCase( "AAAAAAAAAAAAAAAAAAAAAAA" ) ) {
7998                 return false;
7999             }
8000             if ( !msa_0.getSequenceAsString( 4 ).toString().equalsIgnoreCase( "DDDDDDDDDDDDDDDDDDDDAXF" ) ) {
8001                 return false;
8002             }
8003         }
8004         catch ( final Exception e ) {
8005             e.printStackTrace();
8006             return false;
8007         }
8008         return true;
8009     }
8010
8011     private static boolean testGeneralMsaParser() {
8012         try {
8013             final String msa_str_0 = "seq1 abcd\n\nseq2 efgh\n";
8014             final Msa msa_0 = GeneralMsaParser.parse( new ByteArrayInputStream( msa_str_0.getBytes() ) );
8015             final String msa_str_1 = "seq_1 abc\nseq2 ghi\nseq_1 def\nseq2 jkm\n";
8016             final Msa msa_1 = GeneralMsaParser.parse( new ByteArrayInputStream( msa_str_1.getBytes() ) );
8017             final String msa_str_2 = "seq1 abc\nseq2 ghi\n\ndef\njkm\n";
8018             final Msa msa_2 = GeneralMsaParser.parse( new ByteArrayInputStream( msa_str_2.getBytes() ) );
8019             final String msa_str_3 = "seq1 abc\n def\nseq2 ghi\n jkm\n";
8020             final Msa msa_3 = GeneralMsaParser.parse( new ByteArrayInputStream( msa_str_3.getBytes() ) );
8021             final Msa msa_4 = GeneralMsaParser.parse( new FileInputStream( PATH_TO_TEST_DATA + "msa_1.txt" ) );
8022             if ( !msa_4.getSequenceAsString( 0 ).toString().equalsIgnoreCase( "abcdefeeeeeeeexx" ) ) {
8023                 return false;
8024             }
8025             if ( !msa_4.getSequenceAsString( 1 ).toString().equalsIgnoreCase( "efghixffffffffyy" ) ) {
8026                 return false;
8027             }
8028             if ( !msa_4.getSequenceAsString( 2 ).toString().equalsIgnoreCase( "klmnxphhhhhhhhzz" ) ) {
8029                 return false;
8030             }
8031             final Msa msa_5 = GeneralMsaParser.parse( new FileInputStream( PATH_TO_TEST_DATA + "msa_2.txt" ) );
8032             if ( !msa_5.getSequenceAsString( 0 ).toString().equalsIgnoreCase( "abcdefxx" ) ) {
8033                 return false;
8034             }
8035             if ( !msa_5.getSequenceAsString( 1 ).toString().equalsIgnoreCase( "efghixyy" ) ) {
8036                 return false;
8037             }
8038             if ( !msa_5.getSequenceAsString( 2 ).toString().equalsIgnoreCase( "klmnxpzz" ) ) {
8039                 return false;
8040             }
8041             final Msa msa_6 = GeneralMsaParser.parse( new FileInputStream( PATH_TO_TEST_DATA + "msa_3.txt" ) );
8042             if ( !msa_6.getSequenceAsString( 0 ).toString().equalsIgnoreCase( "abcdefeeeeeeeexx" ) ) {
8043                 return false;
8044             }
8045             if ( !msa_6.getSequenceAsString( 1 ).toString().equalsIgnoreCase( "efghixffffffffyy" ) ) {
8046                 return false;
8047             }
8048             if ( !msa_6.getSequenceAsString( 2 ).toString().equalsIgnoreCase( "klmnxphhhhhhhhzz" ) ) {
8049                 return false;
8050             }
8051         }
8052         catch ( final Exception e ) {
8053             e.printStackTrace();
8054             return false;
8055         }
8056         return true;
8057     }
8058
8059     private static boolean testMafft() {
8060         try {
8061             final List<String> opts = new ArrayList<String>();
8062             opts.add( "--maxiterate" );
8063             opts.add( "1000" );
8064             opts.add( "--localpair" );
8065             opts.add( "--quiet" );
8066             Msa msa = null;
8067             final MsaInferrer mafft = Mafft.createInstance();
8068             msa = mafft.infer( new File( PATH_TO_TEST_DATA + "ncbi.fasta" ), opts );
8069             if ( ( msa == null ) || ( msa.getLength() < 10 ) || ( msa.getNumberOfSequences() != 19 ) ) {
8070                 return false;
8071             }
8072         }
8073         catch ( final Exception e ) {
8074             e.printStackTrace( System.out );
8075             return false;
8076         }
8077         return true;
8078     }
8079 }