git.gag.com Git - debian/freetts/blob - tests/UtteranceTests.java

   1 /**
   2  * Copyright 2001 Sun Microsystems, Inc.
   3  *
   4  * See the file "license.terms" for information on usage and
   5  * redistribution of this file, and for a DISCLAIMER OF ALL
   6  * WARRANTIES.
   7  */
   8 package tests;
   9 import junit.framework.*;
  10 import java.util.*;
  11 import java.io.*;
  12 import com.sun.speech.freetts.*;
  13
  14 /**
  15  * JUNIT Tests for the Utterance class
  16  *
  17  * @version 1.0
  18  */
  19 public class UtteranceTests extends TestCase {
  20     Voice voice;
  21     Utterance utterance;
  22
  23     /**
  24      * Creates the set of UtteranceTests
  25      *
  26      * @param  name the name of the test.
  27      */
  28     public UtteranceTests(String name) {
  29         super(name);
  30     }
  31
  32     /**
  33      * Common code run before each test
  34      */
  35     protected void setUp() {
  36         voice = VoiceManager.getInstance().getVoice("kevin");
  37         utterance = new Utterance(voice);
  38         List processors = voice.getUtteranceProcessors();
  39
  40         processors.add(new TestUtteranceProcessor("tokenizer"));
  41         processors.add(new TestUtteranceProcessor("tokentowords"));
  42         processors.add(new TestUtteranceProcessor("pauses"));
  43         processors.add(new TestUtteranceProcessor("intonation"));
  44
  45         voice.getFeatures().setString("testFeature1", "testFeatureValue1");
  46         voice.getFeatures().setString("sillyText", "how now brown cowboy!");
  47         voice.getFeatures().setString("knock knock", "Who is there?");
  48
  49         utterance.setString("uttFeature1", "this is utt feature 1");
  50         utterance.setString("whitespace", "_+_+_+_+_+_+_");
  51         utterance.setString("blackspace", "####@#@#@@");
  52         utterance.setString("inputText", "How now brown cow");
  53
  54         Relation tokens = utterance.createRelation("tokens");
  55         StringTokenizer tok = new StringTokenizer(
  56                   "January 1st 2001 How now brown cow "
  57                 + " it's a far far better thing I do now than I've ever"
  58                 + "done before");
  59
  60         while (tok.hasMoreTokens()) {
  61             String token = tok.nextToken();
  62             Item newItem = tokens.appendItem();
  63             newItem.getFeatures().setString("name", token);
  64             newItem.getFeatures().setString("punc", "");
  65             newItem.getFeatures().setString("stress", "1");
  66         }
  67
  68         Relation words = utterance.createRelation("Words");
  69
  70
  71         for (Item item = tokens.getHead();
  72                         item != null; item = item.getNext()) {
  73             if (item.getFeatures().getString("name").equals("2001")) {
  74
  75                 Item word1 = item.createDaughter();
  76                 word1.getFeatures().setString("name", "two");
  77                 words.appendItem(word1);
  78
  79                 Item word2 = item.createDaughter();
  80                 word2.getFeatures().setString("name", "thousand");
  81                 words.appendItem(word2);
  82
  83                 Item word3 = item.createDaughter();
  84                 word3.getFeatures().setString("name", "one");
  85                 words.appendItem(word3);
  86
  87             } else {
  88                 Item word = item.createDaughter();
  89                 word.getFeatures().setString("name",
  90                         item.getFeatures().getString("name").toLowerCase());
  91                 words.appendItem(word);
  92             }
  93         }
  94
  95         wordSylSeg(utterance);
  96     }
  97
  98     /**
  99      * Populates an utterance with the word/syl/seg relations
 100      *
 101      * @param u the utterance
 102      */
 103     private void wordSylSeg(Utterance u) {
 104         Relation syl = u.createRelation("Syllable");
 105         Relation sylStructure = u.createRelation("SylStructure");
 106         Relation seg = u.createRelation("Segment");
 107
 108         for (Item word = u.getRelation("Words").getHead();
 109                         word != null; word = word.getNext()) {
 110             Item ssword = sylStructure.appendItem(word);
 111             List phones = lookup(word.getFeatures().getString("name"));
 112             for (Iterator pi = phones.iterator(); pi.hasNext(); ) {
 113                 Item segitem = seg.appendItem();
 114                 segitem.getFeatures().setString("name", (String) pi.next());
 115                 ssword.addDaughter(segitem);
 116             }
 117         }
 118     }
 119
 120     /**
 121      * Breaks a word into characters
 122      *
 123      * @param word the word
 124      *
 125      * @return list of single character strings
 126      */
 127     private List lookup(String word) {
 128         List l = new ArrayList();
 129
 130         for (int i = 0; i < word.length(); i++) {
 131             String ph = word.substring(i, i + 1);
 132             l.add(ph);
 133         }
 134         return l;
 135     }
 136
 137     /**
 138      * Test feature traversal behavior
 139      */
 140     public void testFeature1() {
 141         assertTrue("syl exist", utterance.getRelation("Syllable") != null);
 142         assertTrue("syls exist", utterance.getRelation("SylStructure") != null);
 143         assertTrue("segment exists", utterance.getRelation("Segment") != null);
 144         Item item = utterance.getRelation("Segment").getHead();
 145         item = item.getNext();
 146         item = item.getNext();
 147         item = item.getNext();
 148
 149         // we should be at the 'u' in january
 150         assertTrue("name",
 151                 item.findFeature("name").toString().equals("u"));
 152         assertTrue("n.name",
 153                 item.findFeature("n.name").toString().equals("a"));
 154         assertTrue("p.name",
 155                 item.findFeature("p.name").toString().equals("n"));
 156         assertTrue("R:SylStructure.parent",
 157                 item.findItem("R:SylStructure").toString().equals("u"));
 158         assertTrue("R:SylStructure.parent",
 159                 item.findItem("R:SylStructure.parent").
 160                 toString().equals("january"));
 161         assertTrue("R:SylStructure.parent.name",
 162                 item.findFeature("R:SylStructure.parent.name").toString()
 163                 .equals("january"));
 164         assertTrue("R:SylStructure.parent.n",
 165                 item.findItem("R:SylStructure.parent.n").toString()
 166                 .equals("1st"));
 167
 168         Item token = utterance.getRelation("tokens").getHead();
 169         assertTrue("token head", token.toString().equals("January"));
 170         assertTrue("n.n.name",
 171                 token.findFeature("n.n.name").toString().equals("2001"));
 172         assertTrue("n.n.daughter.name",
 173                 token.findFeature("n.n.daughter.name").
 174                 toString().equals("two"));
 175         assertTrue("n.n.daughter.n.name",
 176                 token.findFeature("n.n.daughter.n.name").
 177                 toString().equals("thousand"));
 178         assertTrue("n.n.daughtern.name",
 179                 token.findFeature("n.n.daughtern.name").
 180                 toString().equals("one"));
 181     }
 182
 183
 184
 185     /**
 186      * Common code run after each test
 187      */
 188     protected void tearDown() {
 189         //utterance = null;
 190     }
 191
 192
 193     /**
 194      * Tests to see that we succeed
 195      */
 196     public void testSuccess() {
 197         assertTrue("Should succeed", true);
 198     }
 199
 200     /**
 201      * Tests to ensure that an utterance is created properly
 202      */
 203     public void testUtteranceCreation() {
 204         assertTrue("Utterance Created", utterance != null);
 205         assertTrue("retrieved proper voice", utterance.getVoice() == voice);
 206     }
 207
 208     /**
 209      * Tests the utterance relations capabilities
 210      */
 211     public void testUtteranceRelations() {
 212         assertTrue("Utterance Created", utterance != null);
 213         Relation tokens = utterance.createRelation("tokens");
 214         assertTrue("retrieved token relation missing",
 215                 utterance.getRelation("tokens") == tokens);
 216         assertTrue("token relation missing",
 217                 utterance.hasRelation("tokens"));
 218         assertTrue("missing relation found",
 219                 !utterance.hasRelation("missing_relation"));
 220         assertTrue("retrieved missing token relation found",
 221                 utterance.getRelation("missing_relation") == null);
 222     }
 223
 224     /**
 225      * Tests the utterance features capabilities
 226      */
 227     public void testUtteranceFeatures() {
 228         assertTrue("Utterance Created", utterance != null);
 229         assertTrue("Missing feature found", !utterance.isPresent("not_present"));
 230         utterance.setString("is_present", "here I am");
 231         assertTrue("presnt feature found", utterance.isPresent("is_present"));
 232         assertTrue("present feature retreived",
 233                 utterance.getString("is_present").equals("here I am"));
 234         assertTrue("missing voice feature found",
 235                 !utterance.isPresent("voice_feature"));
 236         voice.getFeatures().setString("voice_feature", "is_set");
 237         assertTrue("voice feature missing",
 238                 voice.getFeatures().isPresent("voice_feature"));
 239         assertTrue("voice feature missing",
 240                 utterance.isPresent("voice_feature"));
 241         assertTrue("voice present feature retreived",
 242                 utterance.getString("voice_feature").equals("is_set"));
 243
 244         utterance.setFloat("pi", (float) Math.PI);
 245         assertTrue("float get", utterance.getFloat("pi") == (float) Math.PI);
 246
 247         utterance.setInt("one", 1);
 248         assertTrue("int get", utterance.getInt("one") == 1);
 249         Object o = new Object();
 250         utterance.setObject("object", o);
 251         assertTrue("object get", utterance.getObject("object") == o);
 252
 253         try {
 254             utterance.getFloat("one");
 255             assertTrue("Cast exception mission", false);
 256         } catch (ClassCastException e) {
 257             assertTrue("cast error OK", true);
 258         }
 259         utterance.remove("one");
 260         assertTrue("removed  feature found", !utterance.isPresent("one"));
 261     }
 262
 263
 264     /**
 265      * Tests the detailed relations capabilities
 266      */
 267     public void testRelations() {
 268         int index = 0;;
 269         int testSize = 10;
 270         Item[] items = new Item[testSize];
 271         Relation r = utterance.createRelation("itemTests");
 272         for (int i = 0; i < testSize; i++) {
 273             items[i] = r.appendItem();
 274         }
 275
 276         assertTrue("utterance OK", r.getUtterance() == utterance);
 277         assertTrue("Name ok", r.getName().equals("itemTests"));
 278
 279         index = 0;
 280         for (Item item = r.getHead(); item != null;
 281                         item = item.getNext(), index++) {
 282             assertTrue("Proper items", items[index] == item);
 283         }
 284
 285         assertTrue("Items not equal", !items[0].getSharedContents().equals(
 286                                         items[1].getSharedContents()));
 287         Item dup  = r.appendItem();
 288         Item dup2 = r.appendItem(dup);
 289         assertTrue("Items should be equal", dup.getSharedContents().equals(
 290                                             dup2.getSharedContents()));
 291     }
 292
 293     /**
 294      * Tests the Item class capabilities
 295      */
 296     public void testItems() {
 297         Relation r = utterance.createRelation("tokens");
 298         Relation r2 = utterance.createRelation("words");
 299         Item parent  = r.appendItem();
 300         Item i2 = r.appendItem();
 301         Item dup2 = r.appendItem(i2);
 302         Item d1 = parent.createDaughter();
 303         Item d2 = parent.createDaughter();
 304         Item d3 = parent.createDaughter();
 305
 306         assertTrue("dup equals",
 307                 dup2.getSharedContents().equals(i2.getSharedContents()));
 308         assertTrue("parent check 1", d1.getParent() == parent);
 309         assertTrue("parent check 2", d2.getParent() == parent);
 310         assertTrue("parent check 3", d3.getParent() == parent);
 311
 312         //assertTrue("daugher size", parent.getDaughters().size() == 3);
 313         assertTrue("first daughter", parent.getDaughter() == d1);
 314         assertTrue("second daughter", parent.getNthDaughter(1) == d2);
 315         assertTrue("Last daughter", parent.getLastDaughter() == d3);
 316
 317         assertTrue("owner", parent.getOwnerRelation() == r);
 318
 319         Item r2i1 = r2.appendItem();
 320         assertTrue("owner r2i1", r2i1.getOwnerRelation() == r2);
 321
 322         Item r1i1 = r.appendItem(r2i1);
 323         assertTrue("r1,r2 equal",
 324                 r1i1.getSharedContents().equals(r2i1.getSharedContents()));
 325         assertTrue("owner r2i1 reprise", r2i1.getOwnerRelation() == r2);
 326         assertTrue("owner r1i1 ", r1i1.getOwnerRelation() == r);
 327         assertTrue("no parent", r2i1.getParent() == null);
 328         assertTrue("r1i1 no daughters", !r1i1.hasDaughters());
 329         assertTrue("r1i1 utterance", r1i1.getUtterance() == utterance);
 330
 331       // test the feature capability
 332         assertTrue("Missing feature found",
 333                 !r1i1.getFeatures().isPresent("not_present"));
 334         r1i1.getFeatures().setString("is_present", "here I am");
 335         assertTrue("presnt feature found",
 336                 r1i1.getFeatures().isPresent("is_present"));
 337         assertTrue("present feature retreived",
 338                 r1i1.getFeatures().getString("is_present").equals("here I am"));
 339         assertTrue("missing voice feature found",
 340                 !r1i1.getFeatures().isPresent("voice_feature"));
 341
 342         r1i1.getFeatures().setFloat("pi", (float) Math.PI);
 343         assertTrue("float get",
 344                 r1i1.getFeatures().getFloat("pi") == (float) Math.PI);
 345         assertTrue("float get r2",
 346                 r2i1.getFeatures().getFloat("pi") == (float) Math.PI);
 347
 348         r1i1.getFeatures().setInt("one", 1);
 349         assertTrue("int get", r1i1.getFeatures().getInt("one") == 1);
 350         Object o = new Object();
 351         r1i1.getFeatures().setObject("object", o);
 352         assertTrue("object get", r1i1.getFeatures().getObject("object") == o);
 353         assertTrue("object get r2", r2i1.getFeatures().getObject("object") == o);
 354
 355         try {
 356             r1i1.getFeatures().getFloat("one");
 357             assertTrue("Cast exception mission", false);
 358         } catch (ClassCastException e) {
 359             assertTrue("cast error OK", true);
 360         }
 361         r1i1.getFeatures().remove("one");
 362         assertTrue("removed  feature found", !r1i1.getFeatures().isPresent("one"));
 363     }
 364
 365
 366     /**
 367      * Factory method that creates the test suite.
 368      *
 369      * @return the test suite.
 370      */
 371     public static Test suite() {
 372         return new TestSuite(UtteranceTests.class);
 373     }
 374
 375
 376
 377     /**
 378      * Main entry point for this test suite.
 379      *
 380      * @param  args    the command line arguments.
 381      */
 382     public static void main(String[] args) {
 383         junit.textui.TestRunner.run(suite());
 384     }
 385 }
 386
 387
 388
 389 /**
 390  * A test utterance processor
 391  */
 392 class TestUtteranceProcessor implements UtteranceProcessor {
 393     String name;
 394     public TestUtteranceProcessor(String name) {
 395         this.name = name;
 396     }
 397
 398     public void processUtterance(Utterance u) throws ProcessException {
 399         System.out.println("Processing " + name);
 400     }
 401
 402     public String toString() {
 403         return name;
 404     }
 405 }
 406
 407