fr.gael.dhus.util.functional.collect.SortedMapTest.java Source code

Introduction

Here is the source code for fr.gael.dhus.util.functional.collect.SortedMapTest.java

Source

/*
 * Data Hub Service (DHuS) - For Space data distribution.
 * Copyright (C) 2016 GAEL Systems
 *
 * This file is part of DHuS software sources.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
package fr.gael.dhus.util.functional.collect;

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.collections4.comparators.ComparableComparator;
import org.testng.Assert;

import org.testng.annotations.Test;

/**
 * Tests for SortedMap.
 *
 * As SortedMap is read-only, this class will only test read functionalities.
 * It will focus on iterators.
 */
public class SortedMapTest {

    /** Test data set. */
    private final Map<Integer, String> dataSet = new HashMap<>();

    /** A classic lexicographic-order comparator. */
    private final Comparator<String> cmp = new ComparableComparator<>();

    /** Initialises `dataSet` Map */
    public SortedMapTest() {
        dataSet.put(0, "zz");
        dataSet.put(10, "za");
        dataSet.put(1, "oo");
        dataSet.put(11, "oa");
        dataSet.put(2, "jj");
        dataSet.put(12, "jk");
        dataSet.put(3, "ee");
        dataSet.put(13, "ez");
        dataSet.put(4, "aa");
        dataSet.put(14, "az");
    }

    /** Constructor: If both params are null, must throw an IllegalArgumentException. */
    @Test(expectedExceptions = NullPointerException.class)
    @SuppressWarnings("ResultOfObjectAllocationIgnored")
    public void doubleNullTest() {
        new SortedMap(null, null);
    }

    /** Constructor: If map param is null, must throw an IllegalArgumentException. */
    @Test(expectedExceptions = NullPointerException.class)
    @SuppressWarnings("ResultOfObjectAllocationIgnored")
    public void nullMapTest() {
        new SortedMap(null, new ComparableComparator<>());
    }

    /** Constructor: If comparator param is null, must throw an IllegalArgumentException. */
    @Test(expectedExceptions = NullPointerException.class)
    @SuppressWarnings("ResultOfObjectAllocationIgnored")
    public void nullComparatorTest() {
        new SortedMap(Collections.EMPTY_MAP, null);
    }

    /** Constructor: Empty map param. */
    @Test
    public void emptyMapTest() {
        SortedMap sorted_map = new SortedMap(Collections.emptyMap(), cmp);
        Assert.assertTrue(sorted_map.isEmpty());
        Assert.assertEquals(sorted_map.size(), 0);
        Assert.assertFalse(sorted_map.keySet().iterator().hasNext());
        Assert.assertFalse(sorted_map.values().iterator().hasNext());
        Assert.assertFalse(sorted_map.entrySet().iterator().hasNext());
    }

    /** Tests if maps correctly. */
    @Test
    public void sortedMapTest() {
        SortedMap<Integer, String> sorted_map = new SortedMap<>(dataSet, cmp);
        Assert.assertEquals(sorted_map.size(), dataSet.size());

        for (Map.Entry<Integer, String> entry : sorted_map.entrySet()) {
            Assert.assertSame(entry.getValue(), dataSet.get(entry.getKey()));
        }

        Assert.assertTrue(sorted_map.values().containsAll(dataSet.values()));
        Assert.assertTrue(dataSet.values().containsAll(sorted_map.values()));

        Assert.assertTrue(sorted_map.keySet().containsAll(dataSet.keySet()));
        Assert.assertTrue(dataSet.keySet().containsAll(sorted_map.keySet()));
    }

    /** Tests if map is sorted (keySet). */
    @Test
    public void sortedKeysTest() {
        SortedMap<Integer, String> sorted_map = new SortedMap<>(dataSet, cmp);

        // the map should have been sorted in the lexicographic order.
        String prev_val = null;
        for (Integer key : sorted_map.keySet()) {
            String curr_val = dataSet.get(key);
            if (prev_val != null) {
                Assert.assertTrue(curr_val.compareTo(prev_val) >= 0);
            }
            prev_val = curr_val;
        }
    }

    /** Tests if map is sorted (values). */
    @Test
    public void sortedValuesTest() {
        SortedMap<Integer, String> sorted_map = new SortedMap<>(dataSet, cmp);

        String prev_val = null;
        for (String val : sorted_map.values()) {
            if (prev_val != null) {
                Assert.assertTrue(val.compareTo(prev_val) >= 0);
            }
            prev_val = val;
        }
    }

    /** Tests if map is sorted (entries). */
    @Test
    public void sortedEntriesTest() {
        SortedMap<Integer, String> sorted_map = new SortedMap<>(dataSet, cmp);

        String prev_val = null;
        for (Map.Entry<Integer, String> entry : sorted_map.entrySet()) {
            if (prev_val != null) {
                Assert.assertTrue(entry.getValue().compareTo(prev_val) >= 0);
            }
            prev_val = entry.getValue();
        }
    }
}