/***********************************************************************
 * Copyright (c) 2008 by SAP AG, Walldorf. 
 * 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:
 *     SAP AG - initial API and implementation
 ***********************************************************************/
package org.eclipse.jst.jee.model.mergers.tests;

import java.util.List;

import junit.framework.Assert;
import junit.framework.TestCase;

import org.eclipse.jst.javaee.core.JavaeeFactory;
import org.eclipse.jst.javaee.core.RunAs;
import org.eclipse.jst.javaee.core.SecurityRole;
import org.eclipse.jst.javaee.core.UrlPatternType;
import org.eclipse.jst.javaee.web.AuthConstraint;
import org.eclipse.jst.javaee.web.Filter;
import org.eclipse.jst.javaee.web.FilterMapping;
import org.eclipse.jst.javaee.web.SecurityConstraint;
import org.eclipse.jst.javaee.web.Servlet;
import org.eclipse.jst.javaee.web.ServletMapping;
import org.eclipse.jst.javaee.web.TransportGuaranteeType;
import org.eclipse.jst.javaee.web.UserDataConstraint;
import org.eclipse.jst.javaee.web.WebApp;
import org.eclipse.jst.javaee.web.WebFactory;
import org.eclipse.jst.jee.model.internal.mergers.ModelElementMerger;
import org.eclipse.jst.jee.model.internal.mergers.ModelException;
import org.eclipse.jst.jee.model.internal.mergers.WebAppMerger;

/**
 * Tester class for WebAPp artifact.
 * 
 * Base suffix means that the base object has some info and 
 * toMerge is empty: nothing should be merged
 * 
 * ToMerge suffix means that the base is empty object and 
 * toMerge has some info: all from merge should be present in base.
 * 
 * Same suffix means that the information in merge and base is one 
 * and the same: no merge should occurred and additional checks for 
 * doubling of the elements are present.
 * 
 * Complex suffix means variety of information is present in base 
 * and to merge: consistent information combined by base and toMerge
 * should be available at the end.
 * 
 * ComplexOverlapped suffix means variety of information is present 
 * in base and to merge: consistent information combined by base and toMerge
 * should be available at the end. There are artifacts with one and the same 
 * name and different values: values should be merged into base.
 *  
 * 
 * @author Dimitar Giormov
 *
 */
public class WebAppMergerTest extends TestCase{

	/**
	 * Tests the merger with Base security role only.
	 * No merge is necessary
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleSecurityRoleCaseBase() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		SecurityRole role = JavaeeFactory.eINSTANCE.createSecurityRole();
		role.setRoleName("test1");

		descriptorBase.getSecurityRoles().add(role);
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertNotNull(descriptorBase.getSecurityRoles());
		Assert.assertTrue(descriptorBase.getSecurityRoles().size() == 1);
		Assert.assertTrue(descriptorToMerge.getSecurityRoles().size() == 0);
		Assert.assertTrue(((SecurityRole)descriptorBase.getSecurityRoles().get(0)).getRoleName().equals("test1"));
	}

	/**
	 * Tests the merger with toMerge security role only.
	 * The role should be copied in base.
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleSecurityRoleCaseToMerge() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		SecurityRole role = JavaeeFactory.eINSTANCE.createSecurityRole();
		role.setRoleName("test1");

		descriptorToMerge.getSecurityRoles().add(role);

		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertNotNull(descriptorBase.getSecurityRoles());
		Assert.assertEquals(1, descriptorBase.getSecurityRoles().size());
		Assert.assertEquals(1, descriptorToMerge.getSecurityRoles().size());
		Assert.assertTrue(((SecurityRole)descriptorBase.getSecurityRoles().get(0)).getRoleName().equals("test1"));
	}

	/**
	 * Tests the merger with one and the same security role.
	 * The result should be non merged 1 security role.
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleSecurityRoleCaseSameRole() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		SecurityRole role = JavaeeFactory.eINSTANCE.createSecurityRole();
		role.setRoleName("test1");
		descriptorBase.getSecurityRoles().add(role);
		descriptorToMerge.getSecurityRoles().add(role);

		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertNotNull(descriptorBase.getSecurityRoles());
		Assert.assertTrue(descriptorBase.getSecurityRoles().size() == 1);
		Assert.assertTrue(descriptorToMerge.getSecurityRoles().size() == 1);
		Assert.assertTrue(((SecurityRole)descriptorBase.getSecurityRoles().get(0)).getRoleName().equals("test1"));
	}

	/**
	 * Tests the merger with variety of security roles.
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleSecurityRoleCaseComplex() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		SecurityRole role0 = JavaeeFactory.eINSTANCE.createSecurityRole();
		SecurityRole role1 = JavaeeFactory.eINSTANCE.createSecurityRole();
		SecurityRole role2 = JavaeeFactory.eINSTANCE.createSecurityRole();
		SecurityRole role3 = JavaeeFactory.eINSTANCE.createSecurityRole();
		SecurityRole role4 = JavaeeFactory.eINSTANCE.createSecurityRole();
		SecurityRole role5 = JavaeeFactory.eINSTANCE.createSecurityRole();
		role0.setRoleName("test1");
		role1.setRoleName("test2");
		role2.setRoleName("test3");
		role3.setRoleName("test4");
		role4.setRoleName("test5");
		role5.setRoleName("test6");


		descriptorBase.getSecurityRoles().add(role1);
		descriptorBase.getSecurityRoles().add(role3);
		descriptorBase.getSecurityRoles().add(role4);
		descriptorBase.getSecurityRoles().add(role5);


		descriptorToMerge.getSecurityRoles().add(role0);
		descriptorToMerge.getSecurityRoles().add(role1);
		descriptorToMerge.getSecurityRoles().add(role2);


		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertNotNull(descriptorBase.getSecurityRoles());
		Assert.assertTrue(descriptorBase.getSecurityRoles().size() == 6);
		Assert.assertTrue(descriptorToMerge.getSecurityRoles().size() == 3);
		Assert.assertTrue(containsSecRole(descriptorBase.getSecurityRoles(), role0.getRoleName()));
		Assert.assertTrue(containsSecRole(descriptorBase.getSecurityRoles(), role1.getRoleName()));
		Assert.assertTrue(containsSecRole(descriptorBase.getSecurityRoles(), role2.getRoleName()));
		Assert.assertTrue(containsSecRole(descriptorBase.getSecurityRoles(), role3.getRoleName()));
		Assert.assertTrue(containsSecRole(descriptorBase.getSecurityRoles(), role4.getRoleName()));
		Assert.assertTrue(containsSecRole(descriptorBase.getSecurityRoles(), role5.getRoleName()));
	}

	private boolean containsSecRole(List list, String roleName) {


		for (Object object : list) {
			SecurityRole role = (SecurityRole) object;
			if(roleName == null){
				if(roleName == role.getRoleName()){
					return true;
				}
			} else if(roleName.equals(role.getRoleName())){
				return true;
			}
		}
		return false;
	}


	/**
	 * Tests the merger with Base security role only.
	 * No merge is necessary
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleRunAsCaseBase() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		RunAs role = JavaeeFactory.eINSTANCE.createRunAs();
		Servlet servletBase = WebFactory.eINSTANCE.createServlet();
		servletBase.setServletName("servName");
		Servlet servletMerge = WebFactory.eINSTANCE.createServlet();
		servletMerge.setServletName("servName");
		role.setRoleName("test1");
		servletBase.setRunAs(role);

		descriptorBase.getServlets().add(servletBase);
		descriptorToMerge.getServlets().add(servletMerge);


		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertNotNull(servletBase.getRunAs());
		Assert.assertTrue(((RunAs)servletBase.getRunAs()).getRoleName().equals("test1"));
	}

	/**
	 * Tests the merger with toMerge security role only.
	 * The role should be copied in base.
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleRunAsCaseToMerge() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		RunAs role = JavaeeFactory.eINSTANCE.createRunAs();
		Servlet servletBase = WebFactory.eINSTANCE.createServlet();
		servletBase.setServletName("servName");
		Servlet servletMerge = WebFactory.eINSTANCE.createServlet();
		servletMerge.setServletName("servName");
		role.setRoleName("test1");
		servletMerge.setRunAs(role);

		descriptorBase.getServlets().add(servletBase);
		descriptorToMerge.getServlets().add(servletMerge);


		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertNotNull(servletBase.getRunAs());
		Assert.assertTrue(((RunAs)servletBase.getRunAs()).getRoleName().equals("test1"));
		Assert.assertEquals(1, descriptorBase.getServlets().size());
	}


	/**
	 * Tests the merger with null named servlet in toMerge array, the merger should ignore such entries.
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleNullServletToMerge() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		Servlet servletBase = WebFactory.eINSTANCE.createServlet();

		descriptorToMerge.getServlets().add(servletBase);


		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertEquals(0, descriptorBase.getServlets().size());
	}

	/**
	 * Tests the merger with null named servlet in Base, as this is extremely unlikely
	 * the merger should not stop merging because of such error.
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleNullNamedServletInBase() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		Servlet servletBase = WebFactory.eINSTANCE.createServlet();
		Servlet servletMerge = WebFactory.eINSTANCE.createServlet();
		servletMerge.setServletName("servName");

		descriptorBase.getServlets().add(servletBase);
		descriptorToMerge.getServlets().add(servletMerge);


		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertEquals(2, descriptorBase.getServlets().size());
	}

	/**
	 * Tests the merger with one and the same security role.
	 * The result should be non merged 1 security role.
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleRunAsCaseSameRole() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		RunAs role = JavaeeFactory.eINSTANCE.createRunAs();
		Servlet servletBase = WebFactory.eINSTANCE.createServlet();
		servletBase.setServletName("servName");
		Servlet servletMerge = WebFactory.eINSTANCE.createServlet();
		servletMerge.setServletName("servName");
		role.setRoleName("test1");
		servletBase.setRunAs(role);
		servletMerge.setRunAs(role);

		descriptorBase.getServlets().add(servletBase);
		descriptorToMerge.getServlets().add(servletMerge);


		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertNotNull(servletBase.getRunAs());
		Assert.assertTrue(((RunAs)servletBase.getRunAs()).getRoleName().equals("test1"));
	}


	/**
	 * Tests the merger with Base security constraints only.
	 * No merge is necessary
	 * 
	 * @throws ModelException
	 */
//	@Test
	@SuppressWarnings("unchecked")
	public void testSingleSecurityConstraintCaseBase() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		SecurityConstraint sc = WebFactory.eINSTANCE.createSecurityConstraint();
		AuthConstraint createAuthConstraint = WebFactory.eINSTANCE.createAuthConstraint();
		createAuthConstraint.getRoleNames().add("test");
		sc.setAuthConstraint(createAuthConstraint);
		UserDataConstraint userDataConstraint = WebFactory.eINSTANCE.createUserDataConstraint();
		userDataConstraint.setTransportGuarantee(TransportGuaranteeType.CONFIDENTIAL_LITERAL);
		sc.setUserDataConstraint(userDataConstraint);

		descriptorBase.getSecurityConstraints().add(sc);
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, 0);
		result.process();
		Assert.assertNotNull(descriptorBase.getSecurityConstraints());
		Assert.assertTrue(descriptorBase.getSecurityConstraints().size() == 1);
		Assert.assertTrue(descriptorToMerge.getSecurityConstraints().size() == 0);
		Assert.assertTrue(((SecurityConstraint)descriptorBase.getSecurityConstraints().get(0)).getAuthConstraint().getRoleNames().get(0).equals("test"));
	}

	/**
	 * Tests the merger with toMerge security constraints only.
	 * The role should be copied in base.
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testSingleSecurityConstraintCaseToMerge() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		SecurityConstraint sc = WebFactory.eINSTANCE.createSecurityConstraint();
		AuthConstraint createAuthConstraint = WebFactory.eINSTANCE.createAuthConstraint();
		createAuthConstraint.getRoleNames().add("test");
		sc.setAuthConstraint(createAuthConstraint);
		UserDataConstraint userDataConstraint = WebFactory.eINSTANCE.createUserDataConstraint();
		userDataConstraint.setTransportGuarantee(TransportGuaranteeType.CONFIDENTIAL_LITERAL);
		sc.setUserDataConstraint(userDataConstraint);

		descriptorBase.getSecurityConstraints().add(sc);
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();
		WebAppMerger result = new WebAppMerger(descriptorToMerge, descriptorBase, 0);
		result.process();
		Assert.assertNotNull(descriptorToMerge.getSecurityConstraints());
		Assert.assertTrue(descriptorToMerge.getSecurityConstraints().size() == 1);
		Assert.assertTrue(((SecurityConstraint)descriptorToMerge.getSecurityConstraints().get(0)).getAuthConstraint().getRoleNames().get(0).equals("test"));
	}

	/**
	 * Tests the merger "add" behavior with filter mappings with
	 * different url-patterns
	 * No merge is necessary
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testFilterMappingsCaseSameAdd() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();

		Filter filter = WebFactory.eINSTANCE.createFilter();
		filter.setFilterName("TestFilter");
		filter.setFilterClass("test.TestFilter");
		List<Filter> filters = descriptorBase.getFilters();
		filters.add(filter);

		UrlPatternType urlPattern = JavaeeFactory.eINSTANCE.createUrlPatternType();
		urlPattern.setValue("/pattern1/*");
		FilterMapping filterMapping = WebFactory.eINSTANCE.createFilterMapping();
		filterMapping.setFilterName("TestFilter");
		List<UrlPatternType> urlPatterns = filterMapping.getUrlPatterns();
		urlPatterns.add(urlPattern);
		List<FilterMapping> filterMappings = descriptorBase.getFilterMappings();
		filterMappings.add(filterMapping);

		Filter filter2 = WebFactory.eINSTANCE.createFilter();
		filter2.setFilterName("TestFilter");
		filter2.setFilterClass("test.TestFilter2");
		List<Filter> filters2 = descriptorToMerge.getFilters();
		filters2.add(filter2);

		UrlPatternType urlPattern2 = JavaeeFactory.eINSTANCE.createUrlPatternType();
		urlPattern2.setValue("/pattern2/*");
		FilterMapping filterMapping2 = WebFactory.eINSTANCE.createFilterMapping();
		filterMapping2.setFilterName("TestFilter");
		List<UrlPatternType> urlPatterns2 = filterMapping2.getUrlPatterns();
		urlPatterns2.add(urlPattern2);
		List<FilterMapping> filterMappings2 = descriptorToMerge.getFilterMappings();
		filterMappings2.add(filterMapping2);

		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, ModelElementMerger.ADD);
		result.process();
		Assert.assertNotNull(descriptorBase.getFilters());
		Assert.assertEquals(1, descriptorBase.getFilters().size());
		Assert.assertEquals(1, descriptorToMerge.getFilters().size());
		Assert.assertEquals(1, descriptorToMerge.getFilterMappings().size());
		Filter f = descriptorBase.getFilters().get(0);
		Assert.assertNotNull(f);
		Assert.assertTrue(f.getFilterName().equals("TestFilter"));
		Assert.assertNotNull(descriptorBase.getFilterMappings());
		Assert.assertEquals(1, descriptorBase.getFilterMappings().size());
		FilterMapping m = descriptorBase.getFilterMappings().get(0);
		Assert.assertTrue(m.getFilterName().equals("TestFilter"));
		Assert.assertNotNull(m.getUrlPatterns());
		Assert.assertEquals(1, m.getUrlPatterns().size());
		Assert.assertTrue(m.getUrlPatterns().get(0).getValue().equals("/pattern1/*"));
	}

	/**
	 * Tests the merger "copy" behavior with filter mappings with
	 * different url-patterns
	 * The filter mapping should be copied to base
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testFilterMappingsCaseSameCopy() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();

		Filter filter = WebFactory.eINSTANCE.createFilter();
		filter.setFilterName("TestFilter");
		filter.setFilterClass("test.TestFilter");
		List<Filter> filters = descriptorBase.getFilters();
		filters.add(filter);

		UrlPatternType urlPattern = JavaeeFactory.eINSTANCE.createUrlPatternType();
		urlPattern.setValue("/pattern1/*");
		FilterMapping filterMapping = WebFactory.eINSTANCE.createFilterMapping();
		filterMapping.setFilterName("TestFilter");
		List<UrlPatternType> urlPatterns = filterMapping.getUrlPatterns();
		urlPatterns.add(urlPattern);
		List<FilterMapping> filterMappings = descriptorBase.getFilterMappings();
		filterMappings.add(filterMapping);

		Filter filter2 = WebFactory.eINSTANCE.createFilter();
		filter2.setFilterName("TestFilter");
		filter2.setFilterClass("test.TestFilter2");
		List<Filter> filters2 = descriptorToMerge.getFilters();
		filters2.add(filter2);

		UrlPatternType urlPattern2 = JavaeeFactory.eINSTANCE.createUrlPatternType();
		urlPattern2.setValue("/pattern2/*");
		FilterMapping filterMapping2 = WebFactory.eINSTANCE.createFilterMapping();
		filterMapping2.setFilterName("TestFilter");
		List<UrlPatternType> urlPatterns2 = filterMapping2.getUrlPatterns();
		urlPatterns2.add(urlPattern2);
		List<FilterMapping> filterMappings2 = descriptorToMerge.getFilterMappings();
		filterMappings2.add(filterMapping2);

		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, ModelElementMerger.COPY);
		result.process();
		Assert.assertNotNull(descriptorBase.getFilters());
		Assert.assertEquals(1, descriptorBase.getFilters().size());
		Assert.assertEquals(1, descriptorToMerge.getFilters().size());
		Assert.assertEquals(1, descriptorToMerge.getFilterMappings().size());
		Filter f = descriptorBase.getFilters().get(0);
		Assert.assertNotNull(f);
		Assert.assertTrue(f.getFilterName().equals("TestFilter"));
		Assert.assertNotNull(descriptorBase.getFilterMappings());
		Assert.assertEquals(2, descriptorBase.getFilterMappings().size());
		FilterMapping m = descriptorBase.getFilterMappings().get(0);
		Assert.assertTrue(m.getFilterName().equals("TestFilter"));
		Assert.assertNotNull(m.getUrlPatterns());
		Assert.assertEquals(1, m.getUrlPatterns().size());
		Assert.assertTrue(m.getUrlPatterns().get(0).getValue().equals("/pattern1/*"));
		m = descriptorBase.getFilterMappings().get(1);
		Assert.assertTrue(m.getFilterName().equals("TestFilter"));
		Assert.assertNotNull(m.getUrlPatterns());
		Assert.assertEquals(1, m.getUrlPatterns().size());
		Assert.assertTrue(m.getUrlPatterns().get(0).getValue().equals("/pattern2/*"));
	}

	/**
	 * Tests the merger "add" behavior with servlet mappings with
	 * different url-patterns
	 * No merge is necessary
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testServletMappingsCaseSame() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();

		Servlet servlet = WebFactory.eINSTANCE.createServlet();
		servlet.setServletName("TestServlet");
		servlet.setServletClass("test.TestServlet");
		List<Servlet> servlets = descriptorBase.getServlets();
		servlets.add(servlet);

		UrlPatternType urlPattern = JavaeeFactory.eINSTANCE.createUrlPatternType();
		urlPattern.setValue("/pattern1");
		ServletMapping servletMapping = WebFactory.eINSTANCE.createServletMapping();
		servletMapping.setServletName("TestServlet");
		List<UrlPatternType> urlPatterns = servletMapping.getUrlPatterns();
		urlPatterns.add(urlPattern);
		List<ServletMapping> servletMappings = descriptorBase.getServletMappings();
		servletMappings.add(servletMapping);

		Servlet servlet2 = WebFactory.eINSTANCE.createServlet();
		servlet2.setServletName("TestServlet");
		servlet2.setServletClass("test.TestServlet2");
		List<Servlet> servlets2 = descriptorToMerge.getServlets();
		servlets2.add(servlet2);

		UrlPatternType urlPattern2 = JavaeeFactory.eINSTANCE.createUrlPatternType();
		urlPattern2.setValue("/pattern2");
		ServletMapping servletMapping2 = WebFactory.eINSTANCE.createServletMapping();
		servletMapping2.setServletName("TestServlet");
		List<UrlPatternType> urlPatterns2 = servletMapping2.getUrlPatterns();
		urlPatterns2.add(urlPattern2);
		List<ServletMapping> servletMappings2 = descriptorToMerge.getServletMappings();
		servletMappings2.add(servletMapping2);

		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, ModelElementMerger.ADD);
		result.process();
		Assert.assertNotNull(descriptorBase.getServlets());
		Assert.assertEquals(1, descriptorBase.getServlets().size());
		Assert.assertEquals(1, descriptorToMerge.getServlets().size());
		Assert.assertEquals(1, descriptorToMerge.getServletMappings().size());
		Servlet s = descriptorBase.getServlets().get(0);
		Assert.assertNotNull(s);
		Assert.assertTrue(s.getServletName().equals("TestServlet"));
		Assert.assertNotNull(descriptorBase.getServletMappings());
		Assert.assertEquals(1, descriptorBase.getServletMappings().size());
		ServletMapping m = descriptorBase.getServletMappings().get(0);
		Assert.assertTrue(m.getServletName().equals("TestServlet"));
		Assert.assertNotNull(m.getUrlPatterns());
		Assert.assertEquals(1, m.getUrlPatterns().size());
		Assert.assertTrue(m.getUrlPatterns().get(0).getValue().equals("/pattern1"));
	}

	/**
	 * Tests the merger "copy" behavior with servlet mappings with
	 * different url-patterns
	 * The servlet mapping should be copied to base
	 * 
	 * @throws ModelException
	 */
	//@Test
	public void testServletMappingsCaseSameCopy() throws ModelException{
		WebApp descriptorBase = WebFactory.eINSTANCE.createWebApp();
		WebApp descriptorToMerge = WebFactory.eINSTANCE.createWebApp();

		Servlet servlet = WebFactory.eINSTANCE.createServlet();
		servlet.setServletName("TestServlet");
		servlet.setServletClass("test.TestServlet");
		List<Servlet> servlets = descriptorBase.getServlets();
		servlets.add(servlet);

		UrlPatternType urlPattern = JavaeeFactory.eINSTANCE.createUrlPatternType();
		urlPattern.setValue("/pattern1");
		ServletMapping servletMapping = WebFactory.eINSTANCE.createServletMapping();
		servletMapping.setServletName("TestServlet");
		List<UrlPatternType> urlPatterns = servletMapping.getUrlPatterns();
		urlPatterns.add(urlPattern);
		List<ServletMapping> servletMappings = descriptorBase.getServletMappings();
		servletMappings.add(servletMapping);

		Servlet servlet2 = WebFactory.eINSTANCE.createServlet();
		servlet2.setServletName("TestServlet");
		servlet2.setServletClass("test.TestServlet2");
		List<Servlet> servlets2 = descriptorToMerge.getServlets();
		servlets2.add(servlet2);

		UrlPatternType urlPattern2 = JavaeeFactory.eINSTANCE.createUrlPatternType();
		urlPattern2.setValue("/pattern2");
		ServletMapping servletMapping2 = WebFactory.eINSTANCE.createServletMapping();
		servletMapping2.setServletName("TestServlet");
		List<UrlPatternType> urlPatterns2 = servletMapping2.getUrlPatterns();
		urlPatterns2.add(urlPattern2);
		List<ServletMapping> servletMappings2 = descriptorToMerge.getServletMappings();
		servletMappings2.add(servletMapping2);

		WebAppMerger result = new WebAppMerger(descriptorBase, descriptorToMerge, ModelElementMerger.COPY);
		result.process();
		Assert.assertNotNull(descriptorBase.getServlets());
		Assert.assertEquals(1, descriptorBase.getServlets().size());
		Assert.assertEquals(1, descriptorToMerge.getServlets().size());
		Assert.assertEquals(1, descriptorToMerge.getServletMappings().size());
		Servlet s = descriptorBase.getServlets().get(0);
		Assert.assertNotNull(s);
		Assert.assertTrue(s.getServletName().equals("TestServlet"));
		Assert.assertNotNull(descriptorBase.getServletMappings());
		Assert.assertEquals(2, descriptorBase.getServletMappings().size());
		ServletMapping m = descriptorBase.getServletMappings().get(0);
		Assert.assertTrue(m.getServletName().equals("TestServlet"));
		Assert.assertNotNull(m.getUrlPatterns());
		Assert.assertEquals(1, m.getUrlPatterns().size());
		Assert.assertTrue(m.getUrlPatterns().get(0).getValue().equals("/pattern1"));
		m = descriptorBase.getServletMappings().get(1);
		Assert.assertTrue(m.getServletName().equals("TestServlet"));
		Assert.assertNotNull(m.getUrlPatterns());
		Assert.assertEquals(1, m.getUrlPatterns().size());
		Assert.assertTrue(m.getUrlPatterns().get(0).getValue().equals("/pattern2"));
	}

}