EDIT

// $Id$

/**

* 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.

*/

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

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

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

import eu.etaxonomy.cdm.model.location.Point;

import eu.etaxonomy.cdm.model.location.ReferenceSystem;

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

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

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

	private TimePeriod datePublished1 = TimePeriod.NewInstance(2000);

	private int hasProblem1 = 1;

	private LSID lsid1;

	private IBook book2;

	private String editionString2 ="Ed.2";

	private String volumeString2 ="Vol.2";

	private TimePeriod datePublished2 = TimePeriod.NewInstance(2002);

	private int hasProblem2 = 1;

	private LSID lsid2;

	private IBook book3;

	/**

	 * @throws java.lang.Exception

	 */

		annotation1 = Annotation.NewInstance("Annotation1", null);

		annotationString2 = "Annotation2";

		annotation2 = Annotation.NewInstance(annotationString2, null);

		book1 = ReferenceFactory.newBook();

		book1.setAuthorship(team1);

		book1.setTitle(title1);

		book1.setParsingProblem(hasProblem1);

		lsid1 = new LSID("authority1", "namespace1", "object1", "revision1");

		book1.setLsid(lsid1);

		book2 = ReferenceFactory.newBook();

		book2.setAuthorship(team2);

		book2.setTitle(title2);

		book2.setParsingProblem(hasProblem2);

		lsid2 = new LSID("authority2", "namespace2", "object2", "revision2");

		book2.setLsid(lsid2);

	}

	/**

	public void tearDown() throws Exception {

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy#NewInstance(java.lang.Class)}.

	 */

	public void testInvokeCache() throws MatchException {

		matchStrategy = DefaultMatchStrategy.NewInstance(Reference.class);

		Assert.assertTrue("Same object should always match", matchStrategy.invoke(book1, book1));

		IBook bookClone = (IBook) book1.clone();

		Assert.assertTrue("Cloned book should match", matchStrategy.invoke(book1, bookClone));

		book1.setTitleCache("cache1",true);

		Assert.assertFalse("Cached book should not match", matchStrategy.invoke(book1, bookClone));

		bookClone.setTitleCache("cache1",true);

		Assert.assertTrue("Cached book with same cache should match", matchStrategy.invoke(book1, bookClone));

		bookClone.setTitleCache("cache2",true);

		Assert.assertFalse("Cached book with differings caches should not match", matchStrategy.invoke(book1, bookClone));

		bookClone.setTitleCache("cache1",true); //restore

		bookClone.setEdition(null);

		Assert.assertTrue("Cached book with a defined and a null edition should match", matchStrategy.invoke(book1, bookClone));

		BotanicalName botName1 = BotanicalName.NewInstance(Rank.GENUS());

		BotanicalName botName2 = BotanicalName.NewInstance(Rank.GENUS());

		Assert.assertNotNull("Rank should not be null", botName1.getRank());

		botName1.setGenusOrUninomial("Genus1");

		botName2.setGenusOrUninomial("Genus1");

		Assert.assertTrue("Names with equal genus should match", matchStrategy.invoke(botName1, botName2));

		botName1.setCombinationAuthorship(team1);

		botName2.setCombinationAuthorship(null);

		Assert.assertFalse("Names one having an author the other one not should not match", matchStrategy.invoke(botName1, botName2));

		botName1.setAuthorshipCache("authorCache1");

		botName2.setAuthorshipCache("authorCache1");

		Assert.assertTrue("Names with cached authors should match", matchStrategy.invoke(botName1, botName2));

	}

	@Test

	public void testInvokeReferences() throws MatchException {

		matchStrategy = DefaultMatchStrategy.NewInstance(Reference.class);

		Assert.assertTrue("Same object should always match", matchStrategy.invoke(book1, book1));

		Assert.assertTrue("Cloned book should match", matchStrategy.invoke(book1, bookClone));

		bookClone.setTitle("Any title");

		Assert.assertFalse("Books with differing titles should not match", matchStrategy.invoke(book1, bookClone));

		Assert.assertFalse("Books with no title should not match", matchStrategy.invoke(book1, bookClone));

		book1.setTitle(originalTitle);

		bookClone.setTitle(originalTitle);

		bookClone.setInSeries(printSeries2);

		Assert.assertFalse("Cloned book with differing print series should not match", matchStrategy.invoke(book1, bookClone));

		bookClone.setInSeries(seriesClone);

		Assert.assertTrue("Cloned book with cloned bookSeries should match", matchStrategy.invoke(book1, bookClone));

		seriesClone.setTitle("Another title");

		Assert.assertFalse("Cloned book should not match with differing series title", matchStrategy.invoke(book1, bookClone));

		bookClone.setInSeries(printSeries1);

		Assert.assertTrue("Original printSeries should match", matchStrategy.invoke(book1, bookClone));

		IBook bookTitle1 = ReferenceFactory.newBook();

		IBook bookTitle2 = ReferenceFactory.newBook();

		Assert.assertFalse("Books without title should not match", matchStrategy.invoke(bookTitle1, bookTitle2));

		bookTitle1.setTitle("");

		bookTitle2.setTitle("");

		Assert.assertFalse("Books with empty title should not match", matchStrategy.invoke(bookTitle1, bookTitle2));

		//Time period

		bookTitle1.setTitle(title);

		bookTitle2.setTitle(title);

		section2.setInBook(bookTitle1);

		section2.setTitle("SecTitle");

		section2.setPages("22-33");

		IMatchStrategy bookSectionMatchStrategy = DefaultMatchStrategy.NewInstance(Reference.class);

		Assert.assertTrue("Equal BookSections should match", bookSectionMatchStrategy.invoke(section1, section2));

		section2.setInBook(bookTitle2);

		bookTitle2.setInSeries(printSeries2);

		Assert.assertFalse("Books with not matching in series should not match", matchStrategy.invoke(bookTitle1, bookTitle2));

		Assert.assertFalse("Sections with differing print series should not match", bookSectionMatchStrategy.invoke(section1, section2));

		//Authorship

		Person person1 = Person.NewTitledInstance("person");

		Person person2 = Person.NewTitledInstance("person");

		person1.setPrefix("pre1");

		person2.setPrefix("pre2");

		Assert.assertTrue("Equal books should match", matchStrategy.invoke(book1, book2));

		book1.setAuthorship(person1);

		book2.setAuthorship(person1);

		Assert.assertTrue("Books with same author should match", matchStrategy.invoke(book1, book2));

		book2.setAuthorship(person2);

		Assert.assertFalse("Books with different authors should not match", matchStrategy.invoke(book1, book2));

		person2.setPrefix("pre1");

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy#invoke(eu.etaxonomy.cdm.strategy.match.IMergable, eu.etaxonomy.cdm.strategy.match.IMergable)}.

	 */

	@Test

	public void testInvokeTaxonNames() throws MatchException {

		matchStrategy = DefaultMatchStrategy.NewInstance(BotanicalName.class);

		BotanicalName botName1 = BotanicalName.NewInstance(Rank.SPECIES());

		BotanicalName botName2 = BotanicalName.NewInstance(Rank.SPECIES());

		BotanicalName botName3 = BotanicalName.NewInstance(Rank.SPECIES());

		Assert.assertFalse("Names without title should not match", matchStrategy.invoke(botName1, botName2));

		botName1.setGenusOrUninomial("Genus1");

		botName1.setSpecificEpithet("species1");

		botName2.setGenusOrUninomial("Genus1");

		botName2.setSpecificEpithet("species1");

		Assert.assertTrue("Similar names with titles set should match", matchStrategy.invoke(botName1, botName2));

		botName1.setAnamorphic(true);

		botName2.setAnamorphic(false);

		Assert.assertFalse("Similar names with differing boolean marker values should not match", matchStrategy.invoke(botName1, botName2));

		botName2.setAnamorphic(true);

		Assert.assertTrue("Similar names with same boolean marker values should match", matchStrategy.invoke(botName1, botName2));

//		//name relations

//		botName2.addBasionym(botName3, book1, "p.22", null);

//		Specimen specimen1 = Specimen.NewInstance();

//		botName2.addSpecimenTypeDesignation(specimen1, SpecimenTypeDesignationStatus.HOLOTYPE(), book2, "p.56", "originalNameString", false, true);

//		//descriptions

//		TaxonNameDescription description1 = TaxonNameDescription.NewInstance();

//		botName1.addDescription(description1);

//		TaxonNameDescription description2 = TaxonNameDescription.NewInstance();

//		botName2.addDescription(description2);

		//authors

		Team team1 = Team.NewInstance();

		Team team2 = Team.NewInstance();

		botName2.setCombinationAuthorship(team2);

		Assert.assertTrue("Similar teams should match", DefaultMatchStrategy.NewInstance(Team.class).invoke(team1, team2));

		Assert.assertTrue("Similar names with matching authors should match", matchStrategy.invoke(botName1, botName2));

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy#invoke(IMatchable, IMatchable), eu.etaxonomy.cdm.strategy.match.IMatchable)}.

	 */

	@Test

	public void testInvokeAgents() throws MatchException {

		IMatchStrategy matchStrategy = DefaultMatchStrategy.NewInstance(Team.class);

		Team team1 = Team.NewInstance();

		Team team2 = Team.NewInstance();

		Team team3 = Team.NewInstance();

		Assert.assertTrue("Teams should match", matchStrategy.invoke(team1, team2));

		Assert.assertTrue("Teams should match", matchStrategy.invoke(team1, team3));

		String street1 = "Strasse1";

		team1.setContact(Contact.NewInstance(street1, "12345", "Berlin", Country.ARGENTINAARGENTINEREPUBLIC(),"pobox" , "Region", "a@b.de", "f12345", "+49-30-123456", URI.create("www.abc.de"), Point.NewInstance(2.4, 3.2, ReferenceSystem.WGS84(), 3)));

		team2.setContact(Contact.NewInstance("Street2", null, "London", null, null, null, null, "874599873", null, null, null));

		Assert.assertTrue("Contacts should be ignoredin default match strategy", matchStrategy.invoke(team1, team2));

		team1.setNomenclaturalTitle("nomTitle1");

		team2.setNomenclaturalTitle("nomTitle2");

		Assert.assertFalse("Agents with differing nomenclatural titles should not match", matchStrategy.invoke(team1, team2));

		//restore

		team2.setNomenclaturalTitle("nomTitle1");

		Assert.assertTrue("Agents with equal nomenclatural titles should match", matchStrategy.invoke(team1, team2));

		Person person1 = Person.NewTitledInstance("person1");

		person1.setProtectedTitleCache(true);

		Person person2 = Person.NewTitledInstance("person2");

		team1.addTeamMember(person1);

		team2.addTeamMember(person1);

		Assert.assertTrue("Teams with same team members should match", matchStrategy.invoke(team1, team2));

		team1.addTeamMember(person2);

		Assert.assertFalse("Teams with differing team members should not match", matchStrategy.invoke(team1, team2));

		team2.addTeamMember(person2);

		team2.removeTeamMember(person1);

		team2.addTeamMember(person1);

		Assert.assertFalse("Teams with matching members in wrong order should not match", matchStrategy.invoke(team1, team2));

	}

	@Test

	public void testInvokeTeamOrPersonBase(){

	}

}