platform/openide.util/test/unit/src/org/openide/util/NbCollectionsTest.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.openide.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Scanner;
import java.util.Set;
import java.util.logging.Level;
import org.netbeans.junit.NbTestCase;
import org.openide.util.NbCollections;

/**
 * @author Jesse Glick
 */
@SuppressWarnings("unchecked")
public class NbCollectionsTest extends NbTestCase {

    public NbCollectionsTest(String name) {
        super(name);
    }
    
    protected Level logLevel() {
        return Level.SEVERE;
    }

    public void testCheckedSetByCopy() throws Exception {
        Set s = new HashSet();
        s.add(1);
        s.add(2);
        Set<Integer> checked = NbCollections.checkedSetByCopy(s, Integer.class, true);
        assertEquals(s, checked);
        s.add("three");
        try {
            NbCollections.checkedSetByCopy(s, Integer.class, true);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertEquals(checked, NbCollections.checkedSetByCopy(s, Integer.class, false));
        s.remove("three");
        s.add(null);
        checked = NbCollections.checkedSetByCopy(s, Integer.class, true);
        assertEquals("nulls preserved", s, checked);
        s.clear();
        s.add(5);
        assertEquals("modifications to original not reflected", 3, checked.size());
    }

    public void testCheckedListByCopy() throws Exception {
        doTestCheckedListByCopy(new ArrayList());
        doTestCheckedListByCopy(new LinkedList());
    }
    
    private void doTestCheckedListByCopy(List l) {
        l.add(1);
        l.add(2);
        List<Integer> checked = NbCollections.checkedListByCopy(l, Integer.class, true);
        assertEquals(l, checked);
        l.add("three");
        try {
            NbCollections.checkedListByCopy(l, Integer.class, true);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertEquals(checked, NbCollections.checkedListByCopy(l, Integer.class, false));
        l.remove("three");
        l.add(null);
        checked = NbCollections.checkedListByCopy(l, Integer.class, true);
        assertEquals("nulls preserved", l, checked);
        l.clear();
        l.add(5);
        assertEquals("modifications to original not reflected", 3, checked.size());
    }

    public void testCheckedMapByCopy() throws Exception {
        Map m = new HashMap();
        m.put(1, "hello");
        m.put(2, "goodbye");
        Map<Integer,String> checked = NbCollections.checkedMapByCopy(m, Integer.class, String.class, true);
        assertEquals(m, checked);
        m.put(2, new Object());
        try {
            NbCollections.checkedMapByCopy(m, Integer.class, String.class, true);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertEquals(Collections.singletonMap(1, "hello"), NbCollections.checkedMapByCopy(m, Integer.class, String.class, false));
        m.remove(2);
        Long three = 3L;
        m.put(three, "oops!");
        try {
            NbCollections.checkedMapByCopy(m, Integer.class, String.class, true);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertEquals(Collections.singletonMap(1, "hello"), NbCollections.checkedMapByCopy(m, Integer.class, String.class, false));
        m.remove(three);
        m.put(null, null);
        checked = NbCollections.checkedMapByCopy(m, Integer.class, String.class, true);
        assertEquals("nulls preserved", m, checked);
        m.clear();
        m.put(5, "new");
        assertEquals("modifications to original not reflected", 2, checked.size());
    }

    public void testCheckedIteratorByFilter() throws Exception {
        Iterator raw = Arrays.asList("one", 2, "three").iterator();
        Iterator<String> strings = NbCollections.checkedIteratorByFilter(raw, String.class, false);
        assertTrue(strings.hasNext());
        assertEquals("one", strings.next());
        assertTrue(strings.hasNext());
        assertEquals("three", strings.next());
        assertFalse(strings.hasNext());
        raw = Arrays.asList("one", 2, "three").iterator();
        strings = NbCollections.checkedIteratorByFilter(raw, String.class, true);
        try {
            while (strings.hasNext()) {
                strings.next();
            }
            fail();
        } catch (ClassCastException e) {/*OK*/}
        raw = Arrays.asList("one", "three").iterator();
        strings = NbCollections.checkedIteratorByFilter(raw, String.class, true);
        assertTrue(strings.hasNext());
        assertEquals("one", strings.next());
        assertTrue(strings.hasNext());
        assertEquals("three", strings.next());
        assertFalse(strings.hasNext());
        List l = new ArrayList(Arrays.asList(new Object[] {"one", 2, "three"}));
        raw = l.iterator();
        strings = NbCollections.checkedIteratorByFilter(raw, String.class, false);
        assertTrue(strings.hasNext());
        assertEquals("one", strings.next());
        strings.remove();
        assertEquals(2, l.size());
        assertTrue(strings.hasNext());
        assertEquals("three", strings.next());
        assertFalse(strings.hasNext());
    }

    public void testCheckedSetByFilter() throws Exception {
        Set s = new HashSet();
        s.add("hello");
        s.add("there");
        s.add(1);
        s.add("goodbye");
        s.add(2);
        Set<String> s2 = NbCollections.checkedSetByFilter(s, String.class, false);
        assertEquals(3, s2.size());
        assertEquals(new HashSet(Arrays.asList(new String[] {"hello", "there", "goodbye"})), s2);
        assertTrue(s2.contains("hello"));
        assertFalse(s2.contains("nowhere"));
        try {
            s2.contains(2);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        Iterator<String> it = s2.iterator();
        while (it.hasNext()) {
            if (it.next().equals("hello")) {
                it.remove();
            }
        }
        assertEquals(2, s2.size());
        assertEquals(new HashSet(Arrays.asList(new String[] {"there", "goodbye"})), s2);
        assertEquals(4, s.size());
        it = s2.iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
        assertEquals(0, s2.size());
        assertEquals(Collections.emptySet(), s2);
        assertEquals(new HashSet(Arrays.asList(new Integer[] {1, 2})), s);
        s.clear();
        s.add("new");
        assertEquals("modifications to original found", Collections.singleton("new"), s2);
        assertTrue(s2.add("additional"));
        assertEquals("original set modified too", new HashSet(Arrays.asList(new String[] {"new", "additional"})), s);
        try {
            ((Set) s2).add(13);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        // Other:
        assertEquals("preserved by serialization", s2, cloneBySerialization(s2));
        assertEquals("empty set filtered as empty", Collections.emptySet(), NbCollections.checkedSetByFilter(Collections.emptySet(), String.class, false));
        assertEquals("empty set from wholly wrong set", Collections.emptySet(), NbCollections.checkedSetByFilter(Collections.singleton(5), String.class, false));
        // Make sure iterator behaves fully acc. to contract:
        Set<Integer> s3 = NbCollections.checkedSetByFilter(new HashSet(Collections.singleton(1)), Integer.class, false);
        Iterator<Integer> it3 = s3.iterator();
        assertTrue(it3.hasNext());
        assertTrue(it3.hasNext());
        assertEquals(new Integer(1), it3.next());
        assertFalse(it3.hasNext());
        assertFalse(it3.hasNext());
        try {
            it3.next();
            fail();
        } catch (NoSuchElementException e) {/*OK*/}
        it3 = s3.iterator();
        try {
            it3.remove();
            fail();
        } catch (IllegalStateException e) {/*OK*/}
        it3 = s3.iterator();
        it3.next();
        it3.remove();
        try {
            it3.remove();
            fail();
        } catch (IllegalStateException e) {/*OK*/}
    }

    public void testCheckedSetByFilterStrict() throws Exception {
        Set s = new HashSet();
        s.add("hello");
        s.add("there");
        s.add(1);
        s.add("goodbye");
        s.add(2);
        Set<String> s2 = NbCollections.checkedSetByFilter(s, String.class, true);
        try {
            s2.size();
            fail();
        } catch (ClassCastException x) {/*OK*/}
        try {
            new HashSet<String>(s2);
            fail();
        } catch (ClassCastException x) {/*OK*/}
        s.remove(1);
        s.remove(2);
        assertEquals(3, s2.size());
        assertTrue(s2.contains("hello"));
        try {
            s2.contains(2);
            fail();
        } catch (ClassCastException e) {/*OK*/}
    }

    public void testCheckedMapByFilter() throws Exception {
        Map m = new HashMap();
        m.put(1, "one");
        m.put(2, "two");
        m.put("three", "three");
        m.put(4, 4);
        Map<Integer,String> m2 = NbCollections.checkedMapByFilter(m, Integer.class, String.class, false);
        assertEquals(2, m2.size());
        assertEquals("one", m2.get(1));
        try {
            m2.get("three");
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertEquals(null, m2.get(4));
        assertTrue(m2.containsKey(1));
        assertFalse(m2.containsKey(5));
        try {
            m2.containsKey("three");
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertFalse(m2.containsKey(4));
        assertTrue(m2.containsValue("one"));
        assertFalse(m2.containsValue("five"));
        try {
            m2.containsValue(3);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertFalse(m2.containsValue("three"));
        assertEquals(2, m2.entrySet().size());
        assertEquals(2, m2.keySet().size());
        assertEquals(2, m2.values().size());
        assertTrue(m2.keySet().contains(1));
        assertFalse(m2.keySet().contains(5));
        try {
            m2.keySet().contains("three");
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertFalse(m2.keySet().contains(4));
        assertTrue(m2.values().contains("one"));
        assertFalse(m2.values().contains("five"));
        try {
            m2.values().contains(4);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        assertFalse(m2.values().contains("three"));
        // Destructive operations:
        m2.put(1, "#one");
        assertEquals("#one", m2.get(1));
        assertEquals("#one", m.get(1));
        try {
            ((Map) m2).put("five", "five");
            fail();
        } catch (ClassCastException e) {/*OK*/}
        try {
            ((Map) m2).put(5, 5);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        m2.remove(1);
        assertEquals(Collections.singletonMap(2, "two"), m2);
        assertEquals(3, m.size());
        m2.entrySet().clear();
        assertTrue(m2.isEmpty());
        assertEquals(2, m.size());
        m.clear();
        m.put(1, "one");
        m.put(2, "two");
        m.put(3, 3);
        m.put("four", "four");
        assertTrue(m2.keySet().remove(1));
        assertFalse(m2.keySet().remove(3));
        assertFalse(m2.keySet().remove("four"));
        assertEquals(Collections.singletonMap(2, "two"), m2);
        m.put(1, "one");
        assertTrue(m2.values().remove("one"));
        assertFalse(m2.values().remove(3));
        assertFalse(m2.values().remove("four"));
        assertEquals(Collections.singletonMap(2, "two"), m2);
        assertEquals(3, m.size());
        // Other:
        assertEquals(m2, cloneBySerialization(m2));
        assertEquals(Collections.emptyMap(), NbCollections.checkedMapByFilter(Collections.emptyMap(), String.class, String.class, false));
        assertEquals(Collections.emptyMap(), NbCollections.checkedMapByFilter(Collections.singletonMap(1, "two"), String.class, String.class, false));
        assertEquals(Collections.emptyMap(), NbCollections.checkedMapByFilter(Collections.singletonMap("one", 2), String.class, String.class, false));
        // Misc. return values have to reflect nature of view:
        m.clear();
        m.put(1, 1);
        assertEquals(null, m2.put(1, "one"));
        m.put(1, 1);
        assertEquals(null, m2.remove(1));
        m.put(1, "one");
        assertEquals("one", m2.put(1, "#one"));
        assertEquals("#one", m2.remove(1));
    }

    public void testCheckedMapByFilterStrict() throws Exception {
        Map m = new HashMap();
        m.put(1, "one");
        m.put(2, "two");
        m.put("three", "three");
        m.put(4, 4);
        Map<Integer,String> m2 = NbCollections.checkedMapByFilter(m, Integer.class, String.class, true);
        try {
            m2.size();
            fail();
        } catch (ClassCastException e) {/*OK*/}
        try {
            new HashMap<Integer,String>(m2);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        try {
            m2.get("three");
            fail();
        } catch (ClassCastException e) {/*OK*/}
        m.remove("three");
        try {
            m2.size();
            fail();
        } catch (ClassCastException e) {/*OK*/}
        m.remove(4);
        m.put("three", "three");
        try {
            m2.size();
            fail();
        } catch (ClassCastException e) {/*OK*/}
        m.remove("three");
        assertEquals(2, m2.size());
        assertEquals("one", m2.get(1));
    }

    public void testCheckedEnumerationByFilter() throws Exception {
        Enumeration<?> raw = Collections.enumeration(Arrays.asList("one", 2, "three"));
        Enumeration<String> strings = NbCollections.checkedEnumerationByFilter(raw, String.class, false);
        assertTrue(strings.hasMoreElements());
        assertEquals("one", strings.nextElement());
        assertTrue(strings.hasMoreElements());
        assertEquals("three", strings.nextElement());
        assertFalse(strings.hasMoreElements());
    }

    public void testCheckedEnumerationByFilterStrict() throws Exception {
        Enumeration<?> raw = Collections.enumeration(Arrays.asList("one", 2, "three"));
        Enumeration<String> strings = NbCollections.checkedEnumerationByFilter(raw, String.class, true);
        try {
            Collections.list(strings);
            fail();
        } catch (ClassCastException e) {/*OK*/}
        raw = Collections.enumeration(Arrays.asList("one", "three"));
        strings = NbCollections.checkedEnumerationByFilter(raw, String.class, true);
        assertTrue(strings.hasMoreElements());
        assertEquals("one", strings.nextElement());
        assertTrue(strings.hasMoreElements());
        assertEquals("three", strings.nextElement());
        assertFalse(strings.hasMoreElements());
    }

    static Object cloneBySerialization(Object o) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(o);
        oos.close();
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        return new ObjectInputStream(bais).readObject();
    }

    public void testIterable() throws Exception {
        String text = "hello kitty!";
        List<String> l1 = new ArrayList<String>();
        for (String token : NbCollections.iterable(new Scanner(text))) {
            l1.add(token);
        }
        assertEquals(Arrays.asList("hello", "kitty!"), l1);
        for (String token : NbCollections.iterable(new Scanner(""))) {
            fail();
        }
        try {
            NbCollections.iterable((Iterator<?>) null);
            fail();
        } catch (NullPointerException x) {/* OK */}
        List<URL> l2 = new ArrayList<URL>();
        for (URL u : NbCollections.iterable(NbCollections.class.getClassLoader().getResources(NbCollections.class.getName().replace('.', '/') + ".class"))) {
            assertNotNull(u);
            l2.add(u);
        }
        assertFalse(l2.isEmpty()); // permissible to have >1 element in case JAR doubly added to CP
        for (URL u : NbCollections.iterable(NbCollections.class.getClassLoader().getResources("nonexistent"))) {
            fail();
        }
        try {
            NbCollections.iterable((Enumeration<?>) null);
            fail();
        } catch (NullPointerException x) {/* OK */}
    }

}