LongLongHashMapValuesTest.java

/*
 * Copyright 2014 Goldman Sachs.
 *
 * 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 org.mapdb.indexTreeLongLongMapTests_GS_GENERATED;

import org.eclipse.collections.api.LongIterable;
import org.eclipse.collections.api.block.function.primitive.LongToObjectFunction;
import org.eclipse.collections.api.collection.primitive.MutableLongCollection;
import org.eclipse.collections.api.iterator.LongIterator;
import org.eclipse.collections.api.list.MutableList;
import org.eclipse.collections.api.map.primitive.MutableLongLongMap;
import org.eclipse.collections.impl.block.factory.primitive.LongPredicates;
import org.eclipse.collections.impl.collection.mutable.primitive.SynchronizedLongCollection;
import org.eclipse.collections.impl.collection.mutable.primitive.UnmodifiableLongCollection;
import org.eclipse.collections.impl.list.mutable.FastList;
import org.eclipse.collections.impl.list.mutable.primitive.LongArrayList;
import org.eclipse.collections.impl.test.Verify;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;

import java.util.NoSuchElementException;

/**
 * JUnit test for {@link MutableLongLongMap#values()}.
 * This file was automatically generated from template file primitivePrimitiveHashMapValuesTest.stg.
 */
public abstract class LongLongHashMapValuesTest extends AbstractMutableLongCollectionTestCase
{
//    @Override
//    protected MutableLongCollection classUnderTest()
//    {
//        return MutableLongLongMap.newWithKeysValues(1L, 1L, 2L, 2L, 3L, 3L).values();
//    }
//
//    @Override
//    protected MutableLongCollection newWith(long... elements)
//    {
//        MutableLongLongMap map = new MutableLongLongMap();
//        for (int i = 0; i < elements.length; i++)
//        {
//            map.put(i, elements[i]);
//        }
//        return map.values();
//    }
//
    @Override
    protected MutableLongCollection newMutableCollectionWith(long... elements)
    {
        return this.newWith(elements);
    }

    @Override
    protected MutableList<Long> newObjectCollectionWith(Long... elements)
    {
        return FastList.newListWith(elements);
    }

    @Override
    @Test
    public void longIterator()
    {
        MutableLongCollection bag = this.newWith(0L, 1L, 2L, 3L);
        LongArrayList list = LongArrayList.newListWith(0L, 1L, 2L, 3L);
        LongIterator iterator = bag.longIterator();
        for (int i = 0; i < 4; i++)
        {
            Assert.assertTrue(iterator.hasNext());
            Assert.assertTrue(list.remove(iterator.next()));
        }
        Verify.assertEmpty(list);
        Assert.assertFalse(iterator.hasNext());

        Verify.assertThrows(NoSuchElementException.class, iterator::next);
    }

    @Override
    @Test(expected = UnsupportedOperationException.class)
    public void addAllIterable()
    {
        this.classUnderTest().addAll(new LongArrayList());
    }

    @Override
    @Test(expected = UnsupportedOperationException.class)
    public void add()
    {
        this.classUnderTest().add(0L);
    }


    @Override
    @Test(expected = UnsupportedOperationException.class)
    public void addAllArray()
    {
        this.classUnderTest().addAll(0L, 1L);
    }

    @Override
    @Test(expected = UnsupportedOperationException.class)
    public void with()
    {
        this.classUnderTest().with(0L);
    }

    @Override
    @Test(expected = UnsupportedOperationException.class)
    public void without()
    {
        this.classUnderTest().without(0L);
    }

    @Override
    @Test(expected = UnsupportedOperationException.class)
    public void withAll()
    {
        this.classUnderTest().withAll(new LongArrayList());
    }

    @Override
    @Test(expected = UnsupportedOperationException.class)
    public void withoutAll()
    {
        this.classUnderTest().withoutAll(new LongArrayList());
    }

    @Override
    @Test
    public void remove()
    {
        MutableLongLongMap map =  newWithKeysValues(1L, 1L, 2L, 2L, 3L, 3L);
        MutableLongCollection collection = map.values();
        Assert.assertTrue(collection.remove(3L));
        Assert.assertFalse(collection.contains(3L));
        Assert.assertTrue(collection.contains(1L));
        Assert.assertTrue(collection.contains(2L));
        Assert.assertFalse(map.contains(3L));
        Assert.assertTrue(map.contains(1L));
        Assert.assertTrue(map.contains(2L));
    }

    protected abstract MutableLongLongMap newWithKeysValues(long... args);

    @Override
    @Test @Ignore
    public void asSynchronized()
    {
        MutableLongCollection collection = this.classUnderTest();
        Verify.assertInstanceOf(SynchronizedLongCollection.class, collection.asSynchronized());
        Assert.assertTrue(collection.asSynchronized().containsAll(this.classUnderTest()));
    }

    @Override
    @Test @Ignore
    public void asUnmodifiable()
    {
        MutableLongCollection collection = this.classUnderTest();
        Verify.assertInstanceOf(UnmodifiableLongCollection.class, collection.asUnmodifiable());
        Assert.assertTrue(collection.asUnmodifiable().containsAll(this.classUnderTest()));
    }

    @Override
    @Test
    public void removeAll()
    {
        Assert.assertFalse(this.newWith().removeAll());
        Assert.assertFalse(this.newWith().removeAll(1L));

        MutableLongLongMap map = newWithKeysValues(1L, 1L, 2L, 2L, 3L, 3L);
        MutableLongCollection collection = map.values();
        Assert.assertFalse(collection.removeAll());

        Assert.assertTrue(collection.removeAll(1L, 5L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertTrue(collection.contains(2L));
        Assert.assertTrue(collection.contains(3L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertTrue(map.contains(2L));
        Assert.assertTrue(map.contains(3L));

        Assert.assertTrue(collection.removeAll(3L, 2L));
        Assert.assertTrue(collection.isEmpty());
        Assert.assertFalse(collection.contains(1L));
        Assert.assertFalse(collection.contains(2L));
        Assert.assertFalse(collection.contains(3L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertFalse(map.contains(2L));
        Assert.assertFalse(map.contains(3L));
        Assert.assertTrue(map.isEmpty());
    }

    @Override
    @Test
    public void removeAll_iterable()
    {
        Assert.assertFalse(this.newWith().removeAll(new LongArrayList()));
        Assert.assertFalse(this.newWith().removeAll(LongArrayList.newListWith(1L)));

        MutableLongLongMap map = newWithKeysValues(1L, 1L, 2L, 2L, 3L, 3L);
        MutableLongCollection collection = map.values();
        Assert.assertFalse(collection.removeAll());

        Assert.assertTrue(collection.removeAll(LongArrayList.newListWith(1L, 5L)));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertTrue(collection.contains(2L));
        Assert.assertTrue(collection.contains(3L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertTrue(map.contains(2L));
        Assert.assertTrue(map.contains(3L));

        Assert.assertTrue(collection.removeAll(LongArrayList.newListWith(3L, 2L)));
        Assert.assertTrue(collection.isEmpty());
        Assert.assertFalse(collection.contains(1L));
        Assert.assertFalse(collection.contains(2L));
        Assert.assertFalse(collection.contains(3L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertFalse(map.contains(2L));
        Assert.assertFalse(map.contains(3L));
        Assert.assertTrue(map.isEmpty());
    }

    @Override
    @Test
    public void retainAll()
    {
        Assert.assertFalse(this.newWith().retainAll());
        Assert.assertFalse(this.newWith().retainAll(1L));

        MutableLongLongMap map = newWithKeysValues(0L, 0L, 1L, 1L, 2L, 2L, 3L, 3L);
        MutableLongCollection collection = map.values();
        Assert.assertFalse(collection.retainAll(0L, 1L, 2L, 3L));

        Assert.assertTrue(collection.retainAll(0L, 2L, 3L, 5L));
        Assert.assertTrue(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertTrue(collection.contains(2L));
        Assert.assertTrue(collection.contains(3L));
        Assert.assertFalse(collection.contains(5L));
        Assert.assertTrue(map.contains(0L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertTrue(map.contains(2L));
        Assert.assertTrue(map.contains(3L));
        Assert.assertFalse(map.contains(5L));

        Assert.assertTrue(collection.retainAll(2L, 3L, 5L));
        Assert.assertFalse(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertTrue(collection.contains(2L));
        Assert.assertTrue(collection.contains(3L));
        Assert.assertFalse(collection.contains(5L));
        Assert.assertFalse(map.contains(0L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertTrue(map.contains(2L));
        Assert.assertTrue(map.contains(3L));
        Assert.assertFalse(map.contains(5L));

        Assert.assertTrue(collection.retainAll(3L, 5L));
        Assert.assertFalse(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertFalse(collection.contains(2L));
        Assert.assertTrue(collection.contains(3L));
        Assert.assertFalse(collection.contains(5L));
        Assert.assertFalse(map.contains(0L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertFalse(map.contains(2L));
        Assert.assertTrue(map.contains(3L));
        Assert.assertFalse(map.contains(5L));

        Assert.assertTrue(collection.retainAll(0L, 0L, 1L));
        Assert.assertTrue(collection.isEmpty());
        Assert.assertFalse(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertFalse(collection.contains(2L));
        Assert.assertFalse(collection.contains(3L));
        Assert.assertFalse(collection.contains(5L));
        Assert.assertFalse(map.contains(0L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertFalse(map.contains(2L));
        Assert.assertFalse(map.contains(3L));
        Assert.assertFalse(map.contains(5L));
        Assert.assertTrue(map.isEmpty());
    }

    @Override
    @Test
    public void retainAll_iterable()
    {
        Assert.assertFalse(this.newWith().retainAll(new LongArrayList()));
        Assert.assertFalse(this.newWith().retainAll(LongArrayList.newListWith(1L)));

        MutableLongLongMap map = newWithKeysValues(0L, 0L, 1L, 1L, 2L, 2L, 3L, 3L);
        MutableLongCollection collection = map.values();
        Assert.assertFalse(collection.retainAll(LongArrayList.newListWith(0L, 1L, 2L, 3L)));

        Assert.assertTrue(collection.retainAll(LongArrayList.newListWith(0L, 2L, 3L, 5L)));
        Assert.assertTrue(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertTrue(collection.contains(2L));
        Assert.assertTrue(collection.contains(3L));
        Assert.assertFalse(collection.contains(5L));
        Assert.assertTrue(map.contains(0L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertTrue(map.contains(2L));
        Assert.assertTrue(map.contains(3L));
        Assert.assertFalse(map.contains(5L));

        Assert.assertTrue(collection.retainAll(LongArrayList.newListWith(2L, 3L, 5L)));
        Assert.assertFalse(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertTrue(collection.contains(2L));
        Assert.assertTrue(collection.contains(3L));
        Assert.assertFalse(collection.contains(5L));
        Assert.assertFalse(map.contains(0L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertTrue(map.contains(2L));
        Assert.assertTrue(map.contains(3L));
        Assert.assertFalse(map.contains(5L));

        Assert.assertTrue(collection.retainAll(LongArrayList.newListWith(3L, 5L)));
        Assert.assertFalse(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertFalse(collection.contains(2L));
        Assert.assertTrue(collection.contains(3L));
        Assert.assertFalse(collection.contains(5L));
        Assert.assertFalse(map.contains(0L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertFalse(map.contains(2L));
        Assert.assertTrue(map.contains(3L));
        Assert.assertFalse(map.contains(5L));

        Assert.assertTrue(collection.retainAll(LongArrayList.newListWith(0L, 0L, 1L)));
        Assert.assertTrue(collection.isEmpty());
        Assert.assertFalse(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertFalse(collection.contains(2L));
        Assert.assertFalse(collection.contains(3L));
        Assert.assertFalse(collection.contains(5L));
        Assert.assertFalse(map.contains(0L));
        Assert.assertFalse(map.contains(1L));
        Assert.assertFalse(map.contains(2L));
        Assert.assertFalse(map.contains(3L));
        Assert.assertFalse(map.contains(5L));
        Assert.assertTrue(map.isEmpty());
    }

    @Override
    @Test
    public void clear()
    {
        MutableLongCollection emptyCollection = this.newWith();
        emptyCollection.clear();
        Verify.assertSize(0, emptyCollection);

        MutableLongLongMap map = newWithKeysValues(1L, 1L, 2L, 2L, 3L, 3L);
        MutableLongCollection collection = map.values();
        collection.clear();
        Verify.assertEmpty(collection);
        Verify.assertEmpty(map);
        Verify.assertSize(0, collection);
        Assert.assertFalse(collection.contains(0L));
        Assert.assertFalse(collection.contains(1L));
        Assert.assertFalse(collection.contains(2L));
        Assert.assertFalse(collection.contains(3L));

        MutableLongCollection collection1 = this.newWith(0L, 1L, 31L, 32L);
        collection1.clear();
        Verify.assertEmpty(collection1);
        Verify.assertSize(0, collection1);
        Assert.assertFalse(collection1.contains(0L));
        Assert.assertFalse(collection1.contains(1L));
        Assert.assertFalse(collection1.contains(31L));
        Assert.assertFalse(collection1.contains(32L));

        MutableLongCollection collection2 = this.newWith(0L, 1L, 2L);
        collection2.clear();
        Verify.assertSize(0, collection2);
    }

    @Override
    @Test
    public void contains()
    {
        MutableLongCollection collection = this.newWith(14L, 2L, 30L, 31L, 32L, 35L, 0L, 1L);
        Assert.assertFalse(collection.contains(29L));
        Assert.assertFalse(collection.contains(49L));

        long[] numbers = {14L, 2L, 30L, 31L, 32L, 35L, 0L, 1L};
        for (long number : numbers)
        {
            Assert.assertTrue(collection.contains(number));
            Assert.assertTrue(collection.remove(number));
            Assert.assertFalse(collection.contains(number));
        }

        Assert.assertFalse(collection.contains(29L));
        Assert.assertFalse(collection.contains(49L));
    }

    @Override
    @Test
    public void reject()
    {
        LongIterable iterable = this.classUnderTest();
        Verify.assertSize(0, iterable.reject(LongPredicates.lessThan(4L)));
        Verify.assertSize(1, iterable.reject(LongPredicates.lessThan(3L)));
    }

    @Override
    @Test
    public void select()
    {
        LongIterable iterable = this.classUnderTest();
        Verify.assertSize(3, iterable.select(LongPredicates.lessThan(4L)));
        Verify.assertSize(2, iterable.select(LongPredicates.lessThan(3L)));
    }

    @Override
    @Test
    public void collect()
    {
        LongToObjectFunction<Long> function = (long parameter) -> parameter - 1;
        Assert.assertEquals(this.newObjectCollectionWith(0L, 1L, 2L).toBag(), this.newWith(1L, 2L, 3L).collect(function).toBag());
        LongIterable iterable = this.newWith(1L, 2L, 3L);
        Assert.assertEquals(this.newObjectCollectionWith(0L, 1L, 2L).toBag(), iterable.collect(function).toBag());
        Assert.assertArrayEquals(this.newObjectCollectionWith().toArray(), this.newWith().collect(function).toArray());
        Assert.assertArrayEquals(this.newObjectCollectionWith(2L).toArray(), this.newWith(3L).collect(function).toArray());
    }

    @Override
    @Test
    public void makeString()
    {
        Assert.assertEquals("1", this.newWith(1L).makeString("/"));
        Assert.assertEquals("31", this.newWith(31L).makeString());
        Assert.assertEquals("32", this.newWith(32L).makeString());
        Assert.assertEquals("", this.newWith().makeString());
        Assert.assertEquals("", this.newWith().makeString("/"));
        Assert.assertEquals("[]", this.newWith().makeString("[", ", ", "]"));

        LongIterable iterable1 = this.newWith(0L, 31L);
        Assert.assertTrue(
                iterable1.makeString(),
                iterable1.makeString().equals("0, 31")
                        || iterable1.makeString().equals("31, 0"));

        LongIterable iterable2 = this.newWith(31L, 32L);
        Assert.assertTrue(
                iterable2.makeString("[", "/", "]"),
                iterable2.makeString("[", "/", "]").equals("[31/32]")
                        || iterable2.makeString("[", "/", "]").equals("[32/31]"));

        LongIterable iterable3 = this.newWith(32L, 33L);
        Assert.assertTrue(
                iterable3.makeString("/"),
                iterable3.makeString("/").equals("32/33")
                        || iterable3.makeString("/").equals("33/32"));

        LongIterable iterable4 = this.newWith(1L, 2L);
        Assert.assertTrue("1, 2".equals(iterable4.makeString())
                || "2, 1".equals(iterable4.makeString()));
        Assert.assertTrue("1/2".equals(iterable4.makeString("/"))
                || "2/1".equals(iterable4.makeString("/")));
        Assert.assertTrue("[1/2]".equals(iterable4.makeString("[", "/", "]"))
                || "[2/1]".equals(iterable4.makeString("[", "/", "]")));

        LongIterable iterable5 = this.newWith(0L, 1L);
        Assert.assertTrue(
                iterable5.makeString(),
                iterable5.makeString().equals("0, 1")
                        || iterable5.makeString().equals("1, 0"));
        Assert.assertTrue(
                iterable5.makeString("[", "/", "]"),
                iterable5.makeString("[", "/", "]").equals("[0/1]")
                        || iterable5.makeString("[", "/", "]").equals("[1/0]"));
        Assert.assertTrue(
                iterable5.makeString("/"),
                iterable5.makeString("/").equals("0/1")
                        || iterable5.makeString("/").equals("1/0"));
    }

    @Override
    @Test
    public void appendString()
    {
        StringBuilder appendable = new StringBuilder();
        this.newWith().appendString(appendable);
        Assert.assertEquals("", appendable.toString());
        this.newWith().appendString(appendable, "/");
        Assert.assertEquals("", appendable.toString());
        this.newWith().appendString(appendable, "[", ", ", "]");
        Assert.assertEquals("[]", appendable.toString());
        StringBuilder appendable1 = new StringBuilder();
        this.newWith(1L).appendString(appendable1);
        Assert.assertEquals("1", appendable1.toString());
        StringBuilder appendable2 = new StringBuilder();

        LongIterable iterable = this.newWith(1L, 2L);
        iterable.appendString(appendable2);
        Assert.assertTrue("1, 2".equals(appendable2.toString())
                || "2, 1".equals(appendable2.toString()));
        StringBuilder appendable3 = new StringBuilder();
        iterable.appendString(appendable3, "/");
        Assert.assertTrue("1/2".equals(appendable3.toString())
                || "2/1".equals(appendable3.toString()));

        StringBuilder appendable5 = new StringBuilder();
        this.newWith(31L).appendString(appendable5);
        Assert.assertEquals("31", appendable5.toString());

        StringBuilder appendable6 = new StringBuilder();
        this.newWith(32L).appendString(appendable6);
        Assert.assertEquals("32", appendable6.toString());

        StringBuilder appendable7 = new StringBuilder();
        LongIterable iterable1 = this.newWith(0L, 31L);
        iterable1.appendString(appendable7);
        Assert.assertTrue(appendable7.toString(), "0, 31".equals(appendable7.toString())
                || "31, 0".equals(appendable7.toString()));

        StringBuilder appendable8 = new StringBuilder();
        LongIterable iterable2 = this.newWith(31L, 32L);
        iterable2.appendString(appendable8, "/");
        Assert.assertTrue(appendable8.toString(), "31/32".equals(appendable8.toString())
                || "32/31".equals(appendable8.toString()));

        StringBuilder appendable9 = new StringBuilder();
        LongIterable iterable4 = this.newWith(32L, 33L);
        iterable4.appendString(appendable9, "[", "/", "]");
        Assert.assertTrue(appendable9.toString(), "[32/33]".equals(appendable9.toString())
                || "[33/32]".equals(appendable9.toString()));

        StringBuilder appendable10 = new StringBuilder();
        LongIterable iterable5 = this.newWith(0L, 1L);
        iterable5.appendString(appendable10);
        Assert.assertTrue(appendable10.toString(), "0, 1".equals(appendable10.toString())
                || "1, 0".equals(appendable10.toString()));
        StringBuilder appendable11 = new StringBuilder();
        iterable5.appendString(appendable11, "/");
        Assert.assertTrue(appendable11.toString(), "0/1".equals(appendable11.toString())
                || "1/0".equals(appendable11.toString()));
        StringBuilder appendable12 = new StringBuilder();
        iterable5.appendString(appendable12, "[", "/", "]");
        Assert.assertTrue(appendable12.toString(), "[0/1]".equals(appendable12.toString())
                || "[1/0]".equals(appendable12.toString()));
    }

    @Override
    @Test
    public void testEquals()
    {
        //Testing equals() is not applicable for MutableLongCollection.
    }

    @Override
    public void testToString()
    {
        //Testing toString() is not applicable for MutableLongCollection.
    }

    @Override
    public void testHashCode()
    {
        //Testing hashCode() is not applicable for MutableLongCollection.
    }

    @Override
    public void newCollection()
    {
        //Testing newCollection() is not applicable for MutableLongCollection.
    }
}