ResumableTreeTraverserTest.java

// Copyright 2012 Google Inc. All Rights Reserved.
//
// 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.google.collide.client.util.collections;

import com.google.collide.client.ui.tree.TreeTestUtils;
import com.google.collide.client.util.collections.ResumableTreeTraverser.FinishedCallback;
import com.google.collide.client.util.collections.ResumableTreeTraverser.VisitorApi;
import com.google.collide.dto.DirInfo;
import com.google.collide.dto.FileInfo;
import com.google.collide.dto.TreeNodeInfo;
import com.google.collide.json.shared.JsonArray;
import com.google.collide.shared.util.JsonCollections;
import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;

import junit.framework.TestCase;

import org.easymock.EasyMock;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
 * The tests use a file tree since we already have a util method to create
 * a nice tree.  The actual data doesn't affect the traversal.
 */
/**
 * Tests for {@link ResumableTreeTraverser}.
 * 
 */
public class ResumableTreeTraverserTest extends TestCase {

  private static class NodeProvider implements ResumableTreeTraverser.NodeProvider<TreeNodeInfo> {
    @Override
    public Iterator<TreeNodeInfo> getChildrenIterator(TreeNodeInfo node) {
      if (node instanceof FileInfo) {
        return null;
      }
      
      DirInfo dirInfo = (DirInfo) node;
      JsonArray<TreeNodeInfo> children = JsonCollections.createArray();
      children.addAll(dirInfo.getFiles());
      children.addAll(dirInfo.getSubDirectories());
      
      return children.asIterable().iterator();
    }
  }
  
  private static class Visitor implements ResumableTreeTraverser.Visitor<TreeNodeInfo> {
    List<TreeNodeInfo> visitedItems = new ArrayList<TreeNodeInfo>(); 
    
    @Override
    public void visit(TreeNodeInfo item, VisitorApi visitorApi) {
      visitedItems.add(item);
    }
  }
  
  private static class AlwaysPauseVisitor extends Visitor {
    @Override
    public void visit(TreeNodeInfo item, VisitorApi visitorApi) {
      super.visit(item, visitorApi);
      visitorApi.pause();
    }
  }
  
  private static class AlwaysPauseAndResumeVisitor extends Visitor {
    @Override
    public void visit(TreeNodeInfo item, VisitorApi visitorApi) {
      super.visit(item, visitorApi);
      visitorApi.pause();
      visitorApi.resume();
    }
  }
  
  private static class AlwaysPauseAndRemoveVisitor extends Visitor {
    @Override
    public void visit(TreeNodeInfo item, VisitorApi visitorApi) {
      super.visit(item, visitorApi);
      visitorApi.pause();
      visitorApi.remove();
    }
  }
  
  private static class AlwaysRemoveVisitor extends Visitor {
    @Override
    public void visit(TreeNodeInfo item, VisitorApi visitorApi) {
      super.visit(item, visitorApi);
      visitorApi.remove();
    }
  }
  
  private final NodeProvider provider = new NodeProvider(); 

  private DirInfo root;
  private Visitor trivialVisitor;
  
  public ResumableTreeTraverserTest(String name) {
    super(name);
  }

  public void testAlwaysPauseVisitors() {
    Visitor alwaysPauseVisitor = new AlwaysPauseVisitor();
    Visitor alwaysPauseVisitor2 = new AlwaysPauseVisitor();
    Visitor alwaysPauseVisitor3 = new AlwaysPauseVisitor();
    
    ResumableTreeTraverser<TreeNodeInfo> traverser =
        new ResumableTreeTraverser<TreeNodeInfo>(provider, provider.getChildrenIterator(root),
            JsonCollections.createArray(alwaysPauseVisitor, alwaysPauseVisitor2,
                alwaysPauseVisitor3), null);
    // -1 to offset the first call to resume
    int numPauses = -1;
    while (traverser.hasMore()) {
      traverser.resume();
      numPauses++;
      
      // Assert that these visitors are being called in order
      assertEquals(Math.min(numPauses / 3 + 1, trivialVisitor.visitedItems.size()),
          alwaysPauseVisitor.visitedItems.size());
      assertEquals(
          Math.min(numPauses / 3 + ((numPauses % 3 >= 1) ? 1 : 0),
              trivialVisitor.visitedItems.size()), alwaysPauseVisitor2.visitedItems.size());
      assertEquals(
          Math.min(numPauses / 3 + ((numPauses % 3 == 2) ? 1 : 0),
              trivialVisitor.visitedItems.size()), alwaysPauseVisitor3.visitedItems.size());
    }
    
    assertEquals(trivialVisitor.visitedItems, alwaysPauseVisitor.visitedItems);
    assertEquals(trivialVisitor.visitedItems, alwaysPauseVisitor2.visitedItems);
    assertEquals(trivialVisitor.visitedItems, alwaysPauseVisitor3.visitedItems);
    assertEquals(trivialVisitor.visitedItems.size() * 3, numPauses);
  }
  
  public void testAlwaysPauseAndRemoveBlocksSubsequentVisitor() {
    testVisitorWhoseRemovalBlocksSubsequentVisitor(new AlwaysPauseAndRemoveVisitor());
  }
  
  public void testAlwaysRemoveBlocksSubsequentVisitor() {
    testVisitorWhoseRemovalBlocksSubsequentVisitor(new AlwaysRemoveVisitor());
  }
  
  private void testVisitorWhoseRemovalBlocksSubsequentVisitor(Visitor visitor1) {
    Visitor visitor2 = new Visitor();
    
    ResumableTreeTraverser<TreeNodeInfo> traverser =
        new ResumableTreeTraverser<TreeNodeInfo>(provider, provider.getChildrenIterator(root),
            JsonCollections.createArray(visitor1, visitor2), null);
    while (traverser.hasMore()) {
      traverser.resume();
    }

    // Visitor1 deletes immediately, so no children should have been visited
    List<TreeNodeInfo> expectedItems = Lists.newArrayList();
    Iterators.addAll(expectedItems, provider.getChildrenIterator(root));
    assertEquals(expectedItems, visitor1.visitedItems);

    // Since visitor1 always deletes, visitor2 should never be called
    assertEquals(0, visitor2.visitedItems.size());
  }

  public void testVisitorBeforeAlwaysRemoveVisitor2() {
    testVisitorBeforeVisitor2ThatRemoves(new Visitor(), new AlwaysRemoveVisitor());
  }
  
  public void testVisitorBeforeAlwaysPauseAndRemoveVisitor2() {
    testVisitorBeforeVisitor2ThatRemoves(new Visitor(), new AlwaysPauseAndRemoveVisitor());
  }
  
  public void testAlwaysPauseVisitorBeforeAlwaysRemoveVisitor2() {
    testVisitorBeforeVisitor2ThatRemoves(new AlwaysPauseVisitor(), new AlwaysRemoveVisitor());
  }
  
  public void testAlwaysPauseVisitorBeforeAlwaysPauseAndRemoveVisitor2() {
    testVisitorBeforeVisitor2ThatRemoves(new AlwaysPauseVisitor(),
        new AlwaysPauseAndRemoveVisitor());
  }
  
  private void testVisitorBeforeVisitor2ThatRemoves(Visitor visitor1, Visitor visitor2) {
    ResumableTreeTraverser<TreeNodeInfo> traverser =
        new ResumableTreeTraverser<TreeNodeInfo>(provider, provider.getChildrenIterator(root),
            JsonCollections.createArray(visitor1, visitor2), null);
    while (traverser.hasMore()) {
      traverser.resume();
    }

    // Visitor2 deletes immediately, so no children should have been visited
    List<TreeNodeInfo> expectedItems = Lists.newArrayList();
    Iterators.addAll(expectedItems, provider.getChildrenIterator(root));
    assertEquals(expectedItems, visitor1.visitedItems);
    assertEquals(expectedItems, visitor2.visitedItems);
  }
  
  public void testPauseAndResumeSynchronouslyCalled() {
    FinishedCallback finishedCallback =
        EasyMock.createStrictMock(ResumableTreeTraverser.FinishedCallback.class);
    finishedCallback.onTraversalFinished();
    EasyMock.replay(finishedCallback);
    
    ResumableTreeTraverser<TreeNodeInfo> traverser = new ResumableTreeTraverser<TreeNodeInfo>(
        provider, provider.getChildrenIterator(root),
        JsonCollections.createArray(new AlwaysPauseAndResumeVisitor()), finishedCallback);
    while (traverser.hasMore()) {
      traverser.resume();
    }
    
    EasyMock.verify(finishedCallback);
  }
  
  @Override
  protected void setUp() throws Exception {
    root = TreeTestUtils.createMockTree(TreeTestUtils.SERVER_NODE_INFO_FACTORY);
    trivialVisitor = new Visitor(); 

    new ResumableTreeTraverser<TreeNodeInfo>(provider, provider.getChildrenIterator(root),
        JsonCollections.createArray(trivialVisitor), null).resume();
  }
}