/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.cas.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringReader;
import java.io.StringWriter;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import junit.framework.TestCase;
import org.apache.uima.cas.BooleanArrayFS;
import org.apache.uima.cas.ByteArrayFS;
import org.apache.uima.cas.CAS;
import org.apache.uima.cas.DoubleArrayFS;
import org.apache.uima.cas.FSIndex;
import org.apache.uima.cas.FSIterator;
import org.apache.uima.cas.Feature;
import org.apache.uima.cas.FloatArrayFS;
import org.apache.uima.cas.IntArrayFS;
import org.apache.uima.cas.LongArrayFS;
import org.apache.uima.cas.ShortArrayFS;
import org.apache.uima.cas.StringArrayFS;
import org.apache.uima.cas.Type;
import org.apache.uima.cas.admin.CASFactory;
import org.apache.uima.cas.admin.CASMgr;
import org.apache.uima.cas.admin.FSIndexComparator;
import org.apache.uima.cas.admin.FSIndexRepositoryMgr;
import org.apache.uima.cas.admin.TypeSystemMgr;
import org.apache.uima.cas.impl.CASImpl;
import org.apache.uima.cas.impl.CASSerializer;
import org.apache.uima.cas.impl.FeatureStructureImplC;
import org.apache.uima.cas.impl.Serialization;
import org.apache.uima.cas.impl.XCASDeserializer;
import org.apache.uima.cas.impl.XCASSerializer;
import org.apache.uima.cas.impl.XmiCasDeserializer;
import org.apache.uima.cas.impl.XmiCasSerializer;
import org.apache.uima.cas.text.AnnotationFS;
import org.apache.uima.resource.metadata.TypeSystemDescription;
import org.apache.uima.test.junit_extension.JUnitExtension;
import org.apache.uima.util.CasCreationUtils;
import org.apache.uima.util.XMLSerializer;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
public class NewPrimitiveTypesTest extends TestCase {
private CASMgr casMgr;
private CAS cas;
private Type annotationType;
private Type exampleType;
private Feature floatFeature;
private Feature stringFeature;
private Feature byteFeature;
private Feature booleanFeature;
private Feature shortFeature;
private Feature longFeature;
private Feature doubleFeature;
private Feature intArrayFeature;
private Feature floatArrayFeature;
private Feature stringArrayFeature;
private Feature byteArrayFeature;
private Feature booleanArrayFeature;
private Feature shortArrayFeature;
private Feature longArrayFeature;
private Feature doubleArrayFeature;
public NewPrimitiveTypesTest(String arg) {
super(arg);
}
/**
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception {
try {
super.setUp();
casMgr = CASFactory.createCAS();
CasCreationUtils.setupTypeSystem(casMgr, (TypeSystemDescription) null);
// Create a writable type system.
TypeSystemMgr tsa = casMgr.getTypeSystemMgr();
// Add new types and features.
annotationType = tsa.getType(CAS.TYPE_NAME_ANNOTATION);
assertTrue(annotationType != null);
// new primitive types
exampleType = tsa.addType("test.primitives.Example", annotationType);
floatFeature = tsa.addFeature("floatFeature", exampleType, tsa.getType(CAS.TYPE_NAME_FLOAT));
stringFeature = tsa.addFeature("stringFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_STRING));
booleanFeature = tsa.addFeature("boolFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_BOOLEAN));
byteFeature = tsa.addFeature("byteFeature", exampleType, tsa.getType(CAS.TYPE_NAME_BYTE));
shortFeature = tsa.addFeature("shortFeature", exampleType, tsa.getType(CAS.TYPE_NAME_SHORT));
longFeature = tsa.addFeature("longFeature", exampleType, tsa.getType(CAS.TYPE_NAME_LONG));
doubleFeature = tsa.addFeature("doubleFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_DOUBLE));
intArrayFeature = tsa.addFeature("intArrayFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_INTEGER_ARRAY));
floatArrayFeature = tsa.addFeature("floatArrayFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_FLOAT_ARRAY), false);
stringArrayFeature = tsa.addFeature("stringArrayFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_STRING_ARRAY), false);
booleanArrayFeature = tsa.addFeature("boolArrayFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_BOOLEAN_ARRAY));
byteArrayFeature = tsa.addFeature("byteArrayFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_BYTE_ARRAY), false);
shortArrayFeature = tsa.addFeature("shortArrayFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_SHORT_ARRAY));
longArrayFeature = tsa.addFeature("longArrayFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_LONG_ARRAY));
doubleArrayFeature = tsa.addFeature("doubleArrayFeature", exampleType, tsa
.getType(CAS.TYPE_NAME_DOUBLE_ARRAY), false);
// Commit the type system.
((CASImpl) casMgr).commitTypeSystem();
// Create the Base indexes.
casMgr.initCASIndexes();
// create custom indexes to test new primitive keys
FSIndexRepositoryMgr irm = casMgr.getIndexRepositoryMgr();
FSIndexComparator comp = irm.createComparator();
comp.setType(tsa.getType("test.primitives.Example"));
comp.addKey(tsa.getFeatureByFullName("test.primitives.Example:doubleFeature"),
FSIndexComparator.STANDARD_COMPARE);
irm.createIndex(comp, "doubleIndex");
comp = irm.createComparator();
comp.setType(tsa.getType("test.primitives.Example"));
comp.addKey(tsa.getFeatureByFullName("test.primitives.Example:longFeature"),
FSIndexComparator.REVERSE_STANDARD_COMPARE);
irm.createIndex(comp, "longIndex");
comp = irm.createComparator();
comp.setType(tsa.getType("test.primitives.Example"));
comp.addKey(tsa.getFeatureByFullName("test.primitives.Example:shortFeature"),
FSIndexComparator.STANDARD_COMPARE);
irm.createIndex(comp, "shortIndex");
irm.commit();
cas = casMgr.getCAS().getView(CAS.NAME_DEFAULT_SOFA);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testCreateFS() throws Exception {
// create FS
createExampleFS(cas);
// check values
validateFSData(cas);
}
public void testBlobSerialization() throws Exception {
// create FS
createExampleFS(cas);
// serialize
ByteArrayOutputStream fos = new ByteArrayOutputStream();
Serialization.serializeCAS(cas, fos);
// reset
cas.reset();
// deserialize
ByteArrayInputStream fis = new ByteArrayInputStream(fos.toByteArray());
Serialization.deserializeCAS(cas, fis);
// check values
validateFSData(cas);
}
public void testJavaSerialization() throws Exception {
// create FS
createExampleFS(cas);
// serialize
CASSerializer cs = Serialization.serializeNoMetaData(cas);
// reset
cas.reset();
// deserialize
cas = Serialization.createCAS(casMgr, cs);
// check values
validateFSData(cas);
}
public void testXCASSerialization() throws Exception {
// create FS
createExampleFS(cas);
// serialize
XCASSerializer ser = new XCASSerializer(cas.getTypeSystem());
OutputStream outputXCAS = new FileOutputStream(JUnitExtension
.getFile("ExampleCas/newprimitives.xcas"));
XMLSerializer xmlSer = new XMLSerializer(outputXCAS);
ser.serialize(cas, xmlSer.getContentHandler());
// reset
cas.reset();
// deserialize
InputStream inputXCAS = new FileInputStream(JUnitExtension
.getFile("ExampleCas/newprimitives.xcas"));
XCASDeserializer.deserialize(inputXCAS, cas, false);
// check values
validateFSData(cas);
}
public void testXmiSerialization() throws Exception {
// create FS
createExampleFS(cas);
// serialize
StringWriter sw = new StringWriter();
XMLSerializer xmlSer = new XMLSerializer(sw, false);
XmiCasSerializer xmiSer = new XmiCasSerializer(cas.getTypeSystem());
xmiSer.serialize(cas, xmlSer.getContentHandler());
String xml = sw.getBuffer().toString();
// System.out.println(xml);
// reset
cas.reset();
// deserialize
XmiCasDeserializer deser = new XmiCasDeserializer(cas.getTypeSystem());
ContentHandler deserHandler = deser.getXmiCasHandler(cas);
SAXParserFactory fact = SAXParserFactory.newInstance();
SAXParser parser = fact.newSAXParser();
XMLReader xmlReader = parser.getXMLReader();
xmlReader.setContentHandler(deserHandler);
xmlReader.parse(new InputSource(new StringReader(xml)));
// check values
validateFSData(cas);
}
public void testFSPrettyPrint() throws Exception {
// create FS
createExampleFS(cas);
// prettyPrint
CAS englishView = cas.getView("EnglishDocument");
assertNotNull(englishView);
assertNotNull(englishView.getSofa());
FSIndex index = englishView.getAnnotationIndex();
FSIterator iter = index.iterator();
// skip document annotation
AnnotationFS fs = (AnnotationFS) iter.get();
iter.moveToNext();
// the exampleType fs
fs = (AnnotationFS) iter.get();
FeatureStructureImplC fsImpl = (FeatureStructureImplC) fs;
StringBuffer sb = new StringBuffer(1024);
fsImpl.prettyPrint(2, 1, sb, true);
// System.out.println(sb.toString());
}
public void testClone() throws Exception {
createExampleFS(cas);
// get the example FS
CAS englishView = cas.getView("EnglishDocument");
FSIterator iter = englishView.getAnnotationIndex().iterator();
// skip document annotation
iter.moveToNext();
// the exampleType fs
AnnotationFS fs = (AnnotationFS) iter.get();
// clone it
AnnotationFS clone = (AnnotationFS) fs.clone();
// subsitute the clone for the original in the index,
// and validate that it was correctly copied
englishView.removeFsFromIndexes(fs);
englishView.addFsToIndexes(clone);
validateFSData(cas);
// editing the original FS should not change the clone
fs.setStringValue(stringFeature, "foo");
fs.setFloatValue(floatFeature, -1f);
fs.setByteValue(byteFeature, (byte) -1);
fs.setBooleanValue(booleanFeature, false);
fs.setShortValue(shortFeature, (short) -1);
fs.setLongValue(longFeature, -1);
fs.setDoubleValue(doubleFeature, -1);
validateFSData(cas);
}
private void validateFSData(CAS parmCas) throws Exception {
CAS englishView = parmCas.getView("EnglishDocument");
assertNotNull(englishView);
assertNotNull(englishView.getSofa());
FSIndex index = englishView.getAnnotationIndex();
FSIterator iter = index.iterator();
// skip document annotation
AnnotationFS fs = (AnnotationFS) iter.get();
iter.moveToNext();
// the exampleType fs
fs = (AnnotationFS) iter.get();
// System.out.print(fs.toString());
// check the scalar values
assertTrue(1 == fs.getBegin());
assertTrue(5 == fs.getEnd());
assertTrue(fs.getStringValue(stringFeature).equals("aaaaaaa"));
assertTrue(fs.getFloatValue(floatFeature) == (float) 99.99);
assertTrue(fs.getByteValue(byteFeature) == (byte) 'z');
assertTrue(fs.getBooleanValue(booleanFeature) == true);
assertTrue(fs.getShortValue(shortFeature) == Short.MIN_VALUE);
assertTrue(fs.getLongValue(longFeature) == Long.MIN_VALUE);
assertTrue(fs.getDoubleValue(doubleFeature) == Double.MAX_VALUE);
// check the array values
StringArrayFS strArrayFS = (StringArrayFS) fs.getFeatureValue(stringArrayFeature);
assertTrue(strArrayFS.get(0).equals("zzzzzz"));
assertTrue(strArrayFS.get(1).equals("yyyyyy"));
assertTrue(strArrayFS.get(2).equals("xxxxxx"));
assertTrue(strArrayFS.get(3).equals("wwwwww"));
assertTrue(strArrayFS.get(4).equals("vvvvvv"));
IntArrayFS intArrayFS = (IntArrayFS) fs.getFeatureValue(intArrayFeature);
assertTrue(intArrayFS.get(0) == Integer.MAX_VALUE);
assertTrue(intArrayFS.get(1) == Integer.MAX_VALUE - 1);
assertTrue(intArrayFS.get(2) == 42);
assertTrue(intArrayFS.get(3) == Integer.MIN_VALUE + 1);
assertTrue(intArrayFS.get(4) == Integer.MIN_VALUE);
FloatArrayFS floatArrayFS = (FloatArrayFS) fs.getFeatureValue(floatArrayFeature);
assertTrue(floatArrayFS.get(0) == Float.MAX_VALUE);
assertTrue(floatArrayFS.get(1) == (float) (Float.MAX_VALUE / 1000.0));
assertTrue(floatArrayFS.get(2) == 42);
assertTrue(floatArrayFS.get(3) == (float) (Float.MIN_VALUE * 1000.0));
assertTrue(floatArrayFS.get(4) == Float.MIN_VALUE);
ByteArrayFS byteArrayFS = (ByteArrayFS) fs.getFeatureValue(byteArrayFeature);
assertTrue(byteArrayFS.get(0) == (byte) 8);
assertTrue(byteArrayFS.get(1) == (byte) 16);
assertTrue(byteArrayFS.get(2) == (byte) 64);
assertTrue(byteArrayFS.get(3) == (byte) 128);
assertTrue(byteArrayFS.get(4) == (byte) 255);
BooleanArrayFS boolArrayFS = (BooleanArrayFS) fs.getFeatureValue(booleanArrayFeature);
assertTrue(boolArrayFS.get(0));
assertTrue(!boolArrayFS.get(1));
assertTrue(boolArrayFS.get(2));
assertTrue(!boolArrayFS.get(3));
assertTrue(boolArrayFS.get(4));
ShortArrayFS shortArrayFS = (ShortArrayFS) fs.getFeatureValue(shortArrayFeature);
assertTrue(shortArrayFS.get(0) == Short.MAX_VALUE);
assertTrue(shortArrayFS.get(1) == Short.MAX_VALUE - 1);
assertTrue(shortArrayFS.get(2) == Short.MAX_VALUE - 2);
assertTrue(shortArrayFS.get(3) == Short.MAX_VALUE - 3);
assertTrue(shortArrayFS.get(4) == Short.MAX_VALUE - 4);
LongArrayFS longArrayFS = (LongArrayFS) fs.getFeatureValue(longArrayFeature);
assertTrue(longArrayFS.get(0) == Long.MAX_VALUE);
assertTrue(longArrayFS.get(1) == Long.MAX_VALUE - 1);
assertTrue(longArrayFS.get(2) == Long.MAX_VALUE - 2);
assertTrue(longArrayFS.get(3) == Long.MAX_VALUE - 3);
assertTrue(longArrayFS.get(4) == Long.MAX_VALUE - 4);
DoubleArrayFS doubleArrayFS = (DoubleArrayFS) fs.getFeatureValue(doubleArrayFeature);
assertTrue(doubleArrayFS.get(0) == Double.MAX_VALUE);
assertTrue(doubleArrayFS.get(1) == Double.MIN_VALUE);
assertTrue(doubleArrayFS.get(2) == Double.parseDouble("1.5555"));
assertTrue(doubleArrayFS.get(3) == Double.parseDouble("99.000000005"));
assertTrue(doubleArrayFS.get(4) == Double.parseDouble("4.44444444444444444"));
}
private void createExampleFS(CAS parmCas) throws Exception {
// Create a view
CAS englishView = parmCas.createView("EnglishDocument");
// Set the document text
englishView.setDocumentText("this beer is good");
// create an FS of exampleType and index it
AnnotationFS fs = englishView.createAnnotation(exampleType, 1, 5);
englishView.getIndexRepository().addFS(fs);
// create Array FSs
StringArrayFS strArrayFS = parmCas.createStringArrayFS(5);
strArrayFS.set(0, "zzzzzz");
strArrayFS.set(1, "yyyyyy");
strArrayFS.set(2, "xxxxxx");
strArrayFS.set(3, "wwwwww");
strArrayFS.set(4, "vvvvvv");
IntArrayFS intArrayFS = parmCas.createIntArrayFS(5);
intArrayFS.set(0, Integer.MAX_VALUE);
intArrayFS.set(1, Integer.MAX_VALUE - 1);
intArrayFS.set(2, 42);
intArrayFS.set(3, Integer.MIN_VALUE + 1);
intArrayFS.set(4, Integer.MIN_VALUE);
FloatArrayFS floatArrayFS = parmCas.createFloatArrayFS(5);
floatArrayFS.set(0, Float.MAX_VALUE);
floatArrayFS.set(1, (float) (Float.MAX_VALUE / 1000.0));
floatArrayFS.set(2, 42);
floatArrayFS.set(3, (float) (Float.MIN_VALUE * 1000.0));
floatArrayFS.set(4, Float.MIN_VALUE);
ByteArrayFS byteArrayFS = parmCas.createByteArrayFS(5);
byteArrayFS.set(0, (byte) 8);
byteArrayFS.set(1, (byte) 16);
byteArrayFS.set(2, (byte) 64);
byteArrayFS.set(3, (byte) 128);
byteArrayFS.set(4, (byte) 255);
BooleanArrayFS boolArrayFS = parmCas.createBooleanArrayFS(20);
boolean val = false;
for (int i = 0; i < 20; i++) {
boolArrayFS.set(i, val = !val);
}
ShortArrayFS shortArrayFS = parmCas.createShortArrayFS(5);
shortArrayFS.set(0, Short.MAX_VALUE);
shortArrayFS.set(1, (short) (Short.MAX_VALUE - 1));
shortArrayFS.set(2, (short) (Short.MAX_VALUE - 2));
shortArrayFS.set(3, (short) (Short.MAX_VALUE - 3));
shortArrayFS.set(4, (short) (Short.MAX_VALUE - 4));
LongArrayFS longArrayFS = parmCas.createLongArrayFS(5);
longArrayFS.set(0, Long.MAX_VALUE);
longArrayFS.set(1, Long.MAX_VALUE - 1);
longArrayFS.set(2, Long.MAX_VALUE - 2);
longArrayFS.set(3, Long.MAX_VALUE - 3);
longArrayFS.set(4, Long.MAX_VALUE - 4);
DoubleArrayFS doubleArrayFS = parmCas.createDoubleArrayFS(5);
doubleArrayFS.set(0, Double.MAX_VALUE);
doubleArrayFS.set(1, Double.MIN_VALUE);
doubleArrayFS.set(2, Double.parseDouble("1.5555"));
doubleArrayFS.set(3, Double.parseDouble("99.000000005"));
doubleArrayFS.set(4, Double.parseDouble("4.44444444444444444"));
// set features of fs
fs.setStringValue(stringFeature, "aaaaaaa");
fs.setFloatValue(floatFeature, (float) 99.99);
fs.setFeatureValue(intArrayFeature, intArrayFS);
fs.setFeatureValue(floatArrayFeature, floatArrayFS);
fs.setFeatureValue(stringArrayFeature, strArrayFS);
// fs.setByteValue(byteFeature, Byte.MAX_VALUE);
fs.setByteValue(byteFeature, (byte) 'z');
fs.setFeatureValue(byteArrayFeature, byteArrayFS);
fs.setBooleanValue(booleanFeature, true);
fs.setFeatureValue(booleanArrayFeature, boolArrayFS);
fs.setShortValue(shortFeature, Short.MIN_VALUE);
fs.setFeatureValue(shortArrayFeature, shortArrayFS);
fs.setLongValue(longFeature, Long.MIN_VALUE);
fs.setFeatureValue(longArrayFeature, longArrayFS);
fs.setDoubleValue(doubleFeature, Double.MAX_VALUE);
fs.setFeatureValue(doubleArrayFeature, doubleArrayFS);
}
public void testNewPrimitiveTypeKeys() throws Exception {
// Create FS with features set in reverse order
for (int i=0; i<5; i++) {
AnnotationFS fs = cas.createAnnotation(exampleType, 0, 0);
fs.setDoubleValue(doubleFeature, 5.0 - i );
fs.setLongValue(longFeature, (long)1+i );
fs.setShortValue(shortFeature, (short)(5 - i) );
cas.getIndexRepository().addFS(fs);
}
// test double as key
FSIterator iter = cas.getIndexRepository().getIndex("doubleIndex", exampleType).iterator();
// System.out.println("\nDouble");
for (int i=0; i<5; i++) {
AnnotationFS testfs = (AnnotationFS)iter.get();
// System.out.println("exampleType has double=" + testfs.getDoubleValue(doubleFeature)
// + " long=" + testfs.getLongValue(longFeature)
// + " short=" + testfs.getShortValue(shortFeature));
assertTrue(1+i == testfs.getDoubleValue(doubleFeature));
assertTrue(5-i == testfs.getLongValue(longFeature));
assertTrue(1+i == testfs.getShortValue(shortFeature));
iter.moveToNext();
}
// test long as key
iter = cas.getIndexRepository().getIndex("longIndex", exampleType).iterator();
// System.out.println("\nLong");
for (int i=0; i<5; i++) {
AnnotationFS testfs = (AnnotationFS)iter.get();
// System.out.println("exampleType has double=" + testfs.getDoubleValue(doubleFeature)
// + " long=" + testfs.getLongValue(longFeature)
// + " short=" + testfs.getShortValue(shortFeature));
assertTrue(1+i == testfs.getDoubleValue(doubleFeature));
assertTrue(5-i == testfs.getLongValue(longFeature));
assertTrue(1+i == testfs.getShortValue(shortFeature));
iter.moveToNext();
}
// test short as key
iter = cas.getIndexRepository().getIndex("shortIndex", exampleType).iterator();
// System.out.println("\nShort");
for (int i=0; i<5; i++) {
AnnotationFS testfs = (AnnotationFS)iter.get();
// System.out.println("exampleType has double=" + testfs.getDoubleValue(doubleFeature)
// + " long=" + testfs.getLongValue(longFeature)
// + " short=" + testfs.getShortValue(shortFeature));
assertTrue(1+i == testfs.getDoubleValue(doubleFeature));
assertTrue(5-i == testfs.getLongValue(longFeature));
assertTrue(1+i == testfs.getShortValue(shortFeature));
iter.moveToNext();
}
}
// public void testUimaTypeSystem2Ecore() throws Exception
// {
// //register default resource factory
// Resource.Factory.Registry.INSTANCE.
// getExtensionToFactoryMap().put("*", new XMIResourceFactoryImpl());
// //create Ecore Resource
// ResourceSet resourceSet = new ResourceSetImpl();
// URI outputURI = URI.createFileURI("test.ecore");
// Resource outputResource = resourceSet.createResource(outputURI);
//
// //Convert UIMA Type System to Ecore
// TypeSystemDescription ts =
// TypeSystemUtil.typeSystem2TypeSystemDescription(cas.getTypeSystem());
// UimaTypeSystem2Ecore.uimaTypeSystem2Ecore(ts, outputResource, null);
// //outputResource.save(null); //for debugging only
// //Convert back
// TypeSystemDescription result = Ecore2UimaTypeSystem.ecore2UimaTypeSystem(outputResource, null);
// ts.toXML(System.out);
// result.toXML(System.out); //for debugging only
// //Should be the same
// UimaTypeSystem2EcoreTest.assertTypeSystemsEqual(ts, result);
//
// //we need to do this to reset the the EMF package registry to its default state,
// //otherwise subsequent tests won't be starting from scratch
// EPackage.Registry.INSTANCE.clear();
// EcorePackage ecore = EcorePackage.eINSTANCE;
// EPackage.Registry.INSTANCE.put(ecore.getNsURI(), ecore);
// }
public static void main(String[] args) {
junit.textui.TestRunner.run(NewPrimitiveTypesTest.class);
}
}