org.eclipse.stem.tests.core/src/org/eclipse/stem/core/sequencer/tests/SequentialSequencerTest.java

package org.eclipse.stem.core.sequencer.tests;

/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

import java.util.Calendar;

import junit.textui.TestRunner;

import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.stem.core.model.ModelFactory;
import org.eclipse.stem.core.model.STEMTime;
import org.eclipse.stem.core.sequencer.Sequencer;
import org.eclipse.stem.core.sequencer.SequencerFactory;
import org.eclipse.stem.core.sequencer.SequentialSequencer;

/**
 * <!-- begin-user-doc --> A test case for the model object '<em><b>Sequential Sequencer</b></em>'.
 * <!-- end-user-doc -->
 * @generated
 */
@SuppressWarnings("all")
public class SequentialSequencerTest extends SequencerTest {

	private static final int START_DAY = 20;
	private static final int END_DAY = 29;
	private static final int NUMBER_OF_DAYS =  END_DAY - START_DAY + 1;
	
	// The fixture sequencer sequences through 10 days
	public static final STEMTime START_TIME = createSTEMTime(2006,
			Calendar.NOVEMBER, START_DAY);

	public static final STEMTime END_TIME = createSTEMTime(2006,
			Calendar.NOVEMBER, END_DAY);

	public static final long TIME_INCREMENT = STEMTime.Units.DAY.getMilliseconds();
	

	protected SequentialSequencer sequencerWithNoEndTime = null;

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * @generated
	 */
	public static void main(String[] args) {
		TestRunner.run(SequentialSequencerTest.class);
	}

	/**
	 * Constructs a new Sequential Sequencer test case with the given name. <!--
	 * begin-user-doc --> <!-- end-user-doc -->
	 * 
	 * @generated
	 */
	public SequentialSequencerTest(String name) {
		super(name);
	}

	/**
	 * Sets the fixture for this Sequential Sequencer test case. <!--
	 * begin-user-doc --> <!-- end-user-doc -->
	 * 
	 * @generated NOT
	 */
	protected void setFixture(SequentialSequencer fixture) {
		super.setFixture(fixture);
	}

	/**
	 * Returns the fixture for this Sequential Sequencer test case. <!--
	 * begin-user-doc --> <!-- end-user-doc -->
	 * 
	 * @generated NOT
	 */
	protected SequentialSequencer getFixture() {
		return (SequentialSequencer) super.fixture;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * 
	 * @see junit.framework.TestCase#setUp()
	 * @generated NOT
	 */
	protected void setUp() throws Exception {
		setFixture(createFixture());

		sequencerWithNoEndTime = SequencerFactory.eINSTANCE
				.createSequentialSequencer();
		sequencerWithNoEndTime.setStartTime((STEMTime) EcoreUtil
				.copy(START_TIME));
		sequencerWithNoEndTime.setCurrentTime((STEMTime) EcoreUtil
				.copy(START_TIME));
		sequencerWithNoEndTime.setTimeIncrement(TIME_INCREMENT);
	} // setUp

	/**
	 * @return a sequential sequencer
	 */
	public static SequentialSequencer createFixture() {
		final SequentialSequencer sequencerWithEnd = SequencerFactory.eINSTANCE
				.createSequentialSequencer();
		sequencerWithEnd.setStartTime((STEMTime) EcoreUtil.copy(START_TIME));
		sequencerWithEnd.setCurrentTime((STEMTime) EcoreUtil.copy(START_TIME));
		sequencerWithEnd.setEndTime((STEMTime) EcoreUtil.copy(END_TIME));
		sequencerWithEnd.setTimeIncrement(TIME_INCREMENT);
		return sequencerWithEnd;
	} // createFixture

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 * 
	 * @see junit.framework.TestCase#tearDown()
	 * @generated NOT
	 */
	protected void tearDown() throws Exception {
		setFixture(null);
		sequencerWithNoEndTime = null;
	} // tearDown

	/**
	 * @see org.eclipse.stem.core.scenario.tests.SequencerTest#testGetNextTime()
	 */
	@Override
	public void testGetNextTime() {

		final STEMTime nextTime = START_TIME.addIncrement(TIME_INCREMENT);

		final SequentialSequencer seqWithEndTime = getFixture();
		// The first time should be the start time
		assertTrue(seqWithEndTime.getNextTime().equals(START_TIME));
		
		assertTrue(seqWithEndTime.getNextTime().equals(nextTime));
		assertFalse(seqWithEndTime.getNextTime().equals(nextTime));

		final SequentialSequencer seqWithNoEndTime = sequencerWithNoEndTime;
		assertTrue(seqWithNoEndTime.getNextTime().equals( START_TIME));
		assertTrue(seqWithNoEndTime.getNextTime().equals(nextTime));
		assertFalse(seqWithNoEndTime.getNextTime().equals(nextTime));
	} // testGetNextTime

	/**
	 * Test that the duration is computed correctly
	 */
	public void testGetDuration() {
		final SequentialSequencer seqWithEndTime = getFixture();
		assertTrue(seqWithEndTime.getDuration() == END_TIME.getTime().getTime()
				- START_TIME.getTime().getTime());

		final SequentialSequencer seqWithNoEndTime = sequencerWithNoEndTime;
		assertTrue(seqWithNoEndTime.getDuration() == Sequencer.UNKNOWN_DURATION);
	} // testGetDuration

	/**
	 * @see org.eclipse.stem.core.scenario.tests.SequencerTest#testGetWorkIncrement()
	 */
	@Override
	public void testGetWorkIncrement() {
		final SequentialSequencer seqWithEndTime = getFixture();
		assertTrue(seqWithEndTime.getWorkIncrement() == 10);

		final SequentialSequencer seqWithNoEndTime = sequencerWithNoEndTime;
		assertTrue(seqWithNoEndTime.getWorkIncrement() == 0);
	} // testGetWorkIncrement

	/**
	 * @see org.eclipse.stem.core.scenario.tests.SequencerTest#testIsTimeToStop()
	 */
	@Override
	public void testIsTimeToStop() {
		final SequentialSequencer seqWithEndTime = getFixture();
		assertNotNull(seqWithEndTime.getEndTime());
		assertFalse(seqWithEndTime.isTimeToStop());
		for (int i = 0; i < NUMBER_OF_DAYS; i++) {
			assertFalse(seqWithEndTime.isTimeToStop());
			seqWithEndTime.getNextTime();
		}
		assertTrue(seqWithEndTime.isTimeToStop());

		final SequentialSequencer seqWithNoEndTime = sequencerWithNoEndTime;
		assertFalse(seqWithNoEndTime.isTimeToStop());
		for (int i = 0; i < 10; i++) {
			seqWithNoEndTime.getNextTime();
			assertFalse(seqWithNoEndTime.isTimeToStop());
		}
		seqWithNoEndTime.getNextTime();
		assertFalse(seqWithNoEndTime.isTimeToStop());
	} // testIsTimeToStop

	/**
	 * @see org.eclipse.stem.core.tests.SequencerTest#testGetWorkComplete()
	 */
	public void testGetWorkComplete() {
		final SequentialSequencer seqWithEndTime = getFixture();
		assertFalse(seqWithEndTime.isTimeToStop());
		for (int i = 0; i < NUMBER_OF_DAYS; i++) {
			seqWithEndTime.getNextTime();
			assertTrue(seqWithEndTime.getWorkComplete() == (i+1) * NUMBER_OF_DAYS);
		}
		assertTrue(seqWithEndTime.getWorkComplete() == 100);

		final SequentialSequencer seqWithNoEndTime = sequencerWithNoEndTime;
		assertFalse(seqWithNoEndTime.isTimeToStop());
		for (int i = 0; i < NUMBER_OF_DAYS; i++) {
			seqWithNoEndTime.getNextTime();
			assertTrue(seqWithNoEndTime.getWorkComplete() == 0);
		}
		seqWithNoEndTime.getNextTime();
		assertTrue(seqWithNoEndTime.getWorkComplete() == 0);
	} // testGetWorkComplete

	/**
	 * @see org.eclipse.stem.core.sequencer.tests.SequencerTest#testReset()
	 */
	@Override
	public void testReset() {
		final SequentialSequencer seqWithEndTime = getFixture();
		assertTrue(seqWithEndTime.getStartTime().equals(
				seqWithEndTime.getCurrentTime()));
		final STEMTime time1 = seqWithEndTime.getNextTime();
		assertTrue(seqWithEndTime.getStartTime().equals(
				seqWithEndTime.getCurrentTime()));
		seqWithEndTime.reset();
		assertTrue(seqWithEndTime.getStartTime().equals(
				seqWithEndTime.getCurrentTime()));
	} // testReset

	/**
	 * Create an instance of STEMTime
	 * 
	 * @return the instance
	 */
	private static STEMTime createSTEMTime(final int year, final int month,
			final int day) {
		final STEMTime retValue = getCurrentSystemTime();

		final Calendar calendar = Calendar.getInstance();
		calendar.set(year, month, day);
		retValue.setTime(calendar.getTime());
		return retValue;
	} // createSTEMTime

	/**
	 * @return the current real wall clock time as returned by the system.
	 */
	protected static STEMTime getCurrentSystemTime() {
		return ModelFactory.eINSTANCE.createSTEMTime();
	} // getCurrentSystemTime
} // SequentialSequencerTest