EDIT

/**

* Copyright (C) 2007 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.operations;

import java.util.Set;

import junit.framework.Assert;

import org.apache.log4j.Logger;

import org.eclipse.core.commands.ExecutionException;

import org.junit.BeforeClass;

import org.junit.Test;

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

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

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

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

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

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

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

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

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

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

/**

 * @author n.hoffmann

 * @created 02.04.2009

 * @version 1.0

 */

public class SwapSynonymAndAcceptedOperationTest extends AbstractTaxeditorOperationTest {

	private static final Logger logger = Logger

			.getLogger(SwapSynonymAndAcceptedOperationTest.class);

	private static AbstractPostOperation operation;

	private static Taxon oldTaxon;

	private static Taxon parentTaxon;

	private static Synonym homotypicSynonym;

	private static Synonym oldHeterotypicSynonym;

	private static HomotypicalGroup heteroypicalGroup;

	private static Taxon misapplication;

	private static Taxon concept;

	private static TaxonRelationshipType conceptRelationshipType;

	private static Taxon childTaxon;

	private static TaxonDescription description;

	private static NonViralName oldSynonymName;

	private static NonViralName oldTaxonName;

	/**

	 * @throws java.lang.Exception

	 */

	@BeforeClass

	public static void setUpBeforeClass() throws Exception {

		(new DefaultTermInitializer()).initialize();

		// Create the original accepted taxon

		oldTaxonName = NonViralName.NewInstance(null);

		oldTaxon = Taxon.NewInstance(oldTaxonName, null);

		// Create its parent taxon

		parentTaxon = Taxon.NewInstance(NonViralName.NewInstance(null), null);

		parentTaxon.addTaxonomicChild(oldTaxon, null, null);

		// Give it a child taxon

		childTaxon = Taxon.NewInstance(NonViralName.NewInstance(null), null);

		childTaxon.setTaxonomicParent(oldTaxon, null, null);

		// Create a homotypic synonym for the accepted taxon

		oldTaxon.addHomotypicSynonymName(NonViralName.NewInstance(null), null, null);

//		homotypicSynonym = Synonym.NewInstance(NonViralName.NewInstance(null), null);

//		HomotypicalGroup acceptedHomotypicalGroup = HomotypicalGroup.NewInstance();

//		acceptedHomotypicalGroup.addTypifiedName(oldTaxon.getName());

//		acceptedHomotypicalGroup.addTypifiedName(homotypicSynonym.getName());

		// Create a heterotypic synonym that will be used to create the new accepted taxon

		oldSynonymName = NonViralName.NewInstance(null);

		oldHeterotypicSynonym = Synonym.NewInstance(oldSynonymName, null);

//		oldTaxon.addS .addHeterotypicSynonym(oldHeterotypicSynonym, null, null);

		heteroypicalGroup = HomotypicalGroup.NewInstance();

		heteroypicalGroup.addTypifiedName(oldHeterotypicSynonym.getName());

		oldTaxon.addSynonym(oldHeterotypicSynonym, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());

		// Create a misapplication

		misapplication = Taxon.NewInstance(NonViralName.NewInstance(null), null);

		oldTaxon.addMisappliedName(misapplication, null, null);	

		// Create a concept relation

		concept = Taxon.NewInstance(NonViralName.NewInstance(null), null);

		conceptRelationshipType = new TaxonRelationshipType();

		concept.addTaxonRelation(oldTaxon, conceptRelationshipType, null, null);	

		// Create a description

		description = TaxonDescription.NewInstance();

		oldTaxon.addDescription(description);

		operation = new SwapSynonymAndAcceptedOperation

				(null, undoContext, oldTaxon, oldHeterotypicSynonym, postOperation);

	}

	private Taxon newTaxon;

	/**

	 * Test method for {@link eu.etaxonomy.taxeditor.store.operations.ChangeHomotypicGroupOperation#execute(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)}.

	 * @throws ExecutionException 

	 */

	@Test

	public void testExecute() throws ExecutionException {

		operation.execute(null, null);

		newTaxon = ((SwapSynonymAndAcceptedOperation) operation).getNewTaxon();

		// New taxon has correct name?		

		Assert.assertEquals(newTaxon.getName(), oldSynonymName);

		// New taxon has correct parent?

		Assert.assertEquals(newTaxon.getTaxonomicParent(), parentTaxon);

		// New taxon has correct child?

		Assert.assertTrue(newTaxon.getTaxonomicChildren().contains(childTaxon));

		// New taxon has 2 synonyms?

		Assert.assertEquals(newTaxon.getSynonyms().size(), 2);

		// New taxon has a synonym with the name of the previous accepted taxon?

		Assert.assertTrue(newTaxon.getSynonymNames().contains(oldTaxonName));

		// New taxon has misapplication?

		Assert.assertTrue(newTaxon.getMisappliedNames().contains(misapplication));

		// New taxon has 1 concept relation?

		int conceptRelCount = 0;

		for (TaxonRelationship relation : newTaxon.getTaxonRelations()) {

			if (relation.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) ||

					relation.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())) {

				continue;

			}

			conceptRelCount++;

		}

		Assert.assertEquals(conceptRelCount, 1);

		// New taxon has description?

		newTaxon.getDescriptions().contains(description);

	}

	/**

	 * Test method for {@link eu.etaxonomy.taxeditor.store.operations.ChangeHomotypicGroupOperation#undo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)}.

	 * @throws ExecutionException 

	 */

	@Test

	public void testUndo() throws ExecutionException {

		operation.undo(null, null);

//		Assert.assertEquals(oldHomotypicalGroup, synonym.getHomotypicGroup());

	}

	/**

	 * Test method for {@link eu.etaxonomy.taxeditor.store.operations.ChangeHomotypicGroupOperation#redo(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.core.runtime.IAdaptable)}.

	 * @throws ExecutionException 

	 */

	@Test

	public void testRedo() throws ExecutionException {

		operation.redo(null, null);

//		Assert.assertEquals(newHomotypicalGroup, synonym.getHomotypicGroup());

	}

	/**

	 * Test method for {@link eu.etaxonomy.taxeditor.store.operations.AbstractPostOperation#postExecute(CdmBase)}.

	 */

	@Test

	public void testPostExecute() {

		// TODO there is not post operation functionality for this class

		// at the moment. Implement test when there is.

		logger.warn("No post operation functionality for this class");

	}

}