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