/*******************************************************************************
 * Copyright (c) 2012, 2014 Obeo.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.emf.compare.tests.unit;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import org.eclipse.emf.compare.AttributeChange;
import org.eclipse.emf.compare.CompareFactory;
import org.eclipse.emf.compare.ComparePackage;
import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.compare.Conflict;
import org.eclipse.emf.compare.ConflictKind;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.DifferenceKind;
import org.eclipse.emf.compare.DifferenceSource;
import org.eclipse.emf.compare.DifferenceState;
import org.eclipse.emf.compare.Equivalence;
import org.eclipse.emf.compare.Match;
import org.eclipse.emf.compare.MatchResource;
import org.eclipse.emf.compare.ReferenceChange;
import org.eclipse.emf.compare.ResourceAttachmentChange;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EEnum;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.impl.EClassifierImpl;
import org.junit.Test;

/**
 * Tests the behavior of the {@link CompareFactory generated factory} for package compare.
 * 
 * @generated
 */
@SuppressWarnings("nls")
public class CompareFactoryTest {
	/**
	 * Ensures that creating {@link Comparison} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateComparison() {
		Object result = CompareFactory.eINSTANCE.createComparison();
		assertNotNull(result);
		assertTrue(result instanceof Comparison);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.COMPARISON);
		assertNotNull(result);
		assertTrue(result instanceof Comparison);
	}

	/**
	 * Ensures that creating {@link MatchResource} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateMatchResource() {
		Object result = CompareFactory.eINSTANCE.createMatchResource();
		assertNotNull(result);
		assertTrue(result instanceof MatchResource);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.MATCH_RESOURCE);
		assertNotNull(result);
		assertTrue(result instanceof MatchResource);
	}

	/**
	 * Ensures that creating {@link Match} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateMatch() {
		Object result = CompareFactory.eINSTANCE.createMatch();
		assertNotNull(result);
		assertTrue(result instanceof Match);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.MATCH);
		assertNotNull(result);
		assertTrue(result instanceof Match);
	}

	/**
	 * Ensures that creating {@link Diff} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateDiff() {
		Object result = CompareFactory.eINSTANCE.createDiff();
		assertNotNull(result);
		assertTrue(result instanceof Diff);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.DIFF);
		assertNotNull(result);
		assertTrue(result instanceof Diff);
	}

	/**
	 * Ensures that creating {@link ResourceAttachmentChange} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateResourceAttachmentChange() {
		Object result = CompareFactory.eINSTANCE.createResourceAttachmentChange();
		assertNotNull(result);
		assertTrue(result instanceof ResourceAttachmentChange);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.RESOURCE_ATTACHMENT_CHANGE);
		assertNotNull(result);
		assertTrue(result instanceof ResourceAttachmentChange);
	}

	/**
	 * Ensures that creating {@link ReferenceChange} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateReferenceChange() {
		Object result = CompareFactory.eINSTANCE.createReferenceChange();
		assertNotNull(result);
		assertTrue(result instanceof ReferenceChange);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.REFERENCE_CHANGE);
		assertNotNull(result);
		assertTrue(result instanceof ReferenceChange);
	}

	/**
	 * Ensures that creating {@link AttributeChange} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateAttributeChange() {
		Object result = CompareFactory.eINSTANCE.createAttributeChange();
		assertNotNull(result);
		assertTrue(result instanceof AttributeChange);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.ATTRIBUTE_CHANGE);
		assertNotNull(result);
		assertTrue(result instanceof AttributeChange);
	}

	/**
	 * Ensures that creating {@link Conflict} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateConflict() {
		Object result = CompareFactory.eINSTANCE.createConflict();
		assertNotNull(result);
		assertTrue(result instanceof Conflict);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.CONFLICT);
		assertNotNull(result);
		assertTrue(result instanceof Conflict);
	}

	/**
	 * Ensures that creating {@link Equivalence} can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateEquivalence() {
		Object result = CompareFactory.eINSTANCE.createEquivalence();
		assertNotNull(result);
		assertTrue(result instanceof Equivalence);

		result = CompareFactory.eINSTANCE.create(ComparePackage.Literals.EQUIVALENCE);
		assertNotNull(result);
		assertTrue(result instanceof Equivalence);
	}

	/**
	 * Ensures that trying to create an {@link EClass} from another package yields the expected exception.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateUnknownEClass() {
		try {
			EClass eClass = EcoreFactory.eINSTANCE.createEClass();
			((EClassifierImpl)eClass).setClassifierID(-1);
			CompareFactory.eINSTANCE.create(eClass);
			fail("Expected IllegalArgumentException hasn't been thrown");
		} catch (IllegalArgumentException e) {
			// Expected behavior
		}
	}

	/**
	 * Ensures that converting {@link DifferenceKind} to String can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testConvertDifferenceKindToString() {
		for (DifferenceKind value : DifferenceKind.VALUES) {
			Object result = CompareFactory.eINSTANCE.convertToString(ComparePackage.Literals.DIFFERENCE_KIND,
					value);
			assertNotNull(result);
			assertEquals(value.toString(), result);
		}
	}

	/**
	 * Ensures that converting {@link DifferenceSource} to String can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testConvertDifferenceSourceToString() {
		for (DifferenceSource value : DifferenceSource.VALUES) {
			Object result = CompareFactory.eINSTANCE.convertToString(
					ComparePackage.Literals.DIFFERENCE_SOURCE, value);
			assertNotNull(result);
			assertEquals(value.toString(), result);
		}
	}

	/**
	 * Ensures that converting {@link DifferenceState} to String can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testConvertDifferenceStateToString() {
		for (DifferenceState value : DifferenceState.VALUES) {
			Object result = CompareFactory.eINSTANCE.convertToString(
					ComparePackage.Literals.DIFFERENCE_STATE, value);
			assertNotNull(result);
			assertEquals(value.toString(), result);
		}
	}

	/**
	 * Ensures that converting {@link ConflictKind} to String can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testConvertConflictKindToString() {
		for (ConflictKind value : ConflictKind.VALUES) {
			Object result = CompareFactory.eINSTANCE.convertToString(ComparePackage.Literals.CONFLICT_KIND,
					value);
			assertNotNull(result);
			assertEquals(value.toString(), result);
		}
	}

	/**
	 * Ensures that trying to convert an {@link EEnum} from another package to String yields the expected
	 * exception.
	 * 
	 * @generated
	 */
	@Test
	public void testConvertUnknownEEnumToString() {
		try {
			EEnum eEnum = EcoreFactory.eINSTANCE.createEEnum();
			((EClassifierImpl)eEnum).setClassifierID(-1);
			CompareFactory.eINSTANCE.convertToString(eEnum, eEnum);
			fail("Expected IllegalArgumentException hasn't been thrown");
		} catch (IllegalArgumentException e) {
			// Expected behavior
		}
	}

	/**
	 * Ensures that creating {@link DifferenceKind} from String can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateDifferenceKindFromString() {
		for (DifferenceKind value : DifferenceKind.VALUES) {
			Object result = CompareFactory.eINSTANCE.createFromString(
					ComparePackage.Literals.DIFFERENCE_KIND, value.getLiteral());
			assertNotNull(result);
			assertSame(value, result);

			try {
				CompareFactory.eINSTANCE.createFromString(ComparePackage.Literals.DIFFERENCE_KIND,
						"ThisShouldntBeAKnownEEnumLiteral");
				fail("Expected IllegalArgumentException hasn't been thrown");
			} catch (IllegalArgumentException e) {
				// Expected behavior
			}
		}
	}

	/**
	 * Ensures that creating {@link DifferenceSource} from String can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateDifferenceSourceFromString() {
		for (DifferenceSource value : DifferenceSource.VALUES) {
			Object result = CompareFactory.eINSTANCE.createFromString(
					ComparePackage.Literals.DIFFERENCE_SOURCE, value.getLiteral());
			assertNotNull(result);
			assertSame(value, result);

			try {
				CompareFactory.eINSTANCE.createFromString(ComparePackage.Literals.DIFFERENCE_SOURCE,
						"ThisShouldntBeAKnownEEnumLiteral");
				fail("Expected IllegalArgumentException hasn't been thrown");
			} catch (IllegalArgumentException e) {
				// Expected behavior
			}
		}
	}

	/**
	 * Ensures that creating {@link DifferenceState} from String can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateDifferenceStateFromString() {
		for (DifferenceState value : DifferenceState.VALUES) {
			Object result = CompareFactory.eINSTANCE.createFromString(
					ComparePackage.Literals.DIFFERENCE_STATE, value.getLiteral());
			assertNotNull(result);
			assertSame(value, result);

			try {
				CompareFactory.eINSTANCE.createFromString(ComparePackage.Literals.DIFFERENCE_STATE,
						"ThisShouldntBeAKnownEEnumLiteral");
				fail("Expected IllegalArgumentException hasn't been thrown");
			} catch (IllegalArgumentException e) {
				// Expected behavior
			}
		}
	}

	/**
	 * Ensures that creating {@link ConflictKind} from String can be done through the factory.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateConflictKindFromString() {
		for (ConflictKind value : ConflictKind.VALUES) {
			Object result = CompareFactory.eINSTANCE.createFromString(ComparePackage.Literals.CONFLICT_KIND,
					value.getLiteral());
			assertNotNull(result);
			assertSame(value, result);

			try {
				CompareFactory.eINSTANCE.createFromString(ComparePackage.Literals.CONFLICT_KIND,
						"ThisShouldntBeAKnownEEnumLiteral");
				fail("Expected IllegalArgumentException hasn't been thrown");
			} catch (IllegalArgumentException e) {
				// Expected behavior
			}
		}
	}

	/**
	 * Ensures that trying to create an {@link EEnum} from another package from String yields the expected
	 * exception.
	 * 
	 * @generated
	 */
	@Test
	public void testCreateUnknownEEnumFromString() {
		try {
			EEnum eEnum = EcoreFactory.eINSTANCE.createEEnum();
			((EClassifierImpl)eEnum).setClassifierID(-1);
			CompareFactory.eINSTANCE.createFromString(eEnum, "ThisShouldntBeAKnownEEnumLiteral");
			fail("Expected IllegalArgumentException hasn't been thrown");
		} catch (IllegalArgumentException e) {
			// Expected behavior
		}
	}
}