ide/spi.viewmodel/test/unit/src/org/netbeans/modules/viewmodel/CachedChildrenTreeModelTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.netbeans.modules.viewmodel;

import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.netbeans.spi.viewmodel.AsynchronousModelFilter;
import org.netbeans.spi.viewmodel.CachedChildrenTreeModel;
import org.netbeans.spi.viewmodel.UnknownTypeException;
import static org.junit.Assert.*;
import org.netbeans.spi.viewmodel.ModelListener;
import org.netbeans.spi.viewmodel.TreeModel;

/**
 *
 * @author martin
 */
public class CachedChildrenTreeModelTest {
    
    public CachedChildrenTreeModelTest() {
    }
    
    @BeforeClass
    public static void setUpClass() {
    }
    
    @AfterClass
    public static void tearDownClass() {
    }
    
    @Before
    public void setUp() {
    }
    
    @After
    public void tearDown() {
    }

    /**
     * Test of getChildren method, of class CachedChildrenTreeModel.
     */
    @Test
    public void testGetChildren() throws Exception {
        System.out.println("getChildren");
        int from = 0;
        int to = Integer.MAX_VALUE;
        CachedChildrenTreeModel instance = new CachedChildrenTreeModelImpl();
        Object[] result = instance.getChildren("", from, to);
        assertArrayEquals(new Object[] {"a", "b", "c"}, result);
        result = instance.getChildren("b", from, to);
        assertArrayEquals(new Object[] {"ba", "bb", "bc"}, result);
    }

    /**
     * Test of computeChildren method, of class CachedChildrenTreeModel.
     */
    @Test
    public void testComputeChildren() throws Exception {
        System.out.println("computeChildren");
        int from = 0;
        int to = Integer.MAX_VALUE;
        CachedChildrenTreeModelImpl instance = new CachedChildrenTreeModelImpl();
        assertFalse(instance.isChildernComputed());
        Object[] result = instance.getChildren("", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"a", "b", "c"}, result);
        // Ask again
        result = instance.getChildren("", from, to);
        assertFalse(instance.isChildernComputed());
        
        result = instance.getChildren("b", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"ba", "bb", "bc"}, result);
        
        result = instance.getChildren("b", from, to);
        assertFalse(instance.isChildernComputed());
        result = instance.getChildren("", from, to);
        assertFalse(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"a", "b", "c"}, result);
    }

    /**
     * Test of cacheChildrenOf method, of class CachedChildrenTreeModel.
     */
    @Test
    public void testCacheChildrenOf() throws Exception {
        System.out.println("cacheChildrenOf");
        int from = 0;
        int to = Integer.MAX_VALUE;
        CachedChildrenTreeModelImpl instance = new CachedChildrenTreeModelImpl();
        assertFalse(instance.isChildernComputed());
        Object[] result = instance.getChildren("", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"a", "b", "c"}, result);
        result = instance.getChildren("c", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"ca", "cb", "cc"}, result);
        result = instance.getChildren("cc", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"cca", "ccb", "ccc"}, result);
        result = instance.getChildren("cc", from, to);
        // cc is always re-computed
        assertTrue(instance.isChildernComputed());
        result = instance.getChildren("c", from, to);
        assertFalse(instance.isChildernComputed());
    }

    /**
     * Test of refreshCache method, of class CachedChildrenTreeModel.
     */
    @Test
    public void testRefreshCache() throws Exception {
        System.out.println("refreshCache");
        int from = 0;
        int to = Integer.MAX_VALUE;
        CachedChildrenTreeModelImpl instance = new CachedChildrenTreeModelImpl();
        assertFalse(instance.isChildernComputed());
        Object[] result = instance.getChildren("", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"a", "b", "c"}, result);
        result = instance.getChildren("a", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"aa", "ab", "ac"}, result);
        
        result = instance.getChildren("", from, to);
        result = instance.getChildren("a", from, to);
        assertFalse(instance.isChildernComputed());
        
        instance.doRefreshCache("a");
        instance.asynchronous(null, AsynchronousModelFilter.CALL.CHILDREN, "a");
        result = instance.getChildren("a", from, to);
        assertTrue(instance.isChildernComputed());
    }

    /**
     * Test of clearCache method, of class CachedChildrenTreeModel.
     */
    @Test
    public void testClearCache() throws Exception {
        System.out.println("clearCache");
        int from = 0;
        int to = Integer.MAX_VALUE;
        CachedChildrenTreeModelImpl instance = new CachedChildrenTreeModelImpl();
        assertFalse(instance.isChildernComputed());
        Object[] result = instance.getChildren("", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"a", "b", "c"}, result);
        result = instance.getChildren("a", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"aa", "ab", "ac"}, result);
        
        result = instance.getChildren("", from, to);
        result = instance.getChildren("a", from, to);
        assertFalse(instance.isChildernComputed());
        
        instance.doClearCache();
        result = instance.getChildren("", from, to);
        assertTrue(instance.isChildernComputed());
        result = instance.getChildren("a", from, to);
        assertTrue(instance.isChildernComputed());
    }

    /**
     * Test of reorder method, of class CachedChildrenTreeModel.
     */
    @Test
    public void testReorder() throws Exception {
        System.out.println("reorder");
        int from = 0;
        int to = Integer.MAX_VALUE;
        CachedChildrenTreeModelImpl instance = new CachedChildrenTreeModelImpl() {
            @Override
            protected Object[] reorder(Object[] nodes) {
                return new Object[] { nodes[2], nodes[0], nodes[1] };
            }
        };
        Object[] result = instance.getChildren("", from, to);
        assertArrayEquals(new Object[] {"c", "a", "b"}, result);
    }

    /**
     * Test of recomputeChildren method, of class CachedChildrenTreeModel.
     */
    @Test
    public void testRecomputeChildren_0args() throws Exception {
        System.out.println("recomputeChildren");
        int from = 0;
        int to = Integer.MAX_VALUE;
        CachedChildrenTreeModelImpl instance = new CachedChildrenTreeModelImpl();
        assertFalse(instance.isChildernComputed());
        Object[] result = instance.getChildren("", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"a", "b", "c"}, result);
        result = instance.getChildren("a", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"aa", "ab", "ac"}, result);
        
        result = instance.getChildren("", from, to);
        result = instance.getChildren("a", from, to);
        assertFalse(instance.isChildernComputed());
        
        instance.doRecomputeChildren();
        assertTrue(instance.isChildernComputed());
        
        result = instance.getChildren("", from, to);
        result = instance.getChildren("a", from, to);
        assertFalse(instance.isChildernComputed());
    }

    /**
     * Test of recomputeChildren method, of class CachedChildrenTreeModel.
     */
    @Test
    public void testRecomputeChildren_Object() throws Exception {
        System.out.println("recomputeChildren");
        int from = 0;
        int to = Integer.MAX_VALUE;
        CachedChildrenTreeModelImpl instance = new CachedChildrenTreeModelImpl();
        assertFalse(instance.isChildernComputed());
        Object[] result = instance.getChildren("", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"a", "b", "c"}, result);
        result = instance.getChildren("a", from, to);
        assertTrue(instance.isChildernComputed());
        assertArrayEquals(new Object[] {"aa", "ab", "ac"}, result);
        
        result = instance.getChildren("", from, to);
        result = instance.getChildren("a", from, to);
        assertFalse(instance.isChildernComputed());
        
        instance.doRecomputeChildren("a");
        assertTrue(instance.isChildernComputed());
        
        result = instance.getChildren("", from, to);
        result = instance.getChildren("a", from, to);
        assertFalse(instance.isChildernComputed());
    }

    public class CachedChildrenTreeModelImpl extends CachedChildrenTreeModel {
        
        private AtomicBoolean childernComputed = new AtomicBoolean(false);

        @Override
        public Object[] computeChildren(Object node) throws UnknownTypeException {
            String s = (String) node;
            childernComputed.set(true);
            return new Object[] { s+"a", s+"b", s+"c" };
        }
        
        boolean isChildernComputed() {
            return childernComputed.getAndSet(false);
        }

        @Override
        protected boolean cacheChildrenOf(Object node) {
            if ("cc".equals(node)) {
                return false;
            }
            return super.cacheChildrenOf(node);
        }
        
        void doRefreshCache(Object node) {
            refreshCache(node);
        }
        
        void doClearCache() {
            clearCache();
        }
        
        void doRecomputeChildren() throws UnknownTypeException {
            recomputeChildren();
        }
        
        void doRecomputeChildren(Object node) throws UnknownTypeException {
            recomputeChildren(node);
        }
        
        @Override
        public Object getRoot() {
            return "";
        }

        @Override
        public boolean isLeaf(Object node) throws UnknownTypeException {
            return false;
        }

        @Override
        public int getChildrenCount(Object node) throws UnknownTypeException {
            return Integer.MAX_VALUE;
        }

        @Override
        public void addModelListener(ModelListener l) {
        }

        @Override
        public void removeModelListener(ModelListener l) {
        }
    }
    
}