android/testSrc/com/android/tools/idea/ui/FileTreeModelTest.java

/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.tools.idea.ui;

import com.android.tools.idea.ui.FileTreeModel;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.util.containers.Stack;
import org.jetbrains.android.AndroidTestCase;

import javax.swing.*;
import java.io.File;
import java.io.FileFilter;
import java.util.*;

import static com.android.tools.idea.ui.FileTreeModel.Node;

/**
 *
 */
public class FileTreeModelTest extends AndroidTestCase {

  private static File createFile(String systemIndependentPath) {
    if (File.separatorChar == '\\' && systemIndependentPath.startsWith("/") && !systemIndependentPath.startsWith("//")) {
      systemIndependentPath = "/" + systemIndependentPath;
    }
    return new File(FileUtil.toSystemDependentName(systemIndependentPath));
  }

  public void testIcon() throws Exception {
    File file = createFile("/asdfasdfasdf");
    Icon icon = new ImageIcon();
    FileTreeModel model = new FileTreeModel(file);

    model.addFile(createFile("asdfasdfasdf/foo"), icon);

    Node testNode = ((Node)model.getRoot()).getChild("foo");
    assertNotNull(testNode);
    assertEquals(icon, testNode.icon);
  }

  public void testMakeNotExists() throws Exception {
    File file = createFile("/asdfasdfasdf");
    assertFalse(file.exists());

    FileTreeModel model = new FileTreeModel(file);

    Node root = (Node)model.getRoot();

    assertTrue(root.children.isEmpty());
    assertEquals("asdfasdfasdf", root.name);
    assertNull(root.icon);
    assertFalse(root.existsOnDisk);
  }

  public void testPathExistsNoOp() throws Exception {
    FileTreeModel model = new FileTreeModel(createFile("/asdf"));

    model.addFile(createFile("/asdf/foo/bar"));
    String baseString = model.toString();

    model.addFile(createFile("/asdf"));
    assertEquals(baseString, model.toString());

    model.addFile(createFile("/asdf/foo"));
    assertEquals(baseString, model.toString());

    model.addFile(createFile("foo"));
    assertEquals(baseString, model.toString());

    model.addFile(createFile("foo/bar"));
    assertEquals(baseString, model.toString());
  }

  public void testToString() throws Exception {
    File root = createFile("/asdf");
    FileTreeModel model = new FileTreeModel(root);
    assertEquals("(asdf)", model.toString());

    File file1 = createFile("/asdf/foo/bar");
    model.addFile(file1);
    assertEquals("(asdf (foo (bar)))", model.toString());

    File file2 = createFile("/asdf/foo2/blah");
    model.addFile(file2);
    assertEquals("(asdf (foo (bar))(foo2 (blah)))", model.toString());

    File file3 = createFile("/asdf/foo/bar2");
    model.addFile(file3);
    assertEquals("(asdf (foo (bar)(bar2))(foo2 (blah)))", model.toString());
  }


  public void testFileTreeConstruction() throws Exception {
    File rootFile = new File(getTestDataPath(), "projects");
    FileTreeModel model = new FileTreeModel(rootFile);
    Node rootNode = (Node)model.getRoot();
    assertTrue(nodeRepresentsFileTree(rootNode, rootFile));
  }

  /**
   * Uses DFS to compare a tree representation with a file structure
   * @return true iff both trees are identical in structure and contents
   */
  protected boolean nodeRepresentsFileTree(Node nodeRoot, File fileRoot) {
    Stack<Node> nodeStack = new Stack<Node>(nodeRoot);
    Stack<File> fileStack = new Stack<File>(fileRoot);

    while(!fileStack.isEmpty()) {
      Node node = nodeStack.pop();
      File file = fileStack.pop();

      assertNotNull(node);
      assertEquals(file.getName(), node.name);

      List<Node> sortedNodeChildren = new ArrayList<Node>(node.children);
      Collections.sort(sortedNodeChildren, new Comparator<Node>() {
        @Override
        public int compare(Node o1, Node o2) {
          return o1.name.compareTo(o2.name);
        }
      });


      // Add childrent in sorted order to the stack
      File[] fileChildren = file.listFiles(new FileFilter() {
        @Override
        public boolean accept(File pathname) {
          return !pathname.isHidden();
        }
      });
      List<File> sortedFileChildren = fileChildren == null ? new ArrayList<File>(0) : Arrays.asList(fileChildren);

      Collections.sort(sortedFileChildren, new Comparator<File>() {
        @Override
        public int compare(File o1, File o2) {
          return o1.getName().compareTo(o2.getName());
        }
      });

      for (Node n : sortedNodeChildren) {
        nodeStack.push(n);
      }
      for (File f : sortedFileChildren) {
        fileStack.push(f);
      }
    }

    // If there were nodes stack that don't exist in the file tree, return false
    return nodeStack.isEmpty();
  }
}