/*******************************************************************************
 * Copyright (c) 2012 Ericsson Research Canada
 * 
 * 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
 * 
 * Description:
 * 
 * This class implements JUnit Test Cases for postponed anomalies 
 * 
 * Contributors:
 *   Sebastien Dubois - Created for Mylyn Review R4E project
 *   Francois Chouinard - Add identifying message to each assert
 ******************************************************************************/

package org.eclipse.mylyn.reviews.r4e.ui.tests.feature;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.mylyn.reviews.r4e.core.model.R4ECommentType;
import org.eclipse.mylyn.reviews.r4e.core.model.R4EParticipant;
import org.eclipse.mylyn.reviews.r4e.core.model.R4ETextContent;
import org.eclipse.mylyn.reviews.r4e.core.model.R4ETextPosition;
import org.eclipse.mylyn.reviews.r4e.core.model.R4EUserRole;
import org.eclipse.mylyn.reviews.r4e.core.model.RModelFactory;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.IR4EUIModelElement;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIAnomalyBasic;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIContent;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIFileContext;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIModelController;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIParticipant;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIPostponedAnomaly;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIPostponedContainer;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIPostponedFile;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIReviewBasic;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIReviewGroup;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUIReviewItem;
import org.eclipse.mylyn.reviews.r4e.ui.internal.model.R4EUITextPosition;
import org.eclipse.mylyn.reviews.r4e.ui.internal.navigator.ReviewNavigatorActionGroup;
import org.eclipse.mylyn.reviews.r4e.ui.internal.utils.R4EUIConstants;
import org.eclipse.mylyn.reviews.r4e.ui.tests.R4ETestSetup;
import org.eclipse.mylyn.reviews.r4e.ui.tests.proxy.R4EUITestMain;
import org.eclipse.mylyn.reviews.r4e.ui.tests.utils.R4EAssert;
import org.eclipse.mylyn.reviews.r4e.ui.tests.utils.TestConstants;
import org.eclipse.mylyn.reviews.r4e.ui.tests.utils.TestUtils;
import org.junit.After;
import org.junit.Before;

@SuppressWarnings({ "restriction", "nls" })
public class PostponedAnomaliesTests extends TestCase {

	// ------------------------------------------------------------------------
	// Constants
	// ------------------------------------------------------------------------

	private static final String ORIGINAL_REVIEW_TEST_NAME = "originalReview";

	private static final String ORIGINAL_REVIEW_TEST_DESCRIPTION = "postponed anomalies: original review";

	private static final String ORIGINAL_ANOMALY1_TEST_TITLE = "originalAnomaly1";

	private static final String ORIGINAL_ANOMALY1_TEST_DESCRIPTION = "Original postponed anomaly 1";

	private static final String ORIGINAL_ANOMALY2_TEST_TITLE = "originalAnomaly2";

	private static final String ORIGINAL_ANOMALY2_TEST_DESCRIPTION = "Original postponed anomaly 2";

	private static final String TARGET_REVIEW_TEST_NAME = "targetReview";

	private static final String TARGET_REVIEW_TEST_DESCRIPTION = "postponed anomalies: target review";

	private static final String ORIGINAL_GLOBAL_ANOMALY_TEST_TITLE = "originalGlobalAnomaly";

	private static final String ORIGINAL_GLOBAL_ANOMALY_TEST_DESCRIPTION = "Original Global Postponed Anomaly";

	private static final String TARGET_GLOBAL_REVIEW_TEST_NAME = "globalTargetReview";

	private static final String TARGET_GLOBAL_REVIEW_TEST_DESCRIPTION = "postponed global anomalies: target review";

	// ------------------------------------------------------------------------
	// Member variables
	// ------------------------------------------------------------------------

	private R4EUITestMain fProxy = null;

	private R4EUIReviewGroup fGroup = null;

	private String fGroupName = null;

	private R4EUIReviewBasic fOriginalReview = null;

	private R4EUIReviewItem fOriginalItem = null;

	private R4EUIReviewItem fOriginalItem2 = null;

	private R4EUIReviewItem fOriginalItem3 = null;

	private String fOriginalItemName = null;

	private R4EUIAnomalyBasic fOriginalAnomaly1 = null;

	private R4EUIAnomalyBasic fOriginalAnomaly2 = null;

	private R4EUIReviewBasic fTargetReview = null;

	private R4EUIReviewItem fTargetItem = null;

	private R4EUIReviewItem fTargetItem2 = null;

	private R4EUIReviewItem fTargetItem3 = null;

	private String fOriginalAnomaly1Title = null;

	private String fOriginalAnomaly2Title = null;

	private String fFile1Name = null;

	private String fFile1VersionID = null;

	private R4EUIPostponedAnomaly fPostponedAnomaly1 = null;;

	private R4EUIPostponedAnomaly fPostponedAnomaly2 = null;

	private int fOrigAnomalyFileIndex;

	private R4EUIAnomalyBasic fOriginalGlobalAnomaly = null;

	private R4EUIReviewBasic fGlobalTargetReview = null;

	private R4EUIPostponedAnomaly fGlobalPostponedAnomaly = null;

	private String fOriginalGlobalAnomalyTitle = null;

	// ------------------------------------------------------------------------
	// Housekeeping
	// ------------------------------------------------------------------------

	/**
	 * Method suite - Sets up the global test environment, if not already done at the suite level.
	 * 
	 * @return Test
	 */
	public static Test suite() {
		TestSuite suite = new TestSuite();
		suite.addTestSuite(PostponedAnomaliesTests.class);
		return new R4ETestSetup(suite);
	}

	/**
	 * Method setUp - Sets up the fixture, for example, open a network connection. This method is called before a test
	 * is executed.
	 * 
	 * @throws java.lang.Exception
	 */
	@Before
	@Override
	public void setUp() throws Exception {
		fProxy = R4EUITestMain.getInstance();
		fProxy.getPreferencesProxy().setGlobalPostponedImport(true);
		createReviewGroups();
		createOriginalReview();
		createOriginalReviewItem();
		createParticipants(fOriginalReview);
		if (((ReviewNavigatorActionGroup) R4EUIModelController.getNavigatorView().getActionSet()).isHideDeltasFilterSet()) {
			fProxy.getCommandProxy().toggleHideDeltasFilter();
		}
		createOriginalPostponedAnomalies();
	}

	/**
	 * Method tearDown
	 * 
	 * @throws java.lang.Exception
	 */
	@After
	@Override
	public void tearDown() throws Exception {
		fProxy = null;
	}

	// ------------------------------------------------------------------------
	// Main test case
	// ------------------------------------------------------------------------

	/**
	 * Method testPostponedAnomalies
	 * 
	 * @throws CoreException
	 */
	public void testPostponedAnomalies() throws CoreException {
		TestUtils.waitForJobs();

		// Global Anomalies
		createOriginalGlobalPostponedAnomalies();
		createGlobalTargetReview();
		importGlobalAnomalies();
		changeGlobalPostponedAnomaliesState();
		changeOriginalGlobalAnomaliesState();
		fixGlobalPostponedAnomalies();

		// Local Anomalies
		createTargetReview();
		createTargetReviewItem();
		createParticipants(fTargetReview);
		importAnomalies();
		changePostponedAnomaliesState();
		changeOriginalAnomaliesState();
		fixPostponedAnomalies();
	}

	// ------------------------------------------------------------------------
	// Helper functions
	// ------------------------------------------------------------------------

	/**
	 * Method createReviewGroups
	 */
	private void createReviewGroups() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createReviewGroups");

		fGroup = null;

		// Create Review Group
		r4eAssert.setTest("Create Review Group");
		for (R4EUIReviewGroup group : R4EUIModelController.getRootElement().getGroups()) {
			if (group.getReviewGroup().getName().equals(TestConstants.REVIEW_GROUP_TEST_NAME)) {
				fGroup = group;
				fGroupName = group.getName();
				break;
			}
		}
		if (null == fGroup) {
			fGroup = fProxy.getReviewGroupProxy().createReviewGroup(
					TestUtils.FSharedFolder + File.separator + TestConstants.REVIEW_GROUP_TEST_NAME,
					TestConstants.REVIEW_GROUP_TEST_NAME, TestConstants.REVIEW_GROUP_TEST_DESCRIPTION,
					TestConstants.REVIEW_GROUP_TEST_ENTRY_CRITERIA, TestConstants.REVIEW_GROUP_TEST_AVAILABLE_PROJECTS,
					TestConstants.REVIEW_GROUP_TEST_AVAILABLE_COMPONENTS, new String[0]);
			r4eAssert.assertNotNull(fGroup);
			r4eAssert.assertEquals(TestConstants.REVIEW_GROUP_TEST_NAME, fGroup.getReviewGroup().getName());
			r4eAssert.assertEquals(new Path(TestUtils.FSharedFolder).toPortableString() + "/"
					+ TestConstants.REVIEW_GROUP_TEST_NAME, fGroup.getReviewGroup().getFolder());
			r4eAssert.assertEquals(TestConstants.REVIEW_GROUP_TEST_DESCRIPTION, fGroup.getReviewGroup()
					.getDescription());
			r4eAssert.assertEquals(TestConstants.REVIEW_GROUP_TEST_ENTRY_CRITERIA, fGroup.getReviewGroup()
					.getDefaultEntryCriteria());
			for (int i = 0; i < TestConstants.REVIEW_GROUP_TEST_AVAILABLE_PROJECTS.length; i++) {
				r4eAssert.assertEquals(TestConstants.REVIEW_GROUP_TEST_AVAILABLE_PROJECTS[i], fGroup.getReviewGroup()
						.getAvailableProjects()
						.get(i));
			}
			for (int i = 0; i < TestConstants.REVIEW_GROUP_TEST_AVAILABLE_COMPONENTS.length; i++) {
				r4eAssert.assertEquals(TestConstants.REVIEW_GROUP_TEST_AVAILABLE_COMPONENTS[i], fGroup.getReviewGroup()
						.getAvailableComponents()
						.get(i));
			}
			fGroupName = fGroup.getName();
		}
	}

	/**
	 * Method createOriginalReview
	 */
	private void createOriginalReview() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createOriginalReview");

		// Update Review Group handle
		r4eAssert.setTest("Update Review Group Handle");
		for (IR4EUIModelElement elem : R4EUIModelController.getRootElement().getChildren()) {
			if (fGroupName.equals(elem.getName())) {
				fGroup = (R4EUIReviewGroup) elem;
			}
		}
		if (!fGroup.isOpen()) {
			fProxy.getCommandProxy().openElement(fGroup);
		}
		r4eAssert.assertTrue(fGroup.isOpen());

		// Create Review Group
		r4eAssert.setTest("Create Review Group");
		fOriginalReview = fProxy.getReviewProxy().createReview(fGroup, TestConstants.REVIEW_TEST_TYPE_INFORMAL,
				ORIGINAL_REVIEW_TEST_NAME, ORIGINAL_REVIEW_TEST_DESCRIPTION, TestConstants.REVIEW_TEST_DUE_DATE,
				TestConstants.REVIEW_TEST_PROJECT, TestConstants.REVIEW_TEST_COMPONENTS,
				TestConstants.REVIEW_TEST_ENTRY_CRITERIA, TestConstants.REVIEW_TEST_OBJECTIVES,
				TestConstants.REVIEW_TEST_REFERENCE_MATERIALS);
		r4eAssert.assertNotNull(fOriginalReview);
		r4eAssert.assertNotNull(fOriginalReview.getParticipantContainer());
		r4eAssert.assertNotNull(fOriginalReview.getAnomalyContainer());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_TYPE_INFORMAL, fOriginalReview.getReview().getType());
		r4eAssert.assertEquals(ORIGINAL_REVIEW_TEST_NAME, fOriginalReview.getReview().getName());
		r4eAssert.assertEquals(ORIGINAL_REVIEW_TEST_DESCRIPTION, fOriginalReview.getReview().getExtraNotes());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_PROJECT, fOriginalReview.getReview().getProject());
		for (int i = 0; i < TestConstants.REVIEW_TEST_COMPONENTS.length; i++) {
			r4eAssert.assertEquals(TestConstants.REVIEW_TEST_COMPONENTS[i], fOriginalReview.getReview()
					.getComponents()
					.get(i));
		}
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_ENTRY_CRITERIA, fOriginalReview.getReview().getEntryCriteria());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_OBJECTIVES, fOriginalReview.getReview().getObjectives());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_REFERENCE_MATERIALS, fOriginalReview.getReview()
				.getReferenceMaterial());
		r4eAssert.assertTrue(fOriginalReview.isOpen());
	}

	/**
	 * Method createOriginalReviewItem
	 */
	private void createOriginalReviewItem() throws CoreException {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createOriginalReviewItem");

		r4eAssert.setTest("Create Commit Item");
		fOriginalItem = fProxy.getItemProxy().createCommitItem(TestUtils.FJavaIProject, 0);
		r4eAssert.assertNotNull(fOriginalItem);
		r4eAssert.assertEquals(R4EUIModelController.getReviewer(), fOriginalItem.getItem().getAddedById());
		r4eAssert.assertEquals("The.committer@some.com", fOriginalItem.getItem().getAuthorRep());
		r4eAssert.assertEquals("second Java Commit", fOriginalItem.getItem().getDescription());
		r4eAssert.assertEquals(4, fOriginalItem.getChildren().length);
		for (int i = 0; i < fOriginalItem.getChildren().length; i++) {
			if (((R4EUIFileContext) fOriginalItem.getChildren()[i]).getName().equals(TestUtils.JAVA_FILE1_PROJ_NAME)) {
				fOrigAnomalyFileIndex = i; //Used later to add anomalies
				r4eAssert.assertEquals(TestUtils.JAVA_FILE1_PROJ_NAME, fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getBase()
						.getName());
				r4eAssert.assertEquals(TestUtils.JAVA_FILE1_PROJ_NAME, fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getTarget()
						.getName());
				r4eAssert.assertEquals(606, ((R4ETextPosition) fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(0)
						.getTarget()
						.getLocation()).getStartPosition());
				r4eAssert.assertEquals(25, ((R4ETextPosition) fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(0)
						.getTarget()
						.getLocation()).getLength());
				r4eAssert.assertEquals(665, ((R4ETextPosition) fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(1)
						.getTarget()
						.getLocation()).getStartPosition());
				r4eAssert.assertEquals(63, ((R4ETextPosition) fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(1)
						.getTarget()
						.getLocation()).getLength());
				r4eAssert.assertEquals(733, ((R4ETextPosition) fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(2)
						.getTarget()
						.getLocation()).getStartPosition());
				r4eAssert.assertEquals(61, ((R4ETextPosition) fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(2)
						.getTarget()
						.getLocation()).getLength());
				fFile1Name = fOriginalItem.getFileContexts().get(i).getName();
				fFile1VersionID = fOriginalItem.getFileContexts().get(i).getTargetFileVersion().getVersionID();
			} else if (((R4EUIFileContext) fOriginalItem.getChildren()[i]).getName().equals(
					TestUtils.JAVA_FILE4_PROJ_NAME)) {
				r4eAssert.assertNull(fOriginalItem.getItem().getFileContextList().get(i).getBase());

				r4eAssert.assertEquals(TestUtils.JAVA_FILE4_PROJ_NAME, fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getTarget()
						.getName());
			} else if (((R4EUIFileContext) fOriginalItem.getChildren()[i]).getName().equals(
					TestUtils.JAVA_FILE3_PROJ_NAME)) {
				r4eAssert.assertNull(fOriginalItem.getItem().getFileContextList().get(i).getBase());
				r4eAssert.assertEquals(TestUtils.JAVA_FILE3_PROJ_NAME, fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getTarget()
						.getName());
			} else if (((R4EUIFileContext) fOriginalItem.getChildren()[i]).getName().equals(
					TestUtils.JAVA_FILE2_PROJ_NAME)) {
				r4eAssert.assertEquals(TestUtils.JAVA_FILE2_PROJ_NAME, fOriginalItem.getItem()
						.getFileContextList()
						.get(i)
						.getBase()
						.getName());
				r4eAssert.assertNull(fOriginalItem.getItem().getFileContextList().get(i).getTarget());
			}
		}

		r4eAssert.setTest("Create Manual Tree Item");
		fOriginalItem2 = fProxy.getItemProxy().createManualTreeItem(TestUtils.FJavaFile3);
		r4eAssert.assertNotNull(fOriginalItem2);
		r4eAssert.assertEquals(R4EUIModelController.getReviewer(), fOriginalItem2.getItem().getAddedById());
		r4eAssert.assertEquals(TestUtils.JAVA_FILE3_PROJ_NAME, fOriginalItem2.getItem()
				.getFileContextList()
				.get(0)
				.getBase()
				.getName());
		r4eAssert.assertEquals(TestUtils.JAVA_FILE3_PROJ_NAME, fOriginalItem2.getItem()
				.getFileContextList()
				.get(0)
				.getTarget()
				.getName());
		r4eAssert.assertEquals(0, ((R4ETextPosition) fOriginalItem2.getItem()
				.getFileContextList()
				.get(0)
				.getDeltas()
				.get(0)
				.getTarget()
				.getLocation()).getStartPosition());
		r4eAssert.assertEquals(755, ((R4ETextPosition) fOriginalItem2.getItem()
				.getFileContextList()
				.get(0)
				.getDeltas()
				.get(0)
				.getTarget()
				.getLocation()).getLength());

		r4eAssert.setTest("Create Manual Text Item");
		fOriginalItem3 = fProxy.getItemProxy().createManualTextItem(TestUtils.FJavaFile4, 50, 20);
		r4eAssert.assertNotNull(fOriginalItem3);
		r4eAssert.assertEquals(R4EUIModelController.getReviewer(), fOriginalItem3.getItem().getAddedById());
		r4eAssert.assertEquals(TestUtils.JAVA_FILE4_PROJ_NAME, fOriginalItem3.getItem()
				.getFileContextList()
				.get(0)
				.getBase()
				.getName());
		r4eAssert.assertEquals(TestUtils.JAVA_FILE4_PROJ_NAME, fOriginalItem3.getItem()
				.getFileContextList()
				.get(0)
				.getTarget()
				.getName());
		r4eAssert.assertEquals(50, ((R4ETextPosition) fOriginalItem3.getItem()
				.getFileContextList()
				.get(0)
				.getDeltas()
				.get(0)
				.getTarget()
				.getLocation()).getStartPosition());
		r4eAssert.assertEquals(20, ((R4ETextPosition) fOriginalItem3.getItem()
				.getFileContextList()
				.get(0)
				.getDeltas()
				.get(0)
				.getTarget()
				.getLocation()).getLength());

		fOriginalItemName = fOriginalItem.getName();
	}

	/**
	 * Method createParticipants
	 * 
	 * @param aReview
	 */
	private void createParticipants(R4EUIReviewBasic aReview) {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createParticipants");

		r4eAssert.setTest("Create Participant");
		List<R4EParticipant> participants = new ArrayList<R4EParticipant>(1);
		R4EParticipant participant = RModelFactory.eINSTANCE.createR4EParticipant();
		participant.setId(TestConstants.PARTICIPANT_TEST_ID);
		participant.setEmail(TestConstants.PARTICIPANT_TEST_EMAIL);
		participants.add(participant);
		R4EUIParticipant uiParticipant = fProxy.getParticipantProxy().createParticipant(
				aReview.getParticipantContainer(), participants);
		r4eAssert.assertNotNull(uiParticipant);
		r4eAssert.assertEquals(TestConstants.PARTICIPANT_TEST_ID, uiParticipant.getParticipant().getId());
		r4eAssert.assertEquals(TestConstants.PARTICIPANT_TEST_EMAIL, uiParticipant.getParticipant().getEmail());
		r4eAssert.assertEquals(R4EUserRole.R4E_ROLE_REVIEWER, uiParticipant.getParticipant().getRoles().get(0));
	}

	// ------------------------------------------------------------------------
	// Create Original Postponed Anomalies
	// ------------------------------------------------------------------------

	/**
	 * Method createOriginalPostponedAnomalies
	 */
	private void createOriginalPostponedAnomalies() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createOriginalPostponedAnomalies");

		// Anomaly1
		r4eAssert.setTest("Anomaly 1");
		R4EUIContent content1 = fOriginalItem.getFileContexts()
				.get(fOrigAnomalyFileIndex)
				.getContentsContainerElement()
				.getContentsList()
				.get(0);
		fOriginalAnomaly1 = fProxy.getAnomalyProxy().createLinkedAnomaly(content1, ORIGINAL_ANOMALY1_TEST_TITLE,
				ORIGINAL_ANOMALY1_TEST_DESCRIPTION, TestConstants.ANOMALY_TEST_CLASS_IMPROVEMENT,
				TestConstants.ANOMALY_TEST_RANK_MAJOR, TestConstants.ANOMALY_TEST_DUE_DATE,
				TestConstants.PARTICIPANT_ASSIGN_TO, null);
		r4eAssert.assertNotNull(fOriginalAnomaly1);
		r4eAssert.assertEquals(ORIGINAL_ANOMALY1_TEST_TITLE, fOriginalAnomaly1.getAnomaly().getTitle());
		r4eAssert.assertEquals(ORIGINAL_ANOMALY1_TEST_DESCRIPTION, fOriginalAnomaly1.getAnomaly().getDescription());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_CLASS_IMPROVEMENT,
				((R4ECommentType) fOriginalAnomaly1.getAnomaly().getType()).getType());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_RANK_MAJOR, fOriginalAnomaly1.getAnomaly().getRank());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_DUE_DATE, fOriginalAnomaly1.getAnomaly().getDueDate());
		r4eAssert.assertEquals(TestConstants.PARTICIPANT_ASSIGN_TO,
				fOriginalAnomaly1.getAnomaly().getAssignedTo().get(0));
		r4eAssert.assertEquals(
				((R4EUITextPosition) content1.getPosition()).getOffset(),
				((R4ETextPosition) ((R4ETextContent) fOriginalAnomaly1.getAnomaly().getLocation().get(0)).getLocation()).getStartPosition());
		r4eAssert.assertEquals(
				((R4EUITextPosition) content1.getPosition()).getLength(),
				((R4ETextPosition) ((R4ETextContent) fOriginalAnomaly1.getAnomaly().getLocation().get(0)).getLocation()).getLength());
		fProxy.getAnomalyProxy().progressAnomaly(fOriginalAnomaly1, TestConstants.ANOMALY_STATE_POSTPONED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fOriginalAnomaly1.getAnomaly().getState());
		fOriginalAnomaly1Title = fOriginalAnomaly1.getAnomaly().getTitle();

		// Anomaly2
		r4eAssert.setTest("Anomaly 2");
		R4EUIContent content2 = fOriginalItem.getFileContexts()
				.get(fOrigAnomalyFileIndex)
				.getContentsContainerElement()
				.getContentsList()
				.get(1);
		fOriginalAnomaly2 = fProxy.getAnomalyProxy().createLinkedAnomaly(content2, ORIGINAL_ANOMALY2_TEST_TITLE,
				ORIGINAL_ANOMALY2_TEST_DESCRIPTION, TestConstants.ANOMALY_TEST_CLASS_IMPROVEMENT,
				TestConstants.ANOMALY_TEST_RANK_MAJOR, TestConstants.ANOMALY_TEST_DUE_DATE,
				TestConstants.PARTICIPANT_ASSIGN_TO, null);
		r4eAssert.assertNotNull(fOriginalAnomaly2);
		r4eAssert.assertEquals(ORIGINAL_ANOMALY2_TEST_TITLE, fOriginalAnomaly2.getAnomaly().getTitle());
		r4eAssert.assertEquals(ORIGINAL_ANOMALY2_TEST_DESCRIPTION, fOriginalAnomaly2.getAnomaly().getDescription());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_CLASS_IMPROVEMENT,
				((R4ECommentType) fOriginalAnomaly2.getAnomaly().getType()).getType());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_RANK_MAJOR, fOriginalAnomaly2.getAnomaly().getRank());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_DUE_DATE, fOriginalAnomaly2.getAnomaly().getDueDate());
		r4eAssert.assertEquals(TestConstants.PARTICIPANT_ASSIGN_TO,
				fOriginalAnomaly2.getAnomaly().getAssignedTo().get(0));
		r4eAssert.assertEquals(
				((R4EUITextPosition) content2.getPosition()).getOffset(),
				((R4ETextPosition) ((R4ETextContent) fOriginalAnomaly2.getAnomaly().getLocation().get(0)).getLocation()).getStartPosition());
		r4eAssert.assertEquals(
				((R4EUITextPosition) content2.getPosition()).getLength(),
				((R4ETextPosition) ((R4ETextContent) fOriginalAnomaly2.getAnomaly().getLocation().get(0)).getLocation()).getLength());
		fProxy.getAnomalyProxy().progressAnomaly(fOriginalAnomaly2, TestConstants.ANOMALY_STATE_POSTPONED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fOriginalAnomaly2.getAnomaly().getState());
		fOriginalAnomaly2Title = fOriginalAnomaly2.getAnomaly().getTitle();
	}

	// ------------------------------------------------------------------------
	// Create Target Review
	// ------------------------------------------------------------------------

	/**
	 * Method createTargetReview
	 */
	private void createTargetReview() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createTargetReview");

		r4eAssert.setTest("Create Review");
		fTargetReview = fProxy.getReviewProxy().createReview(fGroup, TestConstants.REVIEW_TEST_TYPE_INFORMAL,
				TARGET_REVIEW_TEST_NAME, TARGET_REVIEW_TEST_DESCRIPTION, TestConstants.REVIEW_TEST_DUE_DATE,
				TestConstants.REVIEW_TEST_PROJECT, TestConstants.REVIEW_TEST_COMPONENTS,
				TestConstants.REVIEW_TEST_ENTRY_CRITERIA, TestConstants.REVIEW_TEST_OBJECTIVES,
				TestConstants.REVIEW_TEST_REFERENCE_MATERIALS);
		r4eAssert.assertNotNull(fTargetReview);
		r4eAssert.assertNotNull(fTargetReview.getParticipantContainer());
		r4eAssert.assertNotNull(fTargetReview.getAnomalyContainer());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_TYPE_INFORMAL, fTargetReview.getReview().getType());
		r4eAssert.assertEquals(TARGET_REVIEW_TEST_NAME, fTargetReview.getReview().getName());
		r4eAssert.assertEquals(TARGET_REVIEW_TEST_DESCRIPTION, fTargetReview.getReview().getExtraNotes());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_PROJECT, fTargetReview.getReview().getProject());
		for (int i = 0; i < TestConstants.REVIEW_TEST_COMPONENTS.length; i++) {
			r4eAssert.assertEquals(TestConstants.REVIEW_TEST_COMPONENTS[i], fTargetReview.getReview()
					.getComponents()
					.get(i));
		}
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_ENTRY_CRITERIA, fTargetReview.getReview().getEntryCriteria());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_OBJECTIVES, fTargetReview.getReview().getObjectives());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_REFERENCE_MATERIALS, fTargetReview.getReview()
				.getReferenceMaterial());
		r4eAssert.assertTrue(fTargetReview.isOpen());
	}

	// ------------------------------------------------------------------------
	// Create Target Review Item
	// ------------------------------------------------------------------------

	/**
	 * Method createTargetReviewItem
	 */
	private void createTargetReviewItem() throws CoreException {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createTargetReviewItem");

		r4eAssert.setTest("Create Commit Item");
		fTargetItem = fProxy.getItemProxy().createCommitItem(TestUtils.FJavaIProject, 0);
		r4eAssert.assertNotNull(fTargetItem);
		r4eAssert.assertEquals(R4EUIModelController.getReviewer(), fTargetItem.getItem().getAddedById());
		r4eAssert.assertEquals("The.committer@some.com", fTargetItem.getItem().getAuthorRep());
		r4eAssert.assertEquals("second Java Commit", fTargetItem.getItem().getDescription());
		r4eAssert.assertEquals(4, fTargetItem.getChildren().length);
		for (int i = 0; i < fTargetItem.getChildren().length; i++) {
			if (((R4EUIFileContext) fTargetItem.getChildren()[i]).getName().equals(TestUtils.JAVA_FILE1_PROJ_NAME)) {

				r4eAssert.assertEquals(TestUtils.JAVA_FILE1_PROJ_NAME, fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getBase()
						.getName());
				r4eAssert.assertEquals(TestUtils.JAVA_FILE1_PROJ_NAME, fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getTarget()
						.getName());
				r4eAssert.assertEquals(606, ((R4ETextPosition) fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(0)
						.getTarget()
						.getLocation()).getStartPosition());
				r4eAssert.assertEquals(25, ((R4ETextPosition) fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(0)
						.getTarget()
						.getLocation()).getLength());
				r4eAssert.assertEquals(665, ((R4ETextPosition) fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(1)
						.getTarget()
						.getLocation()).getStartPosition());
				r4eAssert.assertEquals(63, ((R4ETextPosition) fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(1)
						.getTarget()
						.getLocation()).getLength());
				r4eAssert.assertEquals(733, ((R4ETextPosition) fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(2)
						.getTarget()
						.getLocation()).getStartPosition());
				r4eAssert.assertEquals(61, ((R4ETextPosition) fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getDeltas()
						.get(2)
						.getTarget()
						.getLocation()).getLength());
				//	r4eAssert.assertTrue(fProxy.getCommandProxy().verifyAnnotations(
				//			((R4EUIFileContext) fTargetItem.getChildren()[i]).getContentsContainerElement().getChildren(),
				//			true, R4EUIConstants.DELTA_ANNOTATION_ID));
			} else if (((R4EUIFileContext) fTargetItem.getChildren()[i]).getName().equals(
					TestUtils.JAVA_FILE4_PROJ_NAME)) {
				r4eAssert.assertNull(fTargetItem.getItem().getFileContextList().get(i).getBase());
				r4eAssert.assertEquals(TestUtils.JAVA_FILE4_PROJ_NAME, fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getTarget()
						.getName());
			} else if (((R4EUIFileContext) fTargetItem.getChildren()[i]).getName().equals(
					TestUtils.JAVA_FILE3_PROJ_NAME)) {
				r4eAssert.assertNull(fTargetItem.getItem().getFileContextList().get(i).getBase());
				r4eAssert.assertEquals(TestUtils.JAVA_FILE3_PROJ_NAME, fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getTarget()
						.getName());
			} else if (((R4EUIFileContext) fTargetItem.getChildren()[i]).getName().equals(
					TestUtils.JAVA_FILE2_PROJ_NAME)) {
				r4eAssert.assertEquals(TestUtils.JAVA_FILE2_PROJ_NAME, fTargetItem.getItem()
						.getFileContextList()
						.get(i)
						.getBase()
						.getName());
				r4eAssert.assertNull(fTargetItem.getItem().getFileContextList().get(i).getTarget());
			}
		}

		r4eAssert.setTest("Create Manual Tree Item");
		fTargetItem2 = fProxy.getItemProxy().createManualTreeItem(TestUtils.FJavaFile3);
		r4eAssert.assertNotNull(fTargetItem2);
		r4eAssert.assertEquals(R4EUIModelController.getReviewer(), fTargetItem2.getItem().getAddedById());
		r4eAssert.assertEquals(TestUtils.JAVA_FILE3_PROJ_NAME, fTargetItem2.getItem()
				.getFileContextList()
				.get(0)
				.getBase()
				.getName());
		r4eAssert.assertEquals(TestUtils.JAVA_FILE3_PROJ_NAME, fTargetItem2.getItem()
				.getFileContextList()
				.get(0)
				.getTarget()
				.getName());
		r4eAssert.assertEquals(0, ((R4ETextPosition) fTargetItem2.getItem()
				.getFileContextList()
				.get(0)
				.getDeltas()
				.get(0)
				.getTarget()
				.getLocation()).getStartPosition());
		r4eAssert.assertEquals(755, ((R4ETextPosition) fTargetItem2.getItem()
				.getFileContextList()
				.get(0)
				.getDeltas()
				.get(0)
				.getTarget()
				.getLocation()).getLength());
		r4eAssert.assertTrue(fProxy.getCommandProxy().verifyAnnotations(
				((R4EUIFileContext) fTargetItem2.getChildren()[0]).getContentsContainerElement().getChildren(), false,
				R4EUIConstants.SELECTION_ANNOTATION_ID));

		r4eAssert.setTest("Create Manual Text Item");
		fTargetItem3 = fProxy.getItemProxy().createManualTextItem(TestUtils.FJavaFile4, 50, 20);
		r4eAssert.assertNotNull(fTargetItem3);
		r4eAssert.assertEquals(R4EUIModelController.getReviewer(), fTargetItem3.getItem().getAddedById());
		r4eAssert.assertEquals(TestUtils.JAVA_FILE4_PROJ_NAME, fTargetItem3.getItem()
				.getFileContextList()
				.get(0)
				.getBase()
				.getName());
		r4eAssert.assertEquals(TestUtils.JAVA_FILE4_PROJ_NAME, fTargetItem3.getItem()
				.getFileContextList()
				.get(0)
				.getTarget()
				.getName());
		r4eAssert.assertEquals(50, ((R4ETextPosition) fTargetItem3.getItem()
				.getFileContextList()
				.get(0)
				.getDeltas()
				.get(0)
				.getTarget()
				.getLocation()).getStartPosition());
		r4eAssert.assertEquals(20, ((R4ETextPosition) fTargetItem3.getItem()
				.getFileContextList()
				.get(0)
				.getDeltas()
				.get(0)
				.getTarget()
				.getLocation()).getLength());
		r4eAssert.assertTrue(fProxy.getCommandProxy().verifyAnnotations(
				((R4EUIFileContext) fTargetItem3.getChildren()[0]).getContentsContainerElement().getChildren(), true,
				R4EUIConstants.SELECTION_ANNOTATION_ID));
	}

	// ------------------------------------------------------------------------
	// Import Anomalies
	// ------------------------------------------------------------------------

	/**
	 * Method importAnomalies
	 */
	private void importAnomalies() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("importAnomalies");

		r4eAssert.setTest("Import Postponed Anomaly");
		fProxy.getCommandProxy().importPostponedAnomalies(fTargetReview);

		// Verify that the postponed anomalies were correctly imported
		R4EUIPostponedContainer postponedContainer = fTargetReview.getPostponedContainer();
		r4eAssert.assertNotNull(postponedContainer);

		R4EUIPostponedFile postponedFile = (R4EUIPostponedFile) postponedContainer.getChildren()[0];
		r4eAssert.assertNotNull(postponedFile);
		r4eAssert.assertEquals(fFile1Name, postponedFile.getName());
		r4eAssert.assertEquals(fFile1VersionID, postponedFile.getTargetFileVersion().getVersionID());

		r4eAssert.setTest("Postponed Anomaly 1");
		fPostponedAnomaly1 = (R4EUIPostponedAnomaly) postponedFile.getChildren()[0];
		r4eAssert.assertNotNull(fPostponedAnomaly1);
		r4eAssert.assertEquals(fOriginalAnomaly1Title, fPostponedAnomaly1.getAnomaly().getTitle());
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fPostponedAnomaly1.getAnomaly().getState());
		r4eAssert.assertEquals(fOriginalReview.getReview().getName(),
				fPostponedAnomaly1.getAnomaly().getInfoAtt().get(R4EUIConstants.POSTPONED_ATTR_ORIG_REVIEW_NAME));

		r4eAssert.setTest("Postponed Anomaly 2");
		fPostponedAnomaly2 = (R4EUIPostponedAnomaly) postponedFile.getChildren()[1];
		r4eAssert.assertNotNull(fPostponedAnomaly2);
		r4eAssert.assertEquals(fOriginalAnomaly2Title, fPostponedAnomaly2.getAnomaly().getTitle());
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fPostponedAnomaly2.getAnomaly().getState());
		r4eAssert.assertEquals(fOriginalReview.getReview().getName(),
				fPostponedAnomaly2.getAnomaly().getInfoAtt().get(R4EUIConstants.POSTPONED_ATTR_ORIG_REVIEW_NAME));

		//r4eAssert.assertTrue(fProxy.getCommandProxy().verifyAnnotations(fPostponedAnomaly2.getParent().getChildren(),
		//		false, R4EUIConstants.ANOMALY_CLOSED_ANNOTATION_ID));
	}

	// ------------------------------------------------------------------------
	// Change Postponed Anomaly State
	// ------------------------------------------------------------------------

	/**
	 * Method changePostponedAnomaliesState
	 */
	private void changePostponedAnomaliesState() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("changePostponedAnomaliesState");

		// Change postponed anomalies states to ASSIGNED
		r4eAssert.setTest("Assign Postponed Anomaly");
		fProxy.getCommandProxy().regressElement(fPostponedAnomaly1);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_ASSIGNED, fPostponedAnomaly1.getAnomaly().getState());
		fProxy.getCommandProxy().regressElement(fPostponedAnomaly2);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_ASSIGNED, fPostponedAnomaly2.getAnomaly().getState());
		//r4eAssert.assertTrue(fProxy.getCommandProxy().verifyAnnotations(fPostponedAnomaly2.getParent().getChildren(),
		//		false, R4EUIConstants.ANOMALY_OPEN_ANNOTATION_ID));

		// Verify that the original anomalies are also updated
		r4eAssert.setTest("Verify Original Anomaly");
		fProxy.getCommandProxy().openElement(fOriginalReview);
		r4eAssert.assertTrue(fOriginalReview.isOpen());
		r4eAssert.assertFalse(fTargetReview.isOpen());

		for (IR4EUIModelElement elem : fOriginalReview.getChildren()) {
			if (elem.getName().equals(fOriginalItemName)) {
				fOriginalItem = (R4EUIReviewItem) elem;
			}
		}
		for (int i = 0; i < fOriginalItem.getChildren().length; i++) {
			if (((R4EUIFileContext) fOriginalItem.getChildren()[i]).getName().equals(TestUtils.JAVA_FILE1_PROJ_NAME)) {
				fOriginalAnomaly1 = (R4EUIAnomalyBasic) fOriginalItem.getFileContexts()
						.get(i)
						.getAnomalyContainerElement()
						.getChildren()[0];

				fOriginalAnomaly2 = (R4EUIAnomalyBasic) fOriginalItem.getFileContexts()
						.get(i)
						.getAnomalyContainerElement()
						.getChildren()[1];
			}
		}
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_ASSIGNED, fOriginalAnomaly1.getAnomaly().getState());
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_ASSIGNED, fOriginalAnomaly2.getAnomaly().getState());
	}

	// ------------------------------------------------------------------------
	// Change Original Anomaly State
	// ------------------------------------------------------------------------

	/**
	 * Method changeOriginalAnomaliesState
	 */
	private void changeOriginalAnomaliesState() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("changeOriginalAnomaliesState");

		// Change original anomalies states back to POSTPONED
		r4eAssert.setTest("Postpone Anomaly");
		fProxy.getAnomalyProxy().progressAnomaly(fOriginalAnomaly1, TestConstants.ANOMALY_STATE_POSTPONED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fOriginalAnomaly1.getAnomaly().getState());
		fProxy.getAnomalyProxy().progressAnomaly(fOriginalAnomaly2, TestConstants.ANOMALY_STATE_POSTPONED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fOriginalAnomaly2.getAnomaly().getState());

		// Re-import of Target review and make sure the postponed anomalies are back
		r4eAssert.setTest("Import Anomalies");
		fProxy.getCommandProxy().openElement(fTargetReview);
		r4eAssert.assertTrue(fTargetReview.isOpen());
		r4eAssert.assertFalse(fOriginalReview.isOpen());
		importAnomalies();
	}

	// ------------------------------------------------------------------------
	// Fix Postponed Anomaly
	// ------------------------------------------------------------------------

	/**
	 * Method fixPostponedAnomalies
	 */
	private void fixPostponedAnomalies() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("fixPostponedAnomalies");

		// Set postponed anomalies state to FIXED
		r4eAssert.setTest("Fix Anomaly");
		fProxy.getCommandProxy().regressElement(fPostponedAnomaly1);
		fProxy.getAnomalyProxy().progressAnomaly(fPostponedAnomaly1, TestConstants.ANOMALY_STATE_FIXED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_FIXED, fPostponedAnomaly1.getAnomaly().getState());
		fProxy.getCommandProxy().regressElement(fPostponedAnomaly2);
		fProxy.getAnomalyProxy().progressAnomaly(fPostponedAnomaly2, TestConstants.ANOMALY_STATE_FIXED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_FIXED, fPostponedAnomaly2.getAnomaly().getState());

		// Re-import anomalies and make sure they are disabled
		r4eAssert.setTest("Check Anomaly");
		fProxy.getCommandProxy().importPostponedAnomalies(fTargetReview);
		r4eAssert.assertEquals(0, fTargetReview.getPostponedContainer().getChildren().length);
	}

	// ------------------------------------------------------------------------
	// Create Original Global Postponed Anomaly
	// ------------------------------------------------------------------------

	/**
	 * Method createOriginalGlobalPostponedAnomalies
	 */
	private void createOriginalGlobalPostponedAnomalies() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createOriginalGlobalPostponedAnomalies");

		// Anomaly1
		r4eAssert.setTest("Create Global Anomaly");
//		R4EUIAnomalyContainer cont1 = fOriginalReview.getAnomalyContainer();
//		R4EUIAnomalyContainer cont2 = R4EUIModelController.getActiveReview().getAnomalyContainer();
		fOriginalGlobalAnomaly = fProxy.getAnomalyProxy().createGlobalAnomaly(fOriginalReview.getAnomalyContainer(),
				ORIGINAL_GLOBAL_ANOMALY_TEST_TITLE, ORIGINAL_GLOBAL_ANOMALY_TEST_DESCRIPTION,
				TestConstants.ANOMALY_TEST_CLASS_IMPROVEMENT, TestConstants.ANOMALY_TEST_RANK_MAJOR,
				TestConstants.ANOMALY_TEST_DUE_DATE, null, TestConstants.PARTICIPANT_ASSIGN_TO);
		r4eAssert.assertNotNull(fOriginalGlobalAnomaly);
		r4eAssert.assertEquals(ORIGINAL_GLOBAL_ANOMALY_TEST_TITLE, fOriginalGlobalAnomaly.getAnomaly().getTitle());
		r4eAssert.assertEquals(ORIGINAL_GLOBAL_ANOMALY_TEST_DESCRIPTION, fOriginalGlobalAnomaly.getAnomaly()
				.getDescription());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_CLASS_IMPROVEMENT,
				((R4ECommentType) fOriginalGlobalAnomaly.getAnomaly().getType()).getType());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_RANK_MAJOR, fOriginalGlobalAnomaly.getAnomaly().getRank());
		r4eAssert.assertEquals(TestConstants.ANOMALY_TEST_DUE_DATE, fOriginalGlobalAnomaly.getAnomaly().getDueDate());
		r4eAssert.assertEquals(TestConstants.PARTICIPANT_ASSIGN_TO, fOriginalGlobalAnomaly.getAnomaly()
				.getAssignedTo()
				.get(0));
		fProxy.getAnomalyProxy().progressAnomaly(fOriginalGlobalAnomaly, TestConstants.ANOMALY_STATE_POSTPONED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fOriginalGlobalAnomaly.getAnomaly().getState());
		fOriginalGlobalAnomalyTitle = fOriginalGlobalAnomaly.getAnomaly().getTitle();
	}

	// ------------------------------------------------------------------------
	// Create Global Target Review
	// ------------------------------------------------------------------------

	/**
	 * Method createGlobalTargetReview
	 */
	private void createGlobalTargetReview() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("createGlobalTargetReview");

		r4eAssert.setTest("Create Review");
		fGlobalTargetReview = fProxy.getReviewProxy().createReview(fGroup, TestConstants.REVIEW_TEST_TYPE_INFORMAL,
				TARGET_GLOBAL_REVIEW_TEST_NAME, TARGET_GLOBAL_REVIEW_TEST_DESCRIPTION,
				TestConstants.REVIEW_TEST_DUE_DATE, TestConstants.REVIEW_TEST_PROJECT,
				TestConstants.REVIEW_TEST_COMPONENTS, TestConstants.REVIEW_TEST_ENTRY_CRITERIA,
				TestConstants.REVIEW_TEST_OBJECTIVES, TestConstants.REVIEW_TEST_REFERENCE_MATERIALS);
		r4eAssert.assertNotNull(fGlobalTargetReview);
		r4eAssert.assertNotNull(fGlobalTargetReview.getParticipantContainer());
		r4eAssert.assertNotNull(fGlobalTargetReview.getAnomalyContainer());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_TYPE_INFORMAL, fGlobalTargetReview.getReview().getType());
		r4eAssert.assertEquals(TARGET_GLOBAL_REVIEW_TEST_NAME, fGlobalTargetReview.getReview().getName());
		r4eAssert.assertEquals(TARGET_GLOBAL_REVIEW_TEST_DESCRIPTION, fGlobalTargetReview.getReview().getExtraNotes());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_PROJECT, fGlobalTargetReview.getReview().getProject());
		for (int i = 0; i < TestConstants.REVIEW_TEST_COMPONENTS.length; i++) {
			r4eAssert.assertEquals(TestConstants.REVIEW_TEST_COMPONENTS[i], fGlobalTargetReview.getReview()
					.getComponents()
					.get(i));
		}
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_ENTRY_CRITERIA, fGlobalTargetReview.getReview()
				.getEntryCriteria());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_OBJECTIVES, fGlobalTargetReview.getReview().getObjectives());
		r4eAssert.assertEquals(TestConstants.REVIEW_TEST_REFERENCE_MATERIALS, fGlobalTargetReview.getReview()
				.getReferenceMaterial());
		r4eAssert.assertTrue(fGlobalTargetReview.isOpen());
	}

	// ------------------------------------------------------------------------
	// Import Global Anomaly 
	// ------------------------------------------------------------------------

	/**
	 * Method importGlobalAnomalies
	 */
	private void importGlobalAnomalies() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("importGlobalAnomalies");

		r4eAssert.setTest("Import Postponed Anomaly");
		fProxy.getCommandProxy().importPostponedAnomalies(fGlobalTargetReview);

		// Verify that the global postponed anomalies were correctly imported
		R4EUIPostponedContainer postponedContainer = fGlobalTargetReview.getPostponedContainer();
		r4eAssert.assertNotNull(postponedContainer);

		r4eAssert.setTest("Check Anomaly");
		fGlobalPostponedAnomaly = (R4EUIPostponedAnomaly) postponedContainer.getAnomalyContainer().getChildren()[0];
		r4eAssert.assertEquals(fOriginalReview.getReview().getName(), fGlobalPostponedAnomaly.getOriginalReviewName());
		r4eAssert.assertNotNull(fGlobalPostponedAnomaly);
		r4eAssert.assertEquals(fOriginalGlobalAnomalyTitle, fGlobalPostponedAnomaly.getAnomaly().getTitle());
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fGlobalPostponedAnomaly.getAnomaly().getState());
	}

	// ------------------------------------------------------------------------
	// Change Global Postponed Anomaly State 
	// ------------------------------------------------------------------------

	/**
	 * Method changeGlobalPostponedAnomaliesState
	 */
	private void changeGlobalPostponedAnomaliesState() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("changeGlobalPostponedAnomaliesState");

		// Change postponed global anomaly states to ASSIGNED
		r4eAssert.setTest("Change Postponed Anomaly");
		fProxy.getCommandProxy().regressElement(fGlobalPostponedAnomaly);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_ASSIGNED, fGlobalPostponedAnomaly.getAnomaly().getState());

		// Verify that the original global anomaly is also updated
		r4eAssert.setTest("Verify Anomaly");
		fProxy.getCommandProxy().openElement(fOriginalReview);
		r4eAssert.assertTrue(fOriginalReview.isOpen());
		r4eAssert.assertFalse(fGlobalTargetReview.isOpen());
		fOriginalGlobalAnomaly = (R4EUIAnomalyBasic) fOriginalReview.getAnomalyContainer().getChildren()[0];
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_ASSIGNED, fOriginalGlobalAnomaly.getAnomaly().getState());
	}

	// ------------------------------------------------------------------------
	// Change Global Postponed Anomaly State 
	// ------------------------------------------------------------------------

	/**
	 * Method changeOriginalGlobalAnomaliesState
	 */
	private void changeOriginalGlobalAnomaliesState() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("changeOriginalGlobalAnomaliesState");

		// Change original global anomaly states back to POSTPONED
		r4eAssert.setTest("Change Global Anomaly");
		fProxy.getAnomalyProxy().progressAnomaly(fOriginalGlobalAnomaly, TestConstants.ANOMALY_STATE_POSTPONED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_POSTPONED, fOriginalGlobalAnomaly.getAnomaly().getState());

		// Re-import of Target review and make sure the postponed anomalies are back
		r4eAssert.setTest("Verify Anomaly");
		fProxy.getCommandProxy().openElement(fGlobalTargetReview);
		r4eAssert.assertTrue(fGlobalTargetReview.isOpen());
		r4eAssert.assertFalse(fOriginalReview.isOpen());
		importGlobalAnomalies();
	}

	// ------------------------------------------------------------------------
	// Fix Global Postponed Anomaly State 
	// ------------------------------------------------------------------------

	/**
	 * Method fixGlobalPostponedAnomalies
	 */
	private void fixGlobalPostponedAnomalies() {

		// Assert object
		R4EAssert r4eAssert = new R4EAssert("fixGlobalPostponedAnomalies");

		// Set postponed global anomaly state to FIXED
		r4eAssert.setTest("Change Global Anomaly");
		fProxy.getCommandProxy().regressElement(fGlobalPostponedAnomaly);
		fProxy.getAnomalyProxy().progressAnomaly(fGlobalPostponedAnomaly, TestConstants.ANOMALY_STATE_FIXED);
		r4eAssert.assertEquals(TestConstants.ANOMALY_STATE_FIXED, fGlobalPostponedAnomaly.getAnomaly().getState());

		// Re-import anomalies and make sure they are disabled
		r4eAssert.setTest("Verify Anomaly");
		fProxy.getCommandProxy().importPostponedAnomalies(fGlobalTargetReview);
		r4eAssert.assertEquals(0, fGlobalTargetReview.getPostponedContainer().getChildren().length);
	}
}