EDIT

/**

 * @author a.kohlbecker

 * @since Jul 31, 2014

 */

public class CdmTypeScanner<T> extends ClassPathScanningCandidateComponentProvider {

* 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.cdm.model.name;

import java.util.HashSet;

import eu.etaxonomy.cdm.model.common.AnnotatableEntity;

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

/**

 * The homotypical group class represents a set of {@link TaxonName taxon names} associated

 * on the base of their typifications. Since it can be asserted that two taxon

	/**

	 * Returns all taxon names in the homotypical group that have a 'is_basionym_for' (zool.: 'is_original_combination_for') relationship.

	 */

	@Transient

	public Set<TaxonName> getBasionyms(){

	/**

	 * Returns all taxon names in the homotypical group that have a 'is_replaced_synonym_for' relationship.

	 */

	@Transient

	public Set<TaxonName> getReplacedSynonym(){

	/**

	 * Returns the name relationships that represent either a basionym (original combination) relationship or

	 * a replaced synonym relationship.

	 */

	@Transient

	public Set<NameRelationship> getBasionymAndReplacedSynonymRelations(){

			return false;

		}

	}

/**

 * @author a.mueller

 */

public class DefaultTermInitializer implements ITermInitializer {

	private static final Logger logger = Logger.getLogger(DefaultTermInitializer.class);

	protected ITermLoader termLoader = new TermLoader();

			TermVocabulary<?> voc  = termLoader.loadTerms(vocabularyEnum, terms);

			setDefinedTerms(vocabularyEnum.getClazz(),voc);

		}

	}

	protected void setDefinedTerms(Class<? extends DefinedTermBase<?>> clazz, TermVocabulary<?> vocabulary) {

		}

	}

    public void setOmit(boolean omit) {

        this.omit = omit;

    }

    public boolean isOmit() {

        return omit;

    }

* 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.cdm.datagenerator;

import eu.etaxonomy.cdm.model.agent.Person;

 * This class offers functionality to create test taxa and descriptions.

 *

 * @author m.doering

 */

public class TaxonGenerator {

	private static String[] genera = {"Carex", "Abies", "Belladonna", "Dracula", "Maria", "Calendula", "Polygala", "Vincia"};

	private static String[] epitheta = {"vulgaris", "magdalena", "officinalis", "alba", "negra", "communa", "alpina", "rotundifolia", "greutheriana", "helventica", "allemania", "franca"};

	private static String[] ranks = {"subsp", "var", "f"};

        Synonym homoSynonym = Synonym.NewInstance(botSpecies4, sec);

        childTaxon.addSynonym(homoSynonym, SynonymType.HOMOTYPIC_SYNONYM_OF());

        //2nd child species taxon that is the child of genus taxon

        IBotanicalName botSpecies2= TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());

        botSpecies2.setTitleCache("Hieracium wolffii Zahn", true);

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import eu.etaxonomy.cdm.format.ICdmFormatter.FormatKey;

import eu.etaxonomy.cdm.model.description.CategoricalData;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.State;

import eu.etaxonomy.cdm.model.description.StateData;

/**

 * Test for {@link CategoricalDataFormatter}.

 * @author a.mueller

 * @since 11.03.2020

 */

    private State state1;

    private State state2;

        stateData3 = StateData.NewInstance(state3);

    }

    @Test

    public void testFormat() {

        CategoricalData catData = CategoricalData.NewInstance(Feature.HABITAT());

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import eu.etaxonomy.cdm.format.ICdmFormatter.FormatKey;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.MeasurementUnit;

import eu.etaxonomy.cdm.model.description.QuantitativeData;

import eu.etaxonomy.cdm.model.description.StatisticalMeasure;

import eu.etaxonomy.cdm.model.description.StatisticalMeasurementValue;

/**

 * Test for {@link QuantitativeDataFormatter}.

 * @author a.mueller

 * @since 12.03.2020

 */

    private StatisticalMeasurementValue min1;

    private StatisticalMeasurementValue max1;

        n1 = StatisticalMeasurementValue.NewInstance(StatisticalMeasure.SAMPLE_SIZE(), new BigDecimal("2"));

    }

    @Test

    public void testFormat() {

        QuantitativeData quantData = QuantitativeData.NewInstance(Feature.CHROMOSOME_NUMBER());

        text = formatter.format(quantData, formatKey);

        Assert.assertEquals("0.1-1.3 m [n=2]", text);

    }

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;

import eu.etaxonomy.cdm.strategy.cache.TaggedCacheHelper;

import eu.etaxonomy.cdm.strategy.cache.TaggedText;

/**

 * Test to test the {@link TaxonRelationshipFormatter}.

 * @author a.mueller

 * @since 14.08.2018

 */

    private static boolean WITHOUT_NAME = true;

    private Person toSecAuthor;

    private List<Language> languages;

    @Before

    public void setUp() throws Exception {

        fromName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());

/**

 * @author a.kohlbecker

 * @since Jun 13, 2016

 */

public class HHH_9751_UtilTest extends Assert {

    @Test

    public void testNullRemoval() {

        list.add("1");

        list.add("2");

        list.add(null);

        assertEquals(3, list.size());

        assertNotNull(list.get(2));

    }

package eu.etaxonomy.cdm.hibernate;

import static org.junit.Assert.assertTrue;

import org.junit.Before;

import org.junit.Test;

public class PartialUserTypeTest {

    private static final Logger logger = Logger.getLogger(PartialUserTypeTest.class);

/**

package eu.etaxonomy.cdm.hibernate;

import java.io.Serializable;

import org.junit.Assert;

import org.junit.Before;

/**

 * @author a.mueller

 */

public class ShiftUsertTypeTest {

	private ShiftUserType shiftUserType;

	@Before

	public void setUp() throws Exception {

		shiftUserType = new ShiftUserType();

	}

	@Test

	public void testDeepCopyObject() {

		//TODO

	}

	@Test

	public void testDisassembleObject() {

		Serializable nullValue = this.shiftUserType.disassemble(null);

		Assert.assertEquals("2,3;3,-1", twoValues);

	}

	@Test

	public void testNullSafeGetString() {

		Shift[] emptyResult = shiftUserType.nullSafeGet("");

		Assert.assertEquals(1, singleResult.length);

	}

	@Test

	public void testNullSafeSet() {

		//TODO

	}

	@Test

	public void testReturnedClass() {

		Class<?> returnedClass = new ShiftUserType().returnedClass();

		Assert.assertEquals(Shift[].class, returnedClass);

	}

	@Test

	public void testSqlTypes() {

		int[] sqlTypes = new ShiftUserType().sqlTypes();

	}

/**

 * @author a.kohlbecker

 * @since Jul 31, 2014

 */

public class CdmTypeScannerTest {

    @Test

        boolean includeAbstract = true;

        boolean includeInterfaces = false;

        scanner.addIncludeFilter(new CdmAssignableTypeFilter(IdentifiableEntity.class, includeAbstract, includeInterfaces));

        assertTrue(classes.contains(TaxonDescription.class));

        assertTrue("abstract base classes are missing", classes.contains(DescriptionBase.class));

    }

*

* 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.cdm.model.agent;

import java.util.GregorianCalendar;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

/**

 * @author a.babadshanjan

 */

public class InstitutionalMembershipTest {

	@Before

	public void onSetUp() throws Exception {

		mship = InstitutionalMembership.NewInstance();

		mship.setPerson(new Person("Steve", "Miller", "Mil."));

		GregorianCalendar joined = new GregorianCalendar(1967, 4, 23);

		GregorianCalendar resigned = new GregorianCalendar(1999, 0, 10);

/**

* Copyright (C) 2007 EDIT

* 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.cdm.model.common;

import static org.junit.Assert.assertEquals;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.junit.Test;

import org.springframework.util.Assert;

/**

 * @author a.mueller

 * @since 08.06.2009

 */

	@Test

	public void testRDF(){

		UUID uuidRdf = UUID.fromString("f3684e25-dcad-4c1e-a5d8-16cddf1c4f5b");

		Assert.notNull(rdfExtension, "RdfExtension must not be null");

		assertEquals("Wrong label for extension type rdf", "RDF",rdfExtension.getRepresentation(Language.ENGLISH()).getAbbreviatedLabel());

	}

	@Test

	public void testDOI(){

		ExtensionType doiExtension = ExtensionType.DOI();

		Assert.notNull(doiExtension, "DoiExtension must not be null");

		assertEquals("Wrong label for extension type rdf", "DOI",doiExtension.getLabel());

	}

* 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.cdm.model.common;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import org.junit.Before;

import org.junit.Test;

import eu.etaxonomy.cdm.model.agent.Person;

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

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

import eu.etaxonomy.cdm.model.taxon.Taxon;

/**

 * @author a.babadshanjan

 * @since 02.02.2009

 */

	private TaxonName abies;

	private TaxonName abiesMill;

	private TaxonName abiesBalsamea;

	private Taxon abiesBalsameaTaxon;

//	private Taxon abiesAlbaxPinusBetaTaxon;

	@Before

	public void setUp() throws Exception {

		abiesAlbaxPinusBeta.setHybridFormula(true);

		abiesAlbaxPinusBeta.addHybridParent(abiesAlba, HybridRelationshipType.FIRST_PARENT(), null);

		abiesAlbaxPinusBeta.addHybridParent(pinusBeta, HybridRelationshipType.SECOND_PARENT(), null);

	}

	@Test

	public void testAddCredit() {

		assertNotNull("A list should always be returned",abies.getCredits());

		assertEquals("Credit0 should be last in list", text3, abies.getCredits(2).getText());

	}

	@Test

	public void testRemoveCredit() {

		assertNotNull("A list should always be returned",abies.getCredits());

	@Test

	public void testClone(){

		assertNotNull(clone);

		assertEquals(clone.annotations, abies.annotations);

		assertEquals(clone.markers, abies.markers);

		assertFalse(clone.uuid.equals(abies.uuid));

	}

/**

package eu.etaxonomy.cdm.model.common;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Test;

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

/**

 * @author a.mueller

 */

	@Test

	public void testToString() {

		Language lang = Language.ENGLISH();

		Assert.assertEquals("English should return 'English' by toString()", "English", lang.toString());

	}

	@Test

	public void testResetTerms() {

		Language lang = Language.ENGLISH();

		new DefaultTermInitializer().initialize();

	}

	@Test

	public void testGetTermByUuid() {

		Language lang = Language.getTermByUuid(Language.uuidZaza_Dimili_Dimli_Kirdki_Kirmanjki_Zazaki);

		Assert.assertEquals("Uuid must be the equal", "e4bf2ec8-4c1a-4ece-9df1-4890a7f18457", lang.getUuid().toString());

	}

	@Test

	public void testENGLISH() {

		Language lang = Language.ENGLISH();

		Assert.assertNotNull("'English' should exist", lang);

	}

	@Test

	public void testUNKNOWN_LANGUAGE() {

		Language unknown = Language.UNKNOWN_LANGUAGE();

		Assert.assertNotNull("'Unknown Language' of undefinedLanguages vocabulary should exist", unknown);

	}

	@Test

	public void testORIGINAL_LANGUAGE() {

		Language original = Language.UNKNOWN_LANGUAGE();

		Assert.assertNotNull("'Original Language' of undefinedLanguages vocabulary should exist", original);

	}

	@Test

	public void testDEFAULT() {

		Language lang = Language.DEFAULT();

		Assert.assertEquals("Uuid of defautl language should be 'e9f8cdb7-6819-44e8-95d3-e2d0690c3523'(english)", Language.uuidEnglish, lang.getUuid());

	}

	@Test

	public void testCSV_LANGUAGE() {

		Language lang = Language.CSV_LANGUAGE();

		Assert.assertNotNull("The csv language must not be null", lang);

		Assert.assertEquals("Uuid of csv language should be 'e9f8cdb7-6819-44e8-95d3-e2d0690c3523'(english)", Language.uuidEnglish, lang.getUuid());

	}

	//once the descriptioin for languages are more explaining texts this test must be adapted

	@Test

	public void testGetLanguageByDescription() {

		Assert.assertNotNull("A language should be found for label 'English'", lang);

		Assert.assertEquals("Uuid of language 'English' should be 'e9f8cdb7-6819-44e8-95d3-e2d0690c3523'", Language.uuidEnglish, lang.getUuid());

	}

	@Test

	public void testGetLanguageByLabel() {

		Assert.assertNotNull("A language should be found for label 'English'", lang);

		Assert.assertEquals("Uuid of language 'English' should be 'e9f8cdb7-6819-44e8-95d3-e2d0690c3523'", Language.uuidEnglish, lang.getUuid());

	}

/**

* Copyright (C) 2007 EDIT

* 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.cdm.model.common;

import static org.junit.Assert.assertEquals;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.junit.Test;

/**

 * @author a.mueller

 * @since 23.04.2008

 */

	@SuppressWarnings("unused")

	private static Logger logger = Logger.getLogger(MarkerTypeTest.class);

	private static final UUID uuidImported = UUID.fromString("96878790-4ceb-42a2-9738-a2242079b679");

	private static final UUID uuidToBeChecked = UUID.fromString("34204192-b41d-4857-a1d4-28992bef2a2a");

	private static final UUID uuidIsDoubtful = UUID.fromString("b51325c8-05fe-421a-832b-d86fc249ef6e");

	private static final UUID uuidComplete = UUID.fromString("b4b1b2ab-89a8-4ce6-8110-d60b8b1bc433");

/* ************ TESTS **********************************/

	@Test

	public void testNewInstanceStringString() {

		String term = "term";

		assertEquals(term, markerType.getRepresentation(Language.DEFAULT()).getText());

	}

	@Test

	public void testIMPORTED() {

		assertNotNull(MarkerType.IMPORTED());

		assertEquals(uuidImported,  MarkerType.IMPORTED().getUuid());

	}

	@Test

	public void testTO_BE_CHECKED() {

		assertEquals(uuidToBeChecked,  MarkerType.TO_BE_CHECKED().getUuid());

	}

	@Test

	public void testIS_DOUBTFUL() {

		assertEquals(uuidIsDoubtful,  MarkerType.IS_DOUBTFUL().getUuid());

	}

	@Test

	public void testCOMPLETE() {

		assertEquals(uuidComplete,  MarkerType.COMPLETE().getUuid());

	}

* 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.cdm.model.description;

import java.util.List;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Test;

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

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

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

/**

 * @author k.luther

 * @since 11.04.2011

 */

/* ************************** TESTS **********************************************************/

	@Test

	public void testGetModifiersVocabulary(){

		TaxonDescription desc = TaxonDescription.NewInstance();

		ethnicGroupVoc.addTerm(scots);

		data.addModifier(scots);

		List<DefinedTerm> modifiers = data.getModifiers(plantPartVoc);

		Assert.assertEquals("There should be 2 modifiers of type 'plant part'", 2, modifiers.size());

		Assert.assertEquals("There should be 3 terms in the 'plant part' vocabulary", 3, plantPartVoc.size());

		Assert.assertEquals("There should be 1 modifiers of type 'ethnic group'", 1, data.getModifiers(ethnicGroupVoc).size());

		Assert.assertEquals("There should be 3 modifiers all together", 3, data.getModifiers().size());

	}

import static org.junit.Assert.assertNotSame;

import org.junit.Before;

import org.junit.Test;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.common.LanguageString;

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

/**

 * @author a.mueller

 * @since 23.04.2018

 */

    private IndividualsAssociation indAssociation;

    @Before

    public void setUp() throws Exception {

        indAssociation = IndividualsAssociation.NewInstance();

        indAssociation.putDescription(langString);

    }

    @Test

    public void testClone() {

        assertEquals(clone.getFeature(), indAssociation.getFeature());

        assertNotSame(clone.getDescription().get(Language.ENGLISH()), indAssociation.getDescription().get(Language.ENGLISH()));

    }

package eu.etaxonomy.cdm.model.description;

import static org.junit.Assert.assertEquals;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import eu.etaxonomy.cdm.model.taxon.Taxon;

	@SuppressWarnings("unused")

	private static Logger logger = Logger.getLogger(PolytomousKeyNodeTest.class);

	private PolytomousKey key1;

	private Taxon taxon1;

	@Before

	public void setUp() throws Exception {

		key1 = PolytomousKey.NewInstance();

		key1.setTitleCache("My Test Key", true);

		PolytomousKeyNode root = key1.getRoot();

		root.setQuestion(KeyStatement.NewInstance("Is this Aus bus?"));

		// child1

		taxon1 = Taxon.NewInstance(null, null);

		taxon1.setTitleCache("Aus bus L.", true);

		PolytomousKeyNode child2 = PolytomousKeyNode.NewInstance("No");

		child2.setTaxon(taxon2);

		root.addChild(child2);

		// child3

		Taxon taxon3 = Taxon.NewInstance(null, null);

		taxon3.setTitleCache("Cus dus subs. rus L.", true);

		PolytomousKeyNode child3 = PolytomousKeyNode.NewInstance("Long and wide");

		child3.setTaxon(taxon3);

		child1.addChild(child3);

		// child4

		Taxon taxon4 = Taxon.NewInstance(null, null);

		taxon4.setTitleCache("Cus dus subs. zus L.", true);

		child3.setSubkey(key2);

		child4.setOtherNode(key2.getRoot());

		PolytomousKeyNode child5 = PolytomousKeyNode.NewInstance("Long and narrow");

		child3.addChild(child5);

	}

	@Test

	public void testNodeNumber() {

		PolytomousKeyNode child3 = child1.getChildAt(0);

		Assert.assertEquals("Child3 should have node number = 3", Integer.valueOf(3),child3.getNodeNumber());

		PolytomousKeyNode child4 = child1.getChildAt(1);

	}

	@Test

	public void testClone(){

		PolytomousKeyNode rootNode = key1.getRoot();

		assertNotNull(clone);

		assertEquals(clone.getFeature(), rootNode.getFeature());

		assertEquals(clone.getKey(), rootNode.getKey());

		assertTrue(clone.getChildren().size() == 0);

		assertTrue(rootNode.getChildren().size()>0);

	}

	@Test

		Assert.assertEquals("Parent node should have no children", 0, parent.getChildren().size());

	}

package eu.etaxonomy.cdm.model.description;

import static org.junit.Assert.assertNotNull;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import eu.etaxonomy.cdm.model.taxon.Taxon;

	private static Logger logger = Logger.getLogger(PolytomousKeyTest.class);

	private PolytomousKey key1;

	private Taxon taxon1;

	@Before

	public void setUp() throws Exception {

		key1 = PolytomousKey.NewInstance();

	@Test

	public void testClone() {

		assertNotNull(clone.getRoot());

		assertNotSame(clone.getRoot(), key1.getRoot());

		assertTrue(clone.getRoot().getChildren().size() == 0);

* 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.cdm.model.description;

import java.util.ArrayList;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Test;

	@Test

	public void testReadCsvLineList() {

		PresenceAbsenceTerm paTermNotExist = PresenceAbsenceTerm.getPresenceAbsenceTermByAbbreviation("slkjlsl�");

		Assert.assertNull(paTermNotExist);

	}

	@Test

    public void testCompareTo(){

        PresenceAbsenceTerm term1 = PresenceAbsenceTerm.CULTIVATED();

        PresenceAbsenceTerm term3 = PresenceAbsenceTerm.ABSENT();

        PresenceAbsenceTerm term4 = PresenceAbsenceTerm.NATIVE_REPORTED_IN_ERROR();

        list.add(term4);

        list.add(term2);

        list.add(term3);

        for (PresenceAbsenceTerm t: list){

            System.out.println(t.getTitleCache());

        }

    }

import java.math.BigDecimal;

import org.junit.Before;

import org.junit.Test;