SimpleNLG-EnFr-master/src/test/java/simplenlg/test/english/ClauseTest.java
/*
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is "Simplenlg".
 *
 * The Initial Developer of the Original Code is Ehud Reiter, Albert Gatt and Dave Westwater.
 * Portions created by Ehud Reiter, Albert Gatt and Dave Westwater are Copyright (C) 2010-11 The University of Aberdeen. All Rights Reserved.
 *
 * Contributor(s): Ehud Reiter, Albert Gatt, Dave Wewstwater, Roman Kutlak, Margaret Mitchell, Pierre-Luc Vaudry.
 */

package simplenlg.test.english;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.Test;

import simplenlg.features.ClauseStatus;
import simplenlg.features.Feature;
import simplenlg.features.Form;
import simplenlg.features.InternalFeature;
import simplenlg.features.NumberAgreement;
import simplenlg.features.Tense;
import simplenlg.framework.CoordinatedPhraseElement;
import simplenlg.framework.NLGElement;
import simplenlg.framework.PhraseCategory;
import simplenlg.framework.PhraseElement;
import simplenlg.phrasespec.NPPhraseSpec;
import simplenlg.phrasespec.SPhraseSpec;

// TODO: Auto-generated Javadoc
/**
 * The Class STest.
 */
public class ClauseTest extends SimpleNLG4TestBase {

	// set up a few more fixtures
	/** The s4. */
	SPhraseSpec s1, s2, s3, s4;

	/**
	 * Instantiates a new s test.
	 * 
	 * @param name
	 *            the name
	 */
	public ClauseTest(String name) {
		super(name);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see simplenlg.test.SimplenlgTest#setUp()
	 */
	@Override
	@Before
	protected void setUp() {
		super.setUp();

		// the woman kissed the man behind the curtain
		this.s1 = this.phraseFactory.createClause();
		this.s1.setSubject(this.woman);
		this.s1.setVerbPhrase(this.kiss);
		this.s1.setObject(this.man);

		// there is the dog on the rock
		this.s2 = this.phraseFactory.createClause();
		this.s2.setSubject("there"); //$NON-NLS-1$
		this.s2.setVerb("be"); //$NON-NLS-1$
		this.s2.setObject(this.dog);
		this.s2.addPostModifier(this.onTheRock);

		// the man gives the woman John's flower
		this.s3 = this.phraseFactory.createClause();
		this.s3.setSubject(this.man);
		this.s3.setVerbPhrase(this.give);

		NPPhraseSpec flower = this.phraseFactory.createNounPhrase("flower"); //$NON-NLS-1$
		NPPhraseSpec john = this.phraseFactory.createNounPhrase("John"); //$NON-NLS-1$
		john.setFeature(Feature.POSSESSIVE, true);
		flower.setFeature(InternalFeature.SPECIFIER, john);
		this.s3.setObject(flower);
		this.s3.setIndirectObject(this.woman);

		this.s4 = this.phraseFactory.createClause();
		this.s4.setFeature(Feature.CUE_PHRASE, "however"); //$NON-NLS-1$
		this.s4.addFrontModifier("tomorrow"); //$NON-NLS-1$

		CoordinatedPhraseElement subject = this.phraseFactory.createCoordinatedPhrase(
				this.phraseFactory.createNounPhrase("Jane"), this.phraseFactory //$NON-NLS-1$
						.createNounPhrase("Andrew")); //$NON-NLS-1$

		this.s4.setSubject(subject);

		PhraseElement pick = this.phraseFactory.createVerbPhrase("pick up"); //$NON-NLS-1$
		this.s4.setVerbPhrase(pick);
		this.s4.setObject("the balls"); //$NON-NLS-1$
		this.s4.addPostModifier("in the shop"); //$NON-NLS-1$
		this.s4.setFeature(Feature.TENSE,Tense.FUTURE);
	}

	/**
	 * Initial test for basic sentences.
	 */
	@Test
	public void testBasic() {
		Assert.assertEquals("the woman kisses the man", this.realiser //$NON-NLS-1$
				.realise(this.s1).getRealisation());
		Assert.assertEquals("there is the dog on the rock", this.realiser //$NON-NLS-1$
				.realise(this.s2).getRealisation());

		setUp();
		Assert.assertEquals("the man gives the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());
		Assert
				.assertEquals(
						"however tomorrow Jane and Andrew will pick up the balls in the shop", //$NON-NLS-1$
						this.realiser.realise(this.s4).getRealisation());
	}
	
	/**
	 * Test did not
	 */
	public void testDidNot() {
		PhraseElement s = phraseFactory.createClause("John", "eat");
		s.setTense(Tense.PAST);
		s.setNegated(true);

		Assert.assertEquals("John did not eat", //$NON-NLS-1$
				this.realiser.realise(s).getRealisation());

	}

	/**
	 * Test that pronominal args are being correctly cast as NPs.
	 */
	public void testPronounArguments() {
		// the subject of s2 should have been cast into a pronominal NP
		NLGElement subj = this.s2.getFeatureAsElementList(
				InternalFeature.SUBJECTS).get(0);
		Assert.assertTrue(subj.isA(PhraseCategory.NOUN_PHRASE));
		// Assert.assertTrue(LexicalCategory.PRONOUN.equals(((PhraseElement)
		// subj)
		// .getCategory()));
	}

	/**
	 * Tests for setting tense, aspect and passive from the sentence interface.
	 */
	@Test
	public void testTenses() {
		// simple past
		this.s3.setFeature(Feature.TENSE,Tense.PAST);
		Assert.assertEquals("the man gave the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		// perfect
		this.s3.setFeature(Feature.PERFECT, true);
		Assert.assertEquals("the man had given the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		// negation
		this.s3.setFeature(Feature.NEGATED,true);
		Assert.assertEquals("the man had not given the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		this.s3.setFeature(Feature.PROGRESSIVE, true);
		Assert.assertEquals(
				"the man had not been giving the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		// passivisation with direct and indirect object
		this.s3.setFeature(Feature.PASSIVE, true);
		// Assert.assertEquals(
		//				"John's flower had not been being given the woman by the man", //$NON-NLS-1$
		// this.realiser.realise(this.s3).getRealisation());
	}

	/**
	 * Test what happens when a sentence is subordinated as complement of a
	 * verb.
	 */
	@Test
	public void testSubordination() {

		// subordinate sentence by setting it as complement of a verb
		this.say.addComplement(this.s3);

		// check the getter
		Assert.assertEquals(ClauseStatus.SUBORDINATE, this.s3
				.getFeature(InternalFeature.CLAUSE_STATUS));

		// check realisation
		Assert.assertEquals("says that the man gives the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.say).getRealisation());
	}

	/**
	 * Test the various forms of a sentence, including subordinates.
	 */
	/**
	 * 
	 */
	@Test
	public void testForm() {

		// check the getter method
		Assert.assertEquals(Form.NORMAL, this.s1.getFeatureAsElement(
				InternalFeature.VERB_PHRASE).getFeature(Feature.FORM));

		// infinitive
		this.s1.setFeature(Feature.FORM, Form.INFINITIVE);

		Assert
				.assertEquals(
						"to kiss the man", this.realiser.realise(this.s1).getRealisation()); //$NON-NLS-1$

		// gerund with "there"
		this.s2.setFeature(Feature.FORM, Form.GERUND);
		Assert.assertEquals("there being the dog on the rock", this.realiser //$NON-NLS-1$
				.realise(this.s2).getRealisation());

		// gerund with possessive
		this.s3.setFeature(Feature.FORM, Form.GERUND);
		Assert.assertEquals("the man's giving the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		// imperative
		this.s3.setFeature(Feature.FORM, Form.IMPERATIVE);

		Assert.assertEquals("give the woman John's flower", this.realiser //$NON-NLS-1$
				.realise(this.s3).getRealisation());

		// subordinating the imperative to a verb should turn it to infinitive
		this.say.addComplement(this.s3);

		Assert.assertEquals("says to give the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.say).getRealisation());

		// imperative -- case II
		this.s4.setFeature(Feature.FORM, Form.IMPERATIVE);
		Assert.assertEquals("however tomorrow pick up the balls in the shop", //$NON-NLS-1$
				this.realiser.realise(this.s4).getRealisation());

		// infinitive -- case II
		this.s4 = this.phraseFactory.createClause();
		this.s4.setFeature(Feature.CUE_PHRASE, "however"); //$NON-NLS-1$
		this.s4.addFrontModifier("tomorrow"); //$NON-NLS-1$

		CoordinatedPhraseElement subject = phraseFactory.createCoordinatedPhrase(
				this.phraseFactory.createNounPhrase("Jane"), this.phraseFactory //$NON-NLS-1$
						.createNounPhrase("Andrew")); //$NON-NLS-1$

		this.s4.setFeature(InternalFeature.SUBJECTS, subject);

		PhraseElement pick = this.phraseFactory.createVerbPhrase("pick up"); //$NON-NLS-1$
		this.s4.setFeature(InternalFeature.VERB_PHRASE, pick);
		this.s4.setObject("the balls"); //$NON-NLS-1$
		this.s4.addPostModifier("in the shop"); //$NON-NLS-1$
		this.s4.setFeature(Feature.TENSE,Tense.FUTURE);
		this.s4.setFeature(Feature.FORM, Form.INFINITIVE);
		Assert.assertEquals(
				"however to pick up the balls in the shop tomorrow", //$NON-NLS-1$
				this.realiser.realise(this.s4).getRealisation());
	}

	/**
	 * Slightly more complex tests for forms.
	 */
	public void testForm2() {
		// set s4 as subject of a new sentence
		SPhraseSpec temp = this.phraseFactory.createClause(this.s4, "be", //$NON-NLS-1$
				"recommended"); //$NON-NLS-1$

		Assert.assertEquals(
				"however tomorrow Jane and Andrew's picking up the " + //$NON-NLS-1$
						"balls in the shop is recommended", //$NON-NLS-1$
				this.realiser.realise(temp).getRealisation());

		// compose this with a new sentence
		// ER - switched direct and indirect object in sentence
		SPhraseSpec temp2 = this.phraseFactory
				.createClause("I", "tell", temp); //$NON-NLS-1$ //$NON-NLS-2$
		temp2.setFeature(Feature.TENSE,Tense.FUTURE);

		PhraseElement indirectObject = this.phraseFactory
				.createNounPhrase("John"); //$NON-NLS-1$

		temp2.setIndirectObject(indirectObject);

		Assert.assertEquals("I will tell John that however tomorrow Jane and " + //$NON-NLS-1$
				"Andrew's picking up the balls in the shop is " + //$NON-NLS-1$
				"recommended", //$NON-NLS-1$
				this.realiser.realise(temp2).getRealisation());

		// turn s4 to imperative and put it in indirect object position

		this.s4 = this.phraseFactory.createClause();
		this.s4.setFeature(Feature.CUE_PHRASE, "however"); //$NON-NLS-1$
		this.s4.addFrontModifier("tomorrow"); //$NON-NLS-1$

		CoordinatedPhraseElement subject = phraseFactory.createCoordinatedPhrase(
				this.phraseFactory.createNounPhrase("Jane"), this.phraseFactory //$NON-NLS-1$
						.createNounPhrase("Andrew")); //$NON-NLS-1$

		this.s4.setSubject(subject);

		PhraseElement pick = this.phraseFactory.createVerbPhrase("pick up"); //$NON-NLS-1$
		this.s4.setVerbPhrase(pick);
		this.s4.setObject("the balls"); //$NON-NLS-1$
		this.s4.addPostModifier("in the shop"); //$NON-NLS-1$
		this.s4.setFeature(Feature.TENSE,Tense.FUTURE);
		this.s4.setFeature(Feature.FORM, Form.IMPERATIVE);

		temp2 = this.phraseFactory.createClause("I", "tell", this.s4); //$NON-NLS-1$ //$NON-NLS-2$
		indirectObject = this.phraseFactory.createNounPhrase("John"); //$NON-NLS-1$
		temp2.setIndirectObject(indirectObject);
		temp2.setFeature(Feature.TENSE,Tense.FUTURE);

		Assert.assertEquals("I will tell John however to pick up the balls " //$NON-NLS-1$
				+ "in the shop tomorrow", this.realiser.realise(temp2) //$NON-NLS-1$
				.getRealisation());
	}

	/**
	 * Tests for gerund forms and genitive subjects.
	 */
	@Test
	public void testGerundsubject() {

		// the man's giving the woman John's flower upset Peter
		SPhraseSpec _s4 = this.phraseFactory.createClause();
		_s4.setVerbPhrase(this.phraseFactory
				.createVerbPhrase("upset")); //$NON-NLS-1$
		_s4.setFeature(Feature.TENSE,Tense.PAST);
		_s4.setObject(this.phraseFactory.createNounPhrase("Peter")); //$NON-NLS-1$
		this.s3.setFeature(Feature.PERFECT, true);

		// set the sentence as subject of another: makes it a gerund
		_s4.setSubject(this.s3);

		// suppress the genitive realisation of the NP subject in gerund
		// sentences
		this.s3.setFeature(Feature.SUPPRESS_GENITIVE_IN_GERUND, true);

		// check the realisation: subject should not be genitive
		Assert.assertEquals(
				"the man having given the woman John's flower upset Peter", //$NON-NLS-1$
				this.realiser.realise(_s4).getRealisation());

	}

	/**
	 * Some tests for multiple embedded sentences.
	 */
	@Test
	public void testComplexSentence1() {
		setUp();
		// the man's giving the woman John's flower upset Peter
		SPhraseSpec complexS = this.phraseFactory.createClause();
		complexS.setVerbPhrase(this.phraseFactory.createVerbPhrase("upset")); //$NON-NLS-1$
		complexS.setFeature(Feature.TENSE,Tense.PAST);
		complexS.setObject(this.phraseFactory.createNounPhrase("Peter")); //$NON-NLS-1$
		this.s3.setFeature(Feature.PERFECT, true);
		complexS.setSubject( this.s3);

		// check the realisation: subject should be genitive
		Assert.assertEquals(
				"the man's having given the woman John's flower upset Peter", //$NON-NLS-1$
				this.realiser.realise(complexS).getRealisation());

		setUp();
		// coordinate sentences in subject position
		SPhraseSpec s5 = this.phraseFactory.createClause();
		s5.setSubject( this.phraseFactory
				.createNounPhrase("some", "person")); //$NON-NLS-1$ //$NON-NLS-2$
		s5.setVerbPhrase(this.phraseFactory.createVerbPhrase("stroke")); //$NON-NLS-1$
		s5.setObject(this.phraseFactory.createNounPhrase("the", "cat")); //$NON-NLS-1$ //$NON-NLS-2$

		CoordinatedPhraseElement coord = phraseFactory.createCoordinatedPhrase(this.s3,
				s5);
		complexS = this.phraseFactory.createClause();
		complexS.setVerbPhrase(this.phraseFactory.createVerbPhrase("upset")); //$NON-NLS-1$
		complexS.setFeature(Feature.TENSE,Tense.PAST);
		complexS.setObject(this.phraseFactory.createNounPhrase("Peter")); //$NON-NLS-1$
		complexS.setSubject(coord);
		this.s3.setFeature(Feature.PERFECT, true);

		Assert.assertEquals("the man's having given the woman John's flower " //$NON-NLS-1$
				+ "and some person's stroking the cat upset Peter", //$NON-NLS-1$
				this.realiser.realise(complexS).getRealisation());

		setUp();
		// now subordinate the complex sentence
		// coord.setClauseStatus(SPhraseSpec.ClauseType.MAIN);
		SPhraseSpec s6 = this.phraseFactory.createClause();
		s6.setVerbPhrase(this.phraseFactory.createVerbPhrase("tell")); //$NON-NLS-1$
		s6.setFeature(Feature.TENSE,Tense.PAST);
		s6.setSubject(this.phraseFactory
				.createNounPhrase("the", "boy")); //$NON-NLS-1$ //$NON-NLS-2$
		// ER - switched indirect and direct object
		PhraseElement indirect = this.phraseFactory.createNounPhrase("every", //$NON-NLS-1$
				"girl"); //$NON-NLS-1$
		s6.setIndirectObject(indirect);
		complexS = this.phraseFactory.createClause();
		complexS.setVerbPhrase(this.phraseFactory.createVerbPhrase("upset")); //$NON-NLS-1$
		complexS.setFeature(Feature.TENSE,Tense.PAST);
		complexS.setObject(this.phraseFactory.createNounPhrase("Peter")); //$NON-NLS-1$
		s6.setObject(complexS);
		coord = phraseFactory.createCoordinatedPhrase(this.s3, s5);
		complexS.setSubject(coord);
		this.s3.setFeature(Feature.PERFECT, true);
		Assert.assertEquals(
				"the boy told every girl that the man's having given the woman " //$NON-NLS-1$
						+ "John's flower and some person's stroking the cat " //$NON-NLS-1$
						+ "upset Peter", //$NON-NLS-1$
				this.realiser.realise(s6).getRealisation());

	}

	/**
	 * More coordination tests.
	 */
	@Test
	public void testComplexSentence3() {
		setUp();

		this.s1 = this.phraseFactory.createClause();
		this.s1.setSubject(this.woman);
		this.s1.setVerb("kiss");
		this.s1.setObject(this.man);

		PhraseElement _man = this.phraseFactory.createNounPhrase("the", "man"); //$NON-NLS-1$ //$NON-NLS-2$
		this.s3 = this.phraseFactory.createClause();
		this.s3.setSubject(_man);
		this.s3.setVerb("give");

		NPPhraseSpec flower = this.phraseFactory.createNounPhrase("flower"); //$NON-NLS-1$
		NPPhraseSpec john = this.phraseFactory.createNounPhrase("John"); //$NON-NLS-1$
		john.setFeature(Feature.POSSESSIVE, true);
		flower.setSpecifier(john);
		this.s3.setObject(flower);

		PhraseElement _woman = this.phraseFactory.createNounPhrase(
				"the", "woman"); //$NON-NLS-1$ //$NON-NLS-2$
		this.s3.setIndirectObject(_woman);

		// the coordinate sentence allows us to raise and lower complementiser
		CoordinatedPhraseElement coord2 = phraseFactory.createCoordinatedPhrase(this.s1,
				this.s3);
		coord2.setFeature(Feature.TENSE,Tense.PAST);

		this.realiser.setDebugMode(true);
		Assert
				.assertEquals(
						"the woman kissed the man and the man gave the woman John's flower", //$NON-NLS-1$
						this.realiser.realise(coord2).getRealisation());
	}

	/**
	 * Tests recogition of strings in API.
	 */
	@Test
	public void testStringRecognition() {

		// test recognition of forms of "be"
		PhraseElement _s1 = this.phraseFactory.createClause(
				"my cat", "be", "sad"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		Assert.assertEquals(
				"my cat is sad", this.realiser.realise(_s1).getRealisation()); //$NON-NLS-1$

		// test recognition of pronoun for afreement
		PhraseElement _s2 = this.phraseFactory
				.createClause("I", "want", "Mary"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		Assert.assertEquals(
				"I want Mary", this.realiser.realise(_s2).getRealisation()); //$NON-NLS-1$

		// test recognition of pronoun for correct form
		PhraseElement subject = this.phraseFactory.createNounPhrase("dog"); //$NON-NLS-1$
		subject.setFeature(InternalFeature.SPECIFIER, "a"); //$NON-NLS-1$
		subject.addPostModifier("from next door"); //$NON-NLS-1$
		PhraseElement object = this.phraseFactory.createNounPhrase("I"); //$NON-NLS-1$
		PhraseElement s = this.phraseFactory.createClause(subject,
				"chase", object); //$NON-NLS-1$
		s.setFeature(Feature.PROGRESSIVE, true);
		Assert.assertEquals("a dog from next door is chasing me", //$NON-NLS-1$
				this.realiser.realise(s).getRealisation());
	}

	/**
	 * Tests complex agreement.
	 */
	@Test
	public void testAgreement() {

		// basic agreement
		NPPhraseSpec np = this.phraseFactory.createNounPhrase("dog"); //$NON-NLS-1$
		np.setSpecifier("the"); //$NON-NLS-1$
		np.addPreModifier("angry"); //$NON-NLS-1$
		PhraseElement _s1 = this.phraseFactory
				.createClause(np, "chase", "John"); //$NON-NLS-1$ //$NON-NLS-2$
		Assert.assertEquals("the angry dog chases John", this.realiser //$NON-NLS-1$
				.realise(_s1).getRealisation());

		// plural
		np = this.phraseFactory.createNounPhrase("dog"); //$NON-NLS-1$
		np.setSpecifier( "the"); //$NON-NLS-1$
		np.addPreModifier("angry"); //$NON-NLS-1$
		np.setFeature(Feature.NUMBER, NumberAgreement.PLURAL);
		_s1 = this.phraseFactory.createClause(np, "chase", "John"); //$NON-NLS-1$ //$NON-NLS-2$
		Assert.assertEquals("the angry dogs chase John", this.realiser //$NON-NLS-1$
				.realise(_s1).getRealisation());

		// test agreement with "there is"
		np = this.phraseFactory.createNounPhrase("dog"); //$NON-NLS-1$
		np.addPreModifier("angry"); //$NON-NLS-1$
		np.setFeature(Feature.NUMBER, NumberAgreement.SINGULAR);
		np.setSpecifier("a"); //$NON-NLS-1$
		PhraseElement _s2 = this.phraseFactory.createClause("there", "be", np); //$NON-NLS-1$ //$NON-NLS-2$
		Assert.assertEquals("there is an angry dog", this.realiser //$NON-NLS-1$
				.realise(_s2).getRealisation());

		// plural with "there"
		np = this.phraseFactory.createNounPhrase("dog"); //$NON-NLS-1$
		np.addPreModifier("angry"); //$NON-NLS-1$
		np.setSpecifier("a"); //$NON-NLS-1$
		np.setFeature(Feature.NUMBER, NumberAgreement.PLURAL);
		_s2 = this.phraseFactory.createClause("there", "be", np); //$NON-NLS-1$ //$NON-NLS-2$
		Assert.assertEquals("there are some angry dogs", this.realiser //$NON-NLS-1$
				.realise(_s2).getRealisation());
	}

	/**
	 * Tests passive.
	 */
	@Test
	public void testPassive() {
		// passive with just complement
		SPhraseSpec _s1 = this.phraseFactory.createClause(null,
				"intubate", this.phraseFactory.createNounPhrase("the", "baby")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		_s1.setFeature(Feature.PASSIVE, true);

		Assert.assertEquals("the baby is intubated", this.realiser //$NON-NLS-1$
				.realise(_s1).getRealisation());

		// passive with subject and complement
		_s1 = this.phraseFactory.createClause(null,
				"intubate", this.phraseFactory.createNounPhrase("the", "baby")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		_s1.setSubject(this.phraseFactory
				.createNounPhrase("the nurse")); //$NON-NLS-1$
		_s1.setFeature(Feature.PASSIVE, true);
		Assert.assertEquals("the baby is intubated by the nurse", //$NON-NLS-1$
				this.realiser.realise(_s1).getRealisation());

		// passive with subject and indirect object
		SPhraseSpec _s2 = this.phraseFactory.createClause(null, "give", //$NON-NLS-1$
				this.phraseFactory.createNounPhrase("the", "baby")); //$NON-NLS-1$ //$NON-NLS-2$

		PhraseElement morphine = this.phraseFactory
				.createNounPhrase("50ug of morphine"); //$NON-NLS-1$
		_s2.setIndirectObject(morphine);
		_s2.setFeature(Feature.PASSIVE, true);
		Assert.assertEquals("the baby is given 50ug of morphine", //$NON-NLS-1$
				this.realiser.realise(_s2).getRealisation());

		// passive with subject, complement and indirect object
		_s2 = this.phraseFactory.createClause(this.phraseFactory
				.createNounPhrase("the", "nurse"), "give", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
				this.phraseFactory.createNounPhrase("the", "baby")); //$NON-NLS-1$ //$NON-NLS-2$

		morphine = this.phraseFactory.createNounPhrase("50ug of morphine"); //$NON-NLS-1$
		_s2.setIndirectObject(morphine);
		_s2.setFeature(Feature.PASSIVE, true);
		Assert.assertEquals("the baby is given 50ug of morphine by the nurse", //$NON-NLS-1$
				this.realiser.realise(_s2).getRealisation());

		// test agreement in passive
		PhraseElement _s3 = this.phraseFactory.createClause(
				phraseFactory.createCoordinatedPhrase("my dog", "your cat"), "chase", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
				"George"); //$NON-NLS-1$
		_s3.setFeature(Feature.TENSE,Tense.PAST);
		_s3.addFrontModifier("yesterday"); //$NON-NLS-1$
		Assert.assertEquals("yesterday my dog and your cat chased George", //$NON-NLS-1$
				this.realiser.realise(_s3).getRealisation());

		_s3 = this.phraseFactory.createClause(phraseFactory.createCoordinatedPhrase(
				"my dog", "your cat"), "chase", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
				this.phraseFactory.createNounPhrase("George")); //$NON-NLS-1$
		_s3.setFeature(Feature.TENSE,Tense.PAST);
		_s3.addFrontModifier("yesterday"); //$NON-NLS-1$
		_s3.setFeature(Feature.PASSIVE, true);
		Assert.assertEquals(
				"yesterday George was chased by my dog and your cat", //$NON-NLS-1$
				this.realiser.realise(_s3).getRealisation());

		// test correct pronoun forms
		PhraseElement _s4 = this.phraseFactory.createClause(this.phraseFactory
				.createNounPhrase("he"), "chase", //$NON-NLS-1$ //$NON-NLS-2$
				this.phraseFactory.createNounPhrase("I")); //$NON-NLS-1$
		Assert.assertEquals("he chases me", this.realiser.realise(_s4) //$NON-NLS-1$
				.getRealisation());
		_s4 = this.phraseFactory
				.createClause(
						this.phraseFactory.createNounPhrase("he"), "chase", this.phraseFactory.createNounPhrase("me")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		_s4.setFeature(Feature.PASSIVE, true);
		Assert
				.assertEquals(
						"I am chased by him", this.realiser.realise(_s4).getRealisation()); //$NON-NLS-1$

		// same thing, but giving the S constructor "me". Should recognise
		// correct pro
		// anyway
		PhraseElement _s5 = this.phraseFactory
				.createClause("him", "chase", "I"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		Assert.assertEquals(
				"he chases me", this.realiser.realise(_s5).getRealisation()); //$NON-NLS-1$

		_s5 = this.phraseFactory.createClause("him", "chase", "I"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		_s5.setFeature(Feature.PASSIVE, true);
		Assert
				.assertEquals(
						"I am chased by him", this.realiser.realise(_s5).getRealisation()); //$NON-NLS-1$

	}

	/**
	 * Tests tenses with modals.
	 */
	public void testModal() {

		setUp();
		// simple modal in present tense
		this.s3.setFeature(Feature.MODAL, "should"); //$NON-NLS-1$
		Assert.assertEquals("the man should give the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		// modal + future -- uses present
		setUp();
		this.s3.setFeature(Feature.MODAL, "should"); //$NON-NLS-1$
		this.s3.setFeature(Feature.TENSE,Tense.FUTURE);
		Assert.assertEquals("the man should give the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		// modal + present progressive
		setUp();
		this.s3.setFeature(Feature.MODAL, "should"); //$NON-NLS-1$
		this.s3.setFeature(Feature.TENSE,Tense.FUTURE);
		this.s3.setFeature(Feature.PROGRESSIVE, true);
		Assert.assertEquals(
				"the man should be giving the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		// modal + past tense
		setUp();
		this.s3.setFeature(Feature.MODAL, "should"); //$NON-NLS-1$
		this.s3.setFeature(Feature.TENSE,Tense.PAST);
		Assert.assertEquals(
				"the man should have given the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

		// modal + past progressive
		setUp();
		this.s3.setFeature(Feature.MODAL, "should"); //$NON-NLS-1$
		this.s3.setFeature(Feature.TENSE,Tense.PAST);
		this.s3.setFeature(Feature.PROGRESSIVE, true);
		
		Assert.assertEquals(
				"the man should have been giving the woman John's flower", //$NON-NLS-1$
				this.realiser.realise(this.s3).getRealisation());

	}
	

}
