EDIT

/**

* Copyright (C) 2013 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.store.utility;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import java.util.Arrays;

import java.util.Collection;

import java.util.Iterator;

import java.util.LinkedHashMap;

import org.junit.Test;

import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

import eu.etaxonomy.cdm.model.name.RankClass;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;

import eu.etaxonomy.cdm.model.reference.OriginalSourceType;

import eu.etaxonomy.cdm.model.reference.ReferenceType;

import eu.etaxonomy.cdm.model.term.IEnumTerm;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

/**

 * @author pplitzner

 * @date 04.11.2013

 */

public class AbstractUtilityTest {

    @Test

    public void testOrderTerms(){

        LinkedHashMap<? extends IEnumTerm<?>, String> orderedTerms;

        orderedTerms = AbstractUtility.orderTerms(Arrays.asList(SpecimenOrObservationType.values()));

        check(orderedTerms, Arrays.asList(SpecimenOrObservationType.values()));

        orderedTerms = AbstractUtility.orderTerms(Arrays.asList(NomenclaturalCode.values()));

        check(orderedTerms, Arrays.asList(NomenclaturalCode.values()));

        orderedTerms = AbstractUtility.orderTerms(Arrays.asList(OriginalSourceType.values()));

        check(orderedTerms, Arrays.asList(OriginalSourceType.values()));

        orderedTerms = AbstractUtility.orderTerms(Arrays.asList(PreferencePredicate.values()));

        check(orderedTerms, Arrays.asList(PreferencePredicate.values()));

        orderedTerms = AbstractUtility.orderTerms(Arrays.asList(RankClass.values()));

        check(orderedTerms, Arrays.asList(RankClass.values()));

        orderedTerms = AbstractUtility.orderTerms(Arrays.asList(ReferenceType.values()));

        check(orderedTerms, Arrays.asList(ReferenceType.values()));

        orderedTerms = AbstractUtility.orderTerms(Arrays.asList(TermType.values()));

        check(orderedTerms, Arrays.asList(TermType.values()));

    }

    private void check(LinkedHashMap<? extends IEnumTerm<?>, String> orderedTerms, Collection<? extends IEnumTerm<?>> expectedTerms) {

        assertFalse("Ordered term list is empty!", orderedTerms.isEmpty());

        assertEquals("Some terms got lost while ordering.", expectedTerms.size(), orderedTerms.size());

        Iterator<String> itti = orderedTerms.values().iterator();

        String first = itti.next();

        while (itti.hasNext()) {

            String next = itti.next();

            if(next.startsWith(" -")){

                assertTrue("Sorting is not alphabetically correct.", first.compareTo(next)<0);

            }

        }

    }

}