platform/platform-impl/testSrc/com/intellij/ide/util/treeView/TreeUiTest.java

   1 package com.intellij.ide.util.treeView;
   2
   3 import com.intellij.openapi.util.Disposer;
   4 import com.intellij.openapi.util.Ref;
   5 import com.intellij.util.Time;
   6 import com.intellij.util.WaitFor;
   7 import com.intellij.util.ui.UIUtil;
   8 import junit.framework.TestSuite;
   9
  10 import javax.swing.*;
  11 import javax.swing.tree.DefaultMutableTreeNode;
  12 import javax.swing.tree.TreePath;
  13
  14 public class TreeUiTest extends AbstractTreeBuilderTest {
  15
  16   public TreeUiTest(boolean passthrougth) {
  17     super(passthrougth);
  18   }
  19
  20   public TreeUiTest(boolean yieldingUiBuild, boolean bgStructureBuilding) {
  21     super(yieldingUiBuild, bgStructureBuilding);
  22   }
  23
  24   public void testEmptyInvisibleRoot() throws Exception {
  25     myTree.setRootVisible(false);
  26     showTree();
  27     assertTree("+/\n");
  28
  29     updateFromRoot();
  30     assertTree("+/\n");
  31
  32
  33     buildNode("/", false);
  34     assertTree("+/\n");
  35
  36     myTree.setRootVisible(true);
  37     buildNode("/", false);
  38     assertTree("/\n");
  39   }
  40
  41   public void testVisibleRoot() throws Exception {
  42     myTree.setRootVisible(true);
  43     buildStructure(myRoot);
  44     assertTree("+/\n");
  45
  46     updateFromRoot();
  47     assertTree("+/\n");
  48   }
  49
  50   public void testInvisibleRoot() throws Exception {
  51     myTree.setRootVisible(false);
  52     buildStructure(myRoot);
  53     assertTree("-/\n"
  54                + " +com\n"
  55                + " +jetbrains\n"
  56                + " +org\n"
  57                + " +xunit\n");
  58
  59     collapsePath(new TreePath(myTreeModel.getRoot()));
  60     assertTree("+/\n");
  61
  62     updateFromRoot();
  63     assertTree("-/\n"
  64                + " +com\n"
  65                + " +jetbrains\n"
  66                + " +org\n"
  67                + " +xunit\n");
  68
  69     buildNode("com", true);
  70     assertTree("-/\n"
  71                + " +[com]\n"
  72                + " +jetbrains\n"
  73                + " +org\n"
  74                + " +xunit\n");
  75
  76     myRoot.removeAll();
  77     updateFromRoot();
  78
  79     assertTree("+/\n");
  80
  81   }
  82
  83   public void testAutoExpand() throws Exception {
  84     buildStructure(myRoot);
  85     assertTree("+/\n");
  86
  87     myAutoExpand.add(new NodeElement("/"));
  88     buildStructure(myRoot);
  89
  90     assertTree("-/\n"
  91                + " +com\n"
  92                + " +jetbrains\n"
  93                + " +org\n"
  94                + " +xunit\n");
  95
  96
  97     myAutoExpand.add(new NodeElement("jetbrains"));
  98     updateFromRoot();
  99
 100     assertTree("-/\n"
 101                + " +com\n"
 102                + " -jetbrains\n"
 103                + "  +fabrique\n"
 104                + " +org\n"
 105                + " +xunit\n");
 106
 107     collapsePath(getPath("jetbrains"));
 108     assertTree("-/\n"
 109                + " +com\n"
 110                + " +jetbrains\n"
 111                + " +org\n"
 112                + " +xunit\n");
 113
 114     updateFrom(new NodeElement("org"));
 115     assertTree("-/\n"
 116                + " +com\n"
 117                + " +jetbrains\n"
 118                + " +org\n"
 119                + " +xunit\n");
 120
 121     updateFrom(new NodeElement("jetbrains"));
 122     assertTree("-/\n"
 123                + " +com\n"
 124                + " -jetbrains\n"
 125                + "  +fabrique\n"
 126                + " +org\n"
 127                + " +xunit\n");
 128   }
 129
 130   public void testAutoExpandDeep() throws Exception {
 131     myTree.setRootVisible(false);
 132     //myAutoExpand.add(new NodeElement("jetbrains"));
 133     myAutoExpand.add(new NodeElement("fabrique"));
 134
 135
 136     buildStructure(myRoot);
 137     //assertTree("+/\n");
 138
 139     expand(getPath("/"));
 140     expand(getPath("jetbrains"));
 141     assertTree("-/\n"
 142                + " +com\n"
 143                + " -jetbrains\n"
 144                + "  -fabrique\n"
 145                + "   ide\n"
 146                + " +org\n"
 147                + " +xunit\n");
 148
 149     collapsePath(getPath("/"));
 150     assertTree("+/\n");
 151
 152     expand(getPath("/"));
 153     expand(getPath("jetbrains"));
 154
 155     assertTree("-/\n"
 156                + " +com\n"
 157                + " -jetbrains\n"
 158                + "  -fabrique\n"
 159                + "   ide\n"
 160                + " +org\n"
 161                + " +xunit\n");
 162
 163     collapsePath(getPath("jetbrains"));
 164     assertTree("-/\n"
 165                + " +com\n"
 166                + " +jetbrains\n"
 167                + " +org\n"
 168                + " +xunit\n");
 169
 170     expand(getPath("jetbrains"));
 171     assertTree("-/\n"
 172                + " +com\n"
 173                + " -jetbrains\n"
 174                + "  -fabrique\n"
 175                + "   ide\n"
 176                + " +org\n"
 177                + " +xunit\n");
 178
 179   }
 180
 181
 182   public void testAutoExpandInNonVisibleNode() throws Exception {
 183     myAutoExpand.add(new NodeElement("fabrique"));
 184     buildStructure(myRoot);
 185
 186     expand(getPath("/"));
 187     assertTree("-/\n"
 188                + " +com\n"
 189                + " +jetbrains\n"
 190                + " +org\n"
 191                + " +xunit\n");
 192   }
 193
 194   public void testSmartExpand() throws Exception {
 195     mySmartExpand = true;
 196     buildStructure(myRoot);
 197     assertTree("+/\n");
 198
 199     expand(getPath("/"));
 200     assertTree("-/\n"
 201                + " +com\n"
 202                + " +jetbrains\n"
 203                + " +org\n"
 204                + " +xunit\n");
 205
 206     expand(getPath("jetbrains"));
 207     assertTree("-/\n"
 208                + " +com\n"
 209                + " -jetbrains\n"
 210                + "  -fabrique\n"
 211                + "   ide\n"
 212                + " +org\n"
 213                + " +xunit\n");
 214
 215     collapsePath(getPath("jetbrains"));
 216     assertTree("-/\n"
 217                + " +com\n"
 218                + " +jetbrains\n"
 219                + " +org\n"
 220                + " +xunit\n");
 221
 222     updateFromRoot();
 223     assertTree("-/\n"
 224                + " +com\n"
 225                + " +jetbrains\n"
 226                + " +org\n"
 227                + " +xunit\n");
 228
 229     mySmartExpand = false;
 230     collapsePath(getPath("jetbrains"));
 231     assertTree("-/\n"
 232                + " +com\n"
 233                + " +jetbrains\n"
 234                + " +org\n"
 235                + " +xunit\n");
 236
 237     expand(getPath("jetbrains"));
 238     assertTree("-/\n"
 239                + " +com\n"
 240                + " -jetbrains\n"
 241                + "  +fabrique\n"
 242                + " +org\n"
 243                + " +xunit\n");
 244   }
 245
 246
 247   public void testClear() throws Exception {
 248     getBuilder().getUi().setClearOnHideDelay(10 * Time.SECOND);
 249
 250     buildStructure(myRoot);
 251
 252     assertTree("+/\n");
 253
 254     final DefaultMutableTreeNode openApiNode = findNode("openapi", false);
 255     final DefaultMutableTreeNode ideNode = findNode("ide", false);
 256     final DefaultMutableTreeNode runnerNode = findNode("runner", false);
 257     final DefaultMutableTreeNode rcpNode = findNode("rcp", false);
 258
 259     assertNull(openApiNode);
 260     assertNull(ideNode);
 261     assertNull(runnerNode);
 262     assertNull(rcpNode);
 263
 264     buildNode(myOpenApi, true);
 265     buildNode(myIde, true);
 266     buildNode(myRunner, false);
 267
 268     hideTree();
 269
 270     assertNull(findNode("openapi", true));
 271     assertNull(findNode("ide", true));
 272     assertNull(findNode("runner", false));
 273     assertNull(findNode("rcp", false));
 274
 275
 276     showTree();
 277
 278     assertTree("-/\n" +
 279                " -com\n" +
 280                "  -intellij\n" +
 281                "   [openapi]\n" +
 282                " -jetbrains\n" +
 283                "  -fabrique\n" +
 284                "   [ide]\n" +
 285                " +org\n" +
 286                " -xunit\n" +
 287                "  runner\n");
 288
 289     getMyBuilder().myWasCleanedUp = false;
 290     hideTree();
 291     showTree();
 292
 293     assertTree("-/\n" +
 294                " -com\n" +
 295                "  -intellij\n" +
 296                "   [openapi]\n" +
 297                " -jetbrains\n" +
 298                "  -fabrique\n" +
 299                "   [ide]\n" +
 300                " +org\n" +
 301                " -xunit\n" +
 302                "  runner\n");
 303
 304
 305     buildNode(myFabrique.myElement, true, false);
 306     assertTree("-/\n" +
 307                " -com\n" +
 308                "  -intellij\n" +
 309                "   openapi\n" +
 310                " -jetbrains\n" +
 311                "  -[fabrique]\n" +
 312                "   ide\n" +
 313                " +org\n" +
 314                " -xunit\n" +
 315                "  runner\n");
 316   }
 317
 318   public void testUpdateRestoresState() throws Exception {
 319     buildStructure(myRoot);
 320
 321     buildNode(myOpenApi, true);
 322     buildNode(myIde, true);
 323     buildNode(myRunner, false);
 324
 325     waitBuilderToCome();
 326
 327     assertTree("-/\n" +
 328                " -com\n" +
 329                "  -intellij\n" +
 330                "   [openapi]\n" +
 331                " -jetbrains\n" +
 332                "  -fabrique\n" +
 333                "   [ide]\n" +
 334                " +org\n" +
 335                " -xunit\n" +
 336                "  runner\n");
 337
 338     myRoot.removeAll();
 339     myStructure.clear();
 340
 341     final AbstractTreeBuilderTest.Node newRoot = myRoot.addChild("newRoot");
 342
 343     buildStructure(newRoot);
 344
 345     updateFromRoot();
 346     assertTree("-/\n" +
 347                " -newRoot\n" +
 348                "  -com\n" +
 349                "   -intellij\n" +
 350                "    [openapi]\n" +
 351                "  -jetbrains\n" +
 352                "   -fabrique\n" +
 353                "    [ide]\n" +
 354                "  +org\n" +
 355                "  -xunit\n" +
 356                "   runner\n");
 357   }
 358
 359
 360   public void testSelect() throws Exception {
 361     buildStructure(myRoot);
 362     assertTree(
 363       "+/\n");
 364
 365
 366     buildNode(myOpenApi, true);
 367     assertTree(
 368       "-/\n" +
 369       " -com\n" +
 370       "  -intellij\n" +
 371       "   [openapi]\n" +
 372       " +jetbrains\n" +
 373       " +org\n" +
 374       " +xunit\n");
 375
 376     buildNode("fabrique", true);
 377
 378     assertTree(
 379       "-/\n" +
 380       " -com\n" +
 381       "  -intellij\n" +
 382       "   [openapi]\n" +
 383       " -jetbrains\n" +
 384       "  +[fabrique]\n" +
 385       " +org\n" +
 386       " +xunit\n");
 387   }
 388
 389   public void testCallbackOnceOnSelect() throws Exception {
 390     buildStructure(myRoot);
 391
 392     assertCallbackOnce(new TreeAction() {
 393       public void run(Runnable onDone) {
 394         getMyBuilder().select(new Object[] {new NodeElement("intellij"), new NodeElement("fabrique")}, onDone);
 395       }
 396     });
 397
 398     assertTree(
 399       "-/\n" +
 400       " -com\n" +
 401       "  +[intellij]\n" +
 402       " -jetbrains\n" +
 403       "  +[fabrique]\n" +
 404       " +org\n" +
 405       " +xunit\n");
 406
 407   }
 408
 409   public void testCallbackOnceOnExpand() throws Exception {
 410     buildStructure(myRoot);
 411
 412     assertCallbackOnce(new TreeAction() {
 413       public void run(Runnable onDone) {
 414         getMyBuilder().expand(new Object[] {new NodeElement("intellij"), new NodeElement("fabrique")}, onDone);
 415       }
 416     });
 417
 418     assertTree(
 419       "-/\n" +
 420       " -com\n" +
 421       "  -intellij\n" +
 422       "   openapi\n" +
 423       " -jetbrains\n" +
 424       "  -fabrique\n" +
 425       "   ide\n" +
 426       " +org\n" +
 427       " +xunit\n");
 428
 429   }
 430
 431
 432   public void testNoInfiniteAutoExpand() throws Exception {
 433     mySmartExpand = false;
 434
 435     assertNoInfiniteAutoExpand(new Runnable() {
 436       public void run() {
 437         myAutoExpand.add(new NodeElement("level2"));
 438         myAutoExpand.add(new NodeElement("level3"));
 439         myAutoExpand.add(new NodeElement("level4"));
 440         myAutoExpand.add(new NodeElement("level5"));
 441         myAutoExpand.add(new NodeElement("level6"));
 442         myAutoExpand.add(new NodeElement("level7"));
 443         myAutoExpand.add(new NodeElement("level8"));
 444         myAutoExpand.add(new NodeElement("level9"));
 445         myAutoExpand.add(new NodeElement("level10"));
 446         myAutoExpand.add(new NodeElement("level11"));
 447         myAutoExpand.add(new NodeElement("level12"));
 448         myAutoExpand.add(new NodeElement("level13"));
 449         myAutoExpand.add(new NodeElement("level14"));
 450         myAutoExpand.add(new NodeElement("level15"));
 451       }
 452     });
 453   }
 454
 455   public void testNoInfiniteSmartExpand() throws Exception {
 456     mySmartExpand = false;
 457
 458     assertNoInfiniteAutoExpand(new Runnable() {
 459       public void run() {
 460         mySmartExpand = true;
 461       }
 462     });
 463   }
 464
 465   private void assertNoInfiniteAutoExpand(final Runnable enableExpand) throws Exception {
 466     class Level extends Node {
 467
 468       int myLevel;
 469
 470       Level(Node parent, int level) {
 471         super(parent, "level" + level);
 472         myLevel = level;
 473       }
 474
 475       @Override
 476       public Object[] getChildElements() {
 477         if (super.getChildElements().length == 0) {
 478           addChild(new Level(this, myLevel + 1));
 479         }
 480
 481         return super.getChildElements();
 482       }
 483     }
 484
 485     myRoot.addChild(new Level(myRoot, 0));
 486
 487     activate();
 488     buildNode("level0", false);
 489
 490     assertTree("-/\n" +
 491                " -level0\n" +
 492                "  +level1\n");
 493
 494     enableExpand.run();
 495
 496     expand(getPath("level1"));
 497
 498     assertTree("-/\n" +
 499                " -level0\n" +
 500                "  -level1\n" +
 501                "   -level2\n" +
 502                "    -level3\n" +
 503                "     -level4\n" +
 504                "      -level5\n" +
 505                "       +level6\n");
 506
 507     expand(getPath("level6"));
 508     assertTree("-/\n" +
 509                " -level0\n" +
 510                "  -level1\n" +
 511                "   -level2\n" +
 512                "    -level3\n" +
 513                "     -level4\n" +
 514                "      -level5\n" +
 515                "       -level6\n" +
 516                "        -level7\n" +
 517                "         -level8\n" +
 518                "          -level9\n" +
 519                "           -level10\n" +
 520                "            +level11\n");
 521   }
 522
 523   private void assertCallbackOnce(final TreeAction action) {
 524     final int[] notifyCount = new int[1];
 525     final boolean[] done = new boolean[1];
 526     invokeLaterIfNeeded(new Runnable() {
 527       public void run() {
 528         action.run(new Runnable() {
 529           public void run() {
 530             notifyCount[0]++;
 531             done[0] = true;
 532           }
 533         });
 534       }
 535     });
 536
 537     new WaitFor(60000) {
 538       @Override
 539       protected boolean condition() {
 540         return done[0] && getMyBuilder().getUi().isReady();
 541       }
 542     };
 543
 544     assertTrue(done[0]);
 545     assertEquals(1, notifyCount[0]);
 546   }
 547
 548   public void testSelectMultiple() throws Exception {
 549     buildStructure(myRoot);
 550     assertTree(
 551       "+/\n");
 552
 553     select(new Object[] {new NodeElement("openapi"), new NodeElement("fabrique")}, false);
 554     assertTree(
 555       "-/\n" +
 556       " -com\n" +
 557       "  -intellij\n" +
 558       "   [openapi]\n" +
 559       " -jetbrains\n" +
 560       "  +[fabrique]\n" +
 561       " +org\n" +
 562       " +xunit\n");
 563   }
 564
 565   public void testUnsuccessfulSelect() throws Exception {
 566     buildStructure(myRoot);
 567     select(new Object[] {new NodeElement("openapi"), new NodeElement("fabrique")}, false);
 568
 569     assertTree(
 570       "-/\n" +
 571       " -com\n" +
 572       "  -intellij\n" +
 573       "   [openapi]\n" +
 574       " -jetbrains\n" +
 575       "  +[fabrique]\n" +
 576       " +org\n" +
 577       " +xunit\n");
 578
 579     select(new Object[] {new NodeElement("whatever1"), new NodeElement("whatever2")}, false);
 580
 581     assertTree(
 582       "-/\n" +
 583       " -com\n" +
 584       "  -intellij\n" +
 585       "   [openapi]\n" +
 586       " -jetbrains\n" +
 587       "  +[fabrique]\n" +
 588       " +org\n" +
 589       " +xunit\n");
 590   }
 591
 592
 593   public void testSelectionWhenChildMoved() throws Exception {
 594     buildStructure(myRoot);
 595     assertTree("+/\n");
 596
 597     final Node refactoring = myCom.getChildNode("intellij").addChild("refactoring");
 598
 599     buildNode("refactoring", true);
 600
 601     assertTree(
 602       "-/\n" +
 603       " -com\n" +
 604       "  -intellij\n" +
 605       "   openapi\n" +
 606       "   [refactoring]\n" +
 607       " +jetbrains\n" +
 608       " +org\n" +
 609       " +xunit\n");
 610
 611     refactoring.delete();
 612     myCom.getChildNode("intellij").getChildNode("openapi").addChild("refactoring");
 613
 614     updateFromRoot();
 615
 616     assertTree(
 617       "-/\n" +
 618       " -com\n" +
 619       "  -intellij\n" +
 620       "   -openapi\n" +
 621       "    [refactoring]\n" +
 622       " +jetbrains\n" +
 623       " +org\n" +
 624       " +xunit\n");
 625   }
 626
 627
 628   public void testSelectionGoesToParentWhenOnlyChildRemove() throws Exception {
 629     buildStructure(myRoot);
 630     buildNode("openapi", true);
 631
 632     assertTree(
 633       "-/\n" +
 634       " -com\n" +
 635       "  -intellij\n" +
 636       "   [openapi]\n" +
 637       " +jetbrains\n" +
 638       " +org\n" +
 639       " +xunit\n");
 640
 641     myCom.getChildNode("intellij").getChildNode("openapi").delete();
 642
 643     updateFromRoot();
 644
 645     assertTree(
 646       "-/\n" +
 647       " -com\n" +
 648       "  [intellij]\n" +
 649       " +jetbrains\n" +
 650       " +org\n" +
 651       " +xunit\n");
 652   }
 653
 654   public void testSelectionGoesToParentWhenOnlyChildMoved() throws Exception {
 655     buildStructure(myRoot);
 656     buildNode("openapi", true);
 657
 658     assertTree(
 659       "-/\n" +
 660       " -com\n" +
 661       "  -intellij\n" +
 662       "   [openapi]\n" +
 663       " +jetbrains\n" +
 664       " +org\n" +
 665       " +xunit\n");
 666
 667     myCom.getChildNode("intellij").getChildNode("openapi").delete();
 668     myRoot.getChildNode("xunit").addChild("openapi");
 669
 670     updateFromRoot();
 671
 672     assertTree(
 673       "-/\n" +
 674       " -com\n" +
 675       "  intellij\n" +
 676       " +jetbrains\n" +
 677       " +org\n" +
 678       " -xunit\n" +
 679       "  [openapi]\n" +
 680       "  runner\n");
 681   }
 682
 683   public void testSelectionGoesToParentWhenOnlyChildMoved2() throws Exception {
 684     buildStructure(myRoot);
 685     buildNode("openapi", true);
 686
 687     assertTree(
 688       "-/\n" +
 689       " -com\n" +
 690       "  -intellij\n" +
 691       "   [openapi]\n" +
 692       " +jetbrains\n" +
 693       " +org\n" +
 694       " +xunit\n");
 695
 696     myCom.getChildNode("intellij").getChildNode("openapi").delete();
 697     myRoot.getChildNode("xunit").addChild("openapi");
 698
 699     getBuilder().addSubtreeToUpdateByElement(new NodeElement("intellij"));
 700     getBuilder().addSubtreeToUpdateByElement(new NodeElement("xunit"));
 701
 702
 703     doAndWaitForBuilder(new Runnable() {
 704       public void run() {
 705         getBuilder().getUpdater().performUpdate();
 706       }
 707     });
 708
 709     assertTree(
 710       "-/\n" +
 711       " -com\n" +
 712       "  intellij\n" +
 713       " +jetbrains\n" +
 714       " +org\n" +
 715       " -xunit\n" +
 716       "  [openapi]\n" +
 717       "  runner\n");
 718   }
 719
 720   public void testSelectionGoesToParentWhenChildrenFold() throws Exception {
 721     buildStructure(myRoot);
 722     buildNode("openapi", true);
 723
 724     assertTree(
 725       "-/\n" +
 726       " -com\n" +
 727       "  -intellij\n" +
 728       "   [openapi]\n" +
 729       " +jetbrains\n" +
 730       " +org\n" +
 731       " +xunit\n");
 732
 733
 734     final DefaultMutableTreeNode node = findNode("intellij", false);
 735     collapsePath(new TreePath(node.getPath()));
 736
 737     assertTree(
 738       "-/\n" +
 739       " -com\n" +
 740       "  +[intellij]\n" +
 741       " +jetbrains\n" +
 742       " +org\n" +
 743       " +xunit\n");
 744   }
 745
 746
 747   public void testQueryStructure() throws Exception {
 748     buildStructure(myRoot);
 749
 750     assertTree("+/\n");
 751     assertUpdates("/: update");
 752
 753     expand(getPath("/"));
 754     assertTree("-/\n" +
 755                " +com\n" +
 756                " +jetbrains\n" +
 757                " +org\n" +
 758                " +xunit\n");
 759     assertUpdates("/: update getChildren\n" +
 760                   "com: update getChildren\n" +
 761                   "eclipse: update\n" +
 762                   "fabrique: update\n" +
 763                   "intellij: update\n" +
 764                   "jetbrains: update getChildren\n" +
 765                   "org: update getChildren\n" +
 766                   "runner: update\n" +
 767                   "xunit: update getChildren");
 768
 769     collapsePath(getPath("/"));
 770     assertTree("+/\n");
 771     assertUpdates("");
 772
 773     expand(getPath("/"));
 774     assertTree("-/\n" +
 775                " +com\n" +
 776                " +jetbrains\n" +
 777                " +org\n" +
 778                " +xunit\n");
 779     assertUpdates("/: update getChildren\n" +
 780                   "com: update getChildren\n" +
 781                   "eclipse: update\n" +
 782                   "fabrique: update\n" +
 783                   "intellij: update\n" +
 784                   "jetbrains: update getChildren\n" +
 785                   "org: update getChildren\n" +
 786                   "runner: update\n" +
 787                   "xunit: update getChildren");
 788
 789     updateFromRoot();
 790     assertTree("-/\n" +
 791                " +com\n" +
 792                " +jetbrains\n" +
 793                " +org\n" +
 794                " +xunit\n");
 795
 796     assertUpdates("/: update getChildren\n" +
 797                   "com: update getChildren\n" +
 798                   "eclipse: update\n" +
 799                   "fabrique: update\n" +
 800                   "intellij: update\n" +
 801                   "jetbrains: update getChildren\n" +
 802                   "org: update getChildren\n" +
 803                   "runner: update\n" +
 804                   "xunit: update getChildren");
 805
 806   }
 807
 808   public void testQueryStructureWhenExpand() throws Exception {
 809     buildStructure(myRoot);
 810
 811     assertTree("+/\n");
 812     assertUpdates("/: update");
 813
 814     buildNode("ide", false);
 815     assertTree("-/\n" +
 816                " +com\n" +
 817                " -jetbrains\n" +
 818                "  -fabrique\n" +
 819                "   ide\n" +
 820                " +org\n" +
 821                " +xunit\n");
 822
 823     assertUpdates("/: update getChildren\n" +
 824                   "com: update getChildren\n" +
 825                   "eclipse: update\n" +
 826                   "fabrique: update (2) getChildren\n" +
 827                   "ide: update getChildren\n" +
 828                   "intellij: update\n" +
 829                   "jetbrains: update getChildren\n" +
 830                   "org: update getChildren\n" +
 831                   "runner: update\n" +
 832                   "xunit: update getChildren");
 833
 834   }
 835
 836   public void testQueryStructureIsAlwaysLeaf() throws Exception {
 837     buildStructure(myRoot);
 838     myStructure.addLeaf(new NodeElement("openapi"));
 839
 840     buildNode("jetbrains", false);
 841     assertTree("-/\n" +
 842                " +com\n" +
 843                " -jetbrains\n" +
 844                "  +fabrique\n" +
 845                " +org\n" +
 846                " +xunit\n");
 847
 848     assertUpdates("/: update (2) getChildren\n" +
 849                   "com: update getChildren\n" +
 850                   "eclipse: update\n" +
 851                   "fabrique: update (2) getChildren\n" +
 852                   "ide: update\n" +
 853                   "intellij: update\n" +
 854                   "jetbrains: update getChildren\n" +
 855                   "org: update getChildren\n" +
 856                   "runner: update\n" +
 857                   "xunit: update getChildren");
 858
 859     expand(getPath("fabrique"));
 860     assertTree("-/\n" +
 861                " +com\n" +
 862                " -jetbrains\n" +
 863                "  -fabrique\n" +
 864                "   ide\n" +
 865                " +org\n" +
 866                " +xunit\n");
 867     assertUpdates("ide: update getChildren");
 868
 869
 870     buildNode("com", false);
 871     assertTree("-/\n" +
 872                " -com\n" +
 873                "  +intellij\n" +
 874                " -jetbrains\n" +
 875                "  -fabrique\n" +
 876                "   ide\n" +
 877                " +org\n" +
 878                " +xunit\n");
 879
 880     myElementUpdate.clear();
 881
 882     expand(getPath("intellij"));
 883     assertTree("-/\n" +
 884                " -com\n" +
 885                "  -intellij\n" +
 886                "   openapi\n" +
 887                " -jetbrains\n" +
 888                "  -fabrique\n" +
 889                "   ide\n" +
 890                " +org\n" +
 891                " +xunit\n");
 892
 893     assertUpdates("");
 894   }
 895
 896   public void testToggleIsAlwaysLeaf() throws Exception {
 897     buildStructure(myRoot);
 898
 899     buildNode("openapi", true);
 900
 901     assertTree("-/\n" +
 902                " -com\n" +
 903                "  -intellij\n" +
 904                "   [openapi]\n" +
 905                " +jetbrains\n" +
 906                " +org\n" +
 907                " +xunit\n");
 908
 909     myStructure.addLeaf(new NodeElement("intellij"));
 910
 911     updateFrom(new NodeElement("com"));
 912
 913     assertTree("-/\n" +
 914                " -com\n" +
 915                "  [intellij]\n" +
 916                " +jetbrains\n" +
 917                " +org\n" +
 918                " +xunit\n");
 919
 920     myStructure.removeLeaf(new NodeElement("intellij"));
 921     updateFrom(new NodeElement("com"));
 922
 923     assertTree("-/\n" +
 924                " -com\n" +
 925                "  +[intellij]\n" +
 926                " +jetbrains\n" +
 927                " +org\n" +
 928                " +xunit\n");
 929
 930     expand(getPath("intellij"));
 931
 932     assertTree("-/\n" +
 933                " -com\n" +
 934                "  -[intellij]\n" +
 935                "   openapi\n" +
 936                " +jetbrains\n" +
 937                " +org\n" +
 938                " +xunit\n");
 939
 940   }
 941
 942
 943   public void testSorting() throws Exception {
 944     buildStructure(myRoot);
 945     assertSorted("");
 946
 947     buildNode("/", false);
 948     assertTree("-/\n" +
 949                " +com\n" +
 950                " +jetbrains\n" +
 951                " +org\n" +
 952                " +xunit\n");
 953
 954     assertSorted("/\n" +
 955                  "com\n" +
 956                  "jetbrains\n" +
 957                  "org\n" +
 958                  "xunit");
 959
 960     updateFromRoot();
 961     assertTree("-/\n" +
 962                " +com\n" +
 963                " +jetbrains\n" +
 964                " +org\n" +
 965                " +xunit\n");
 966     assertSorted("/\n" +
 967                  "com\n" +
 968                  "jetbrains\n" +
 969                  "org\n" +
 970                  "xunit");
 971
 972     updateFrom(new NodeElement("/"), false);
 973     assertTree("-/\n" +
 974                " +com\n" +
 975                " +jetbrains\n" +
 976                " +org\n" +
 977                " +xunit\n");
 978     assertSorted("");
 979
 980
 981     expand(getPath("com"));
 982     assertTree("-/\n" +
 983                " -com\n" +
 984                "  +intellij\n" +
 985                " +jetbrains\n" +
 986                " +org\n" +
 987                " +xunit\n");
 988     assertSorted("intellij");
 989   }
 990
 991   public void testResorting() throws Exception {
 992     final boolean invert[] = new boolean[] {false};
 993     NodeDescriptor.NodeComparator<NodeDescriptor> c = new NodeDescriptor.NodeComparator<NodeDescriptor>() {
 994       public int compare(NodeDescriptor o1, NodeDescriptor o2) {
 995         return invert[0] ? AlphaComparator.INSTANCE.compare(o2, o1) : AlphaComparator.INSTANCE.compare(o1, o2);
 996       }
 997     };
 998
 999     myComparator.setDelegate(c);
1000
1001     buildStructure(myRoot);
1002
1003     buildNode("/", false);
1004     assertTree("-/\n" +
1005                " +com\n" +
1006                " +jetbrains\n" +
1007                " +org\n" +
1008                " +xunit\n");
1009
1010     updateFromRoot();
1011     updateFromRoot();
1012     updateFromRoot();
1013
1014     assertTrue(getMyBuilder().getUi().myOwnComparatorStamp > c.getStamp());
1015     invert[0] = true;
1016     c.incStamp();
1017
1018     updateFrom(new NodeElement("/"), false);
1019     assertTree("-/\n" +
1020                " +xunit\n" +
1021                " +org\n" +
1022                " +jetbrains\n" +
1023                " +com\n");
1024   }
1025
1026   public void testRestoreSelectionOfRemovedElement() throws Exception {
1027     buildStructure(myRoot);
1028     buildNode("openapi", true);
1029     assertTree("-/\n" +
1030                " -com\n" +
1031                "  -intellij\n" +
1032                "   [openapi]\n" +
1033                " +jetbrains\n" +
1034                " +org\n" +
1035                " +xunit\n");
1036
1037
1038     removeFromParentButKeepRef(new NodeElement("openapi"));
1039
1040     updateFromRoot();
1041
1042     assertTree("-/\n" +
1043                " -com\n" +
1044                "  [intellij]\n" +
1045                " +jetbrains\n" +
1046                " +org\n" +
1047                " +xunit\n");
1048   }
1049
1050   public void testElementMove1() throws Exception {
1051     assertMove(new Runnable() {
1052       public void run() {
1053         getBuilder().getUpdater().addSubtreeToUpdateByElement(new NodeElement("com"));
1054         getBuilder().getUpdater().addSubtreeToUpdateByElement(new NodeElement("jetbrains"));
1055       }
1056     });
1057   }
1058
1059   public void testElementMove2() throws Exception {
1060     assertMove(new Runnable() {
1061       public void run() {
1062         getBuilder().getUpdater().addSubtreeToUpdateByElement(new NodeElement("jetbrains"));
1063         getBuilder().getUpdater().addSubtreeToUpdateByElement(new NodeElement("com"));
1064       }
1065     });
1066   }
1067
1068   public void testSelectionOnDelete() throws Exception {
1069     doTestSelectionOnDelete(false);
1070   }
1071
1072   public void testSelectionOnDeleteButKeepRef() throws Exception {
1073     doTestSelectionOnDelete(true);
1074   }
1075
1076   private void doTestSelectionOnDelete(boolean keepRef) throws Exception {
1077     myComparator.setDelegate(new NodeDescriptor.NodeComparator<NodeDescriptor>() {
1078       public int compare(NodeDescriptor o1, NodeDescriptor o2) {
1079         boolean isParent1 = myStructure._getChildElements(o1.getElement(), false).length > 0;
1080         boolean isParent2 = myStructure._getChildElements(o2.getElement(), false).length > 0;
1081
1082         int result = AlphaComparator.INSTANCE.compare(o1, o2);
1083
1084         if (isParent1) {
1085           result -= 1000;
1086         }
1087
1088         if (isParent2) {
1089           result += 1000;
1090         }
1091
1092         return result;
1093       }
1094     });
1095
1096     buildStructure(myRoot);
1097     myRoot.addChild("toDelete");
1098
1099     select(new NodeElement("toDelete"), false);
1100     assertTree("-/\n" +
1101                " +com\n" +
1102                " +jetbrains\n" +
1103                " +org\n" +
1104                " +xunit\n" +
1105                " [toDelete]\n");
1106
1107     if (keepRef) {
1108       removeFromParentButKeepRef(new NodeElement("toDelete"));
1109     } else {
1110       myStructure.getNodeFor(new NodeElement("toDelete")).delete();
1111     }
1112
1113     getMyBuilder().addSubtreeToUpdateByElement(new NodeElement("/"));
1114
1115     assertTree("-/\n" +
1116                " +com\n" +
1117                " +jetbrains\n" +
1118                " +org\n" +
1119                " +[xunit]\n");
1120   }
1121
1122   public void testSelectWhenUpdatesArePending() throws Exception {
1123     getBuilder().getUpdater().setDelay(1000);
1124
1125     buildStructure(myRoot);
1126
1127     buildNode("intellij", false);
1128     select(new Object[] {new NodeElement("intellij")}, false);
1129     assertTree("-/\n" +
1130                " -com\n" +
1131                "  -[intellij]\n" +
1132                "   openapi\n" +
1133                " +jetbrains\n" +
1134                " +org\n" +
1135                " +xunit\n");
1136
1137
1138     myIntellij.addChild("ui");
1139
1140     DefaultMutableTreeNode intellijNode = findNode("intellij", false);
1141     assertTrue(myTree.isExpanded(new TreePath(intellijNode.getPath())));
1142     getMyBuilder().addSubtreeToUpdate(intellijNode);
1143     assertFalse(getMyBuilder().getUi().isReady());
1144
1145     select(new Object[] {new NodeElement("ui")}, false);
1146     assertTree("-/\n" +
1147                " -com\n" +
1148                "  -intellij\n" +
1149                "   openapi\n" +
1150                "   [ui]\n" +
1151                " +jetbrains\n" +
1152                " +org\n" +
1153                " +xunit\n");
1154   }
1155
1156   public void testAddNewElementToLeafElementAlwaysShowPlus() throws Exception {
1157     myAlwaysShowPlus.add(new NodeElement("openapi"));
1158
1159     buildStructure(myRoot);
1160     select(new Object[] {new NodeElement("openapi")}, false);
1161
1162     assertTree("-/\n" +
1163                " -com\n" +
1164                "  -intellij\n" +
1165                "   +[openapi]\n" +
1166                " +jetbrains\n" +
1167                " +org\n" +
1168                " +xunit\n");
1169
1170     expand(getPath("openapi"));
1171     assertTree("-/\n" +
1172                " -com\n" +
1173                "  -intellij\n" +
1174                "   [openapi]\n" +
1175                " +jetbrains\n" +
1176                " +org\n" +
1177                " +xunit\n");
1178
1179
1180     myOpenApi.addChild("ui");
1181
1182     getMyBuilder().addSubtreeToUpdate(findNode("openapi", false));
1183
1184     assertTree("-/\n" +
1185                " -com\n" +
1186                "  -intellij\n" +
1187                "   +[openapi]\n" +
1188                " +jetbrains\n" +
1189                " +org\n" +
1190                " +xunit\n");
1191   }
1192
1193   public void testAddNewElementToLeafElement() throws Exception {
1194     buildStructure(myRoot);
1195     select(new Object[] {new NodeElement("openapi")}, false);
1196
1197     assertTree("-/\n" +
1198                " -com\n" +
1199                "  -intellij\n" +
1200                "   [openapi]\n" +
1201                " +jetbrains\n" +
1202                " +org\n" +
1203                " +xunit\n");
1204
1205     expand(getPath("openapi"));
1206     assertTree("-/\n" +
1207                " -com\n" +
1208                "  -intellij\n" +
1209                "   [openapi]\n" +
1210                " +jetbrains\n" +
1211                " +org\n" +
1212                " +xunit\n");
1213
1214
1215     myOpenApi.addChild("ui");
1216
1217     getMyBuilder().addSubtreeToUpdate(findNode("openapi", false));
1218
1219     assertTree("-/\n" +
1220                " -com\n" +
1221                "  -intellij\n" +
1222                "   +[openapi]\n" +
1223                " +jetbrains\n" +
1224                " +org\n" +
1225                " +xunit\n");
1226   }
1227
1228
1229   private void assertMove(Runnable updateRoutine) throws Exception {
1230     buildStructure(myRoot);
1231
1232     buildNode("intellij", true);
1233     assertTree("-/\n" +
1234                " -com\n" +
1235                "  +[intellij]\n" +
1236                " +jetbrains\n" +
1237                " +org\n" +
1238                " +xunit\n");
1239
1240     AbstractTreeBuilderTest.Node intellij = removeFromParentButKeepRef(new NodeElement("intellij"));
1241     myRoot.getChildNode("jetbrains").addChild(intellij);
1242
1243     updateRoutine.run();
1244
1245     assertTree("-/\n" +
1246                " com\n" +
1247                " -jetbrains\n" +
1248                "  +fabrique\n" +
1249                "  +[intellij]\n" +
1250                " +org\n" +
1251                " +xunit\n");
1252
1253   }
1254
1255
1256   public void testChangeRootElement() throws Exception {
1257     buildStructure(myRoot);
1258
1259     select(new NodeElement("com"), false);
1260
1261     assertTree("-/\n" +
1262                " +[com]\n" +
1263                " +jetbrains\n" +
1264                " +org\n" +
1265                " +xunit\n");
1266
1267     myRoot = new Node(null, "root");
1268     myStructure.reinitRoot(myRoot);
1269
1270     myRoot.addChild("com");
1271
1272     updateFromRoot();
1273     assertTree("+root\n");
1274   }
1275
1276   public void testReleaseBuilderDuringUpdate() throws Exception {
1277     assertReleaseDuringBuilding("update", "fabrique", new Runnable() {
1278       public void run() {
1279         try {
1280           select(new NodeElement("ide"), false);
1281         }
1282         catch (Exception e) {
1283           myCancelRequest = e;
1284         }
1285       }
1286     });
1287   }
1288
1289   public void testReleaseBuilderDuringGetChildren() throws Exception {
1290     assertReleaseDuringBuilding("getChildren", "fabrique", new Runnable() {
1291       public void run() {
1292         try {
1293           select(new NodeElement("ide"), false);
1294         }
1295         catch (Exception e) {
1296           myCancelRequest = e;
1297         }
1298       }
1299     });
1300   }
1301
1302   private void assertReleaseDuringBuilding(final String actionAction, final Object actionElement, Runnable buildAction) throws Exception {
1303     buildStructure(myRoot);
1304
1305     myElementUpdateHook = new ElementUpdateHook() {
1306       public void onElementAction(String action, Object element) {
1307         if (!element.toString().equals(actionElement.toString())) return;
1308
1309         if (actionAction.equals(action)) {
1310           SwingUtilities.invokeLater(new Runnable() {
1311             public void run() {
1312               myReadyRequest = true;
1313               Disposer.dispose(getBuilder());
1314             }
1315           });
1316         }
1317       }
1318     };
1319
1320     buildAction.run();
1321
1322     boolean released = new WaitFor(5000) {
1323       @Override
1324       protected boolean condition() {
1325         return getBuilder().getUi() == null;
1326       }
1327     }.isConditionRealized();
1328
1329     assertTrue(released);
1330   }
1331
1332   public static class SyncUpdate extends TreeUiTest {
1333     public SyncUpdate() {
1334       super(false, false);
1335     }
1336   }
1337
1338   public static class Passthrough extends TreeUiTest {
1339     public Passthrough() {
1340       super(true);
1341     }
1342
1343     public void testSelectionGoesToParentWhenOnlyChildMoved2() throws Exception {
1344       //todo
1345     }
1346
1347     public void testQueryStructureWhenExpand() throws Exception {
1348       //todo
1349     }
1350
1351
1352     public void testElementMove1() throws Exception {
1353       //todo
1354     }
1355
1356     @Override
1357     public void testClear() throws Exception {
1358       //todo
1359     }
1360
1361     @Override
1362     public void testSelectWhenUpdatesArePending() throws Exception {
1363       // doesn't make sense in pass-through mode
1364     }
1365   }
1366
1367   public static class YieldingUpdate extends TreeUiTest {
1368     public YieldingUpdate() {
1369       super(true, false);
1370     }
1371   }
1372
1373   public static class BgLoadingSyncUpdate extends TreeUiTest {
1374     public BgLoadingSyncUpdate() {
1375       super(false, true);
1376     }
1377
1378     @Override
1379     protected int getChildrenLoadingDelay() {
1380       return 300;
1381     }
1382
1383     @Override
1384     protected int getNodeDescriptorUpdateDelay() {
1385       return 300;
1386     }
1387
1388     @Override
1389     public void testNoInfiniteSmartExpand() throws Exception {
1390       //todo
1391     }
1392   }
1393
1394   public static class QuickBgLoadingSyncUpdate extends TreeUiTest {
1395     public QuickBgLoadingSyncUpdate() {
1396       super(false, true);
1397     }
1398
1399
1400     @Override
1401     protected int getNodeDescriptorUpdateDelay() {
1402       return 300;
1403     }
1404
1405     @Override
1406     public void testNoInfiniteSmartExpand() throws Exception {
1407       //todo
1408     }
1409
1410   }
1411
1412   public static TestSuite suite() {
1413     TestSuite suite = new TestSuite();
1414     suite.addTestSuite(Passthrough.class);
1415     suite.addTestSuite(SyncUpdate.class);
1416     suite.addTestSuite(YieldingUpdate.class);
1417     suite.addTestSuite(BgLoadingSyncUpdate.class);
1418     suite.addTestSuite(QuickBgLoadingSyncUpdate.class);
1419     return suite;
1420   }
1421 }