/*
* 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.util;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import junit.framework.Assert;
import junit.framework.TestCase;
import org.apache.uima.UIMAFramework;
import org.apache.uima.analysis_engine.AnalysisEngineDescription;
import org.apache.uima.cas.CAS;
import org.apache.uima.cas.FSIterator;
import org.apache.uima.cas.Feature;
import org.apache.uima.cas.Type;
import org.apache.uima.cas.TypeSystem;
import org.apache.uima.cas.admin.CASFactory;
import org.apache.uima.cas.admin.CASMgr;
import org.apache.uima.cas.text.AnnotationFS;
import org.apache.uima.resource.ResourceInitializationException;
import org.apache.uima.resource.ResourceManager;
import org.apache.uima.resource.metadata.FsIndexCollection;
import org.apache.uima.resource.metadata.FsIndexDescription;
import org.apache.uima.resource.metadata.ProcessingResourceMetaData;
import org.apache.uima.resource.metadata.TypeDescription;
import org.apache.uima.resource.metadata.TypePriorities;
import org.apache.uima.resource.metadata.TypePriorityList;
import org.apache.uima.resource.metadata.TypeSystemDescription;
import org.apache.uima.resource.metadata.impl.ConfigurationParameter_impl;
import org.apache.uima.resource.metadata.impl.FsIndexCollection_impl;
import org.apache.uima.resource.metadata.impl.FsIndexDescription_impl;
import org.apache.uima.resource.metadata.impl.TypePriorities_impl;
import org.apache.uima.resource.metadata.impl.TypePriorityList_impl;
import org.apache.uima.resource.metadata.impl.TypeSystemDescription_impl;
import org.apache.uima.test.junit_extension.JUnitExtension;
public class CasCreationUtilsTest extends TestCase {
/**
* Constructor for CasCreationUtilsTest.
*
* @param arg0
*/
public CasCreationUtilsTest(String arg0) {
super(arg0);
}
public void testMergeTypeSystems() throws Exception {
try {
TypeSystemDescription ts1desc = UIMAFramework.getXMLParser().parseTypeSystemDescription(
new XMLInputSource(JUnitExtension.getFile("CasCreationUtilsTest/TypeSystem1.xml")));
Assert.assertEquals(1, ts1desc.getType("Type1").getFeatures().length);
Assert.assertEquals(1, ts1desc.getType("Type2").getFeatures().length);
Assert.assertEquals(1, ts1desc.getType("Type3").getFeatures().length);
TypeSystemDescription ts2desc = UIMAFramework.getXMLParser().parseTypeSystemDescription(
new XMLInputSource(JUnitExtension.getFile("CasCreationUtilsTest/TypeSystem2.xml")));
Assert.assertEquals(1, ts2desc.getType("Type1").getFeatures().length);
Assert.assertEquals(1, ts2desc.getType("Type2").getFeatures().length);
ArrayList<TypeSystemDescription> tsList = new ArrayList<TypeSystemDescription>();
tsList.add(ts1desc);
tsList.add(ts2desc);
Map typesWithMergedFeatures = new HashMap();
TypeSystemDescription merged = CasCreationUtils.mergeTypeSystems(tsList, UIMAFramework
.newDefaultResourceManager(), typesWithMergedFeatures);
Assert.assertEquals(2, merged.getType("Type1").getFeatures().length);
Assert.assertEquals(2, merged.getType("Type2").getFeatures().length);
Assert.assertEquals(1, merged.getType("Type3").getFeatures().length);
assertEquals(2, typesWithMergedFeatures.size());
assertTrue(typesWithMergedFeatures.containsKey("Type1"));
assertTrue(typesWithMergedFeatures.containsKey("Type2"));
// make sure one-arg version doesn't fail
CasCreationUtils.mergeTypeSystems(tsList);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testMergeTypeSystemElementType() throws Exception {
try {
TypeSystemDescription ts1desc = UIMAFramework.getXMLParser()
.parseTypeSystemDescription(
new XMLInputSource(JUnitExtension
.getFile("CasCreationUtilsTest/TypeSystemMergeBase.xml")));
checkMergeTypeSystem(ts1desc, "TypeSystemMergeWrongElementType1.xml",
ResourceInitializationException.INCOMPATIBLE_ELEMENT_RANGE_TYPES);
checkMergeTypeSystem(ts1desc, "TypeSystemMergeWrongElementType2.xml",
ResourceInitializationException.INCOMPATIBLE_ELEMENT_RANGE_TYPES);
checkMergeTypeSystem(ts1desc, "TypeSystemMergeWrongMultiRef1.xml",
ResourceInitializationException.INCOMPATIBLE_MULTI_REFS);
checkMergeTypeSystem(ts1desc, "TypeSystemMergeWrongMultiRef2.xml",
ResourceInitializationException.INCOMPATIBLE_MULTI_REFS);
checkMergeTypeSystem(ts1desc, "TypeSystemMergeWrongMultiRef3.xml",
ResourceInitializationException.INCOMPATIBLE_MULTI_REFS);
checkMergeTypeSystem(ts1desc, "TypeSystemMergeOkMultiRef.xml", null);
checkMergeTypeSystem(ts1desc, "TypeSystemMergeNoElementType.xml", null);
checkMergeTypeSystem(ts1desc, "typeSystemMergeTopElementType.xml", null);
checkMergeTypeSystem(ts1desc, "TypeSystemMergeWrongElementTypeWithNone.xml",
ResourceInitializationException.INCOMPATIBLE_ELEMENT_RANGE_TYPES);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
private void checkMergeTypeSystem(TypeSystemDescription ts1desc, String typeFile, String msgKey)
throws Exception {
try {
TypeSystemDescription ts2desc = UIMAFramework
.getXMLParser()
.parseTypeSystemDescription(
new XMLInputSource(
JUnitExtension
.getFile("CasCreationUtilsTest/" + typeFile)));
List<TypeSystemDescription> tsList = new ArrayList<TypeSystemDescription>();
tsList.add(ts1desc);
tsList.add(ts2desc);
boolean rightExceptionThrown = (null != msgKey) ? false : true;
try {
CasCreationUtils.mergeTypeSystems(
tsList, UIMAFramework.newDefaultResourceManager(), new HashMap());
} catch (ResourceInitializationException rie) {
rightExceptionThrown = (null != msgKey) && rie.hasMessageKey(msgKey);
}
assertTrue(rightExceptionThrown);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testMergeTypeSystemsWithDifferentSupertypes() throws Exception {
try {
TypeSystemDescription ts1desc = UIMAFramework.getXMLParser().parseTypeSystemDescription(
new XMLInputSource(JUnitExtension.getFile("CasCreationUtilsTest/SupertypeMergeTest1.xml")));
assertEquals("uima.tcas.Annotation", ts1desc.getType("uima.test.Sub").getSupertypeName());
TypeSystemDescription ts2desc = UIMAFramework.getXMLParser().parseTypeSystemDescription(
new XMLInputSource(JUnitExtension.getFile("CasCreationUtilsTest/SupertypeMergeTest2.xml")));
assertEquals("uima.test.Super", ts2desc.getType("uima.test.Sub").getSupertypeName());
List<TypeSystemDescription> tsList = new ArrayList<TypeSystemDescription>();
tsList.add(ts1desc);
tsList.add(ts2desc);
TypeSystemDescription merged = CasCreationUtils.mergeTypeSystems(tsList, UIMAFramework
.newDefaultResourceManager());
assertEquals("uima.test.Super", merged.getType("uima.test.Sub").getSupertypeName());
// try merging in the other order - bug UIMA-826 was an order dependency in the behavior of
// this kind of merging
tsList = new ArrayList<TypeSystemDescription>();
tsList.add(ts2desc);
tsList.add(ts1desc);
merged = CasCreationUtils.mergeTypeSystems(tsList, UIMAFramework
.newDefaultResourceManager());
assertEquals("uima.test.Super", merged.getType("uima.test.Sub").getSupertypeName());
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testAggregateWithImports() throws Exception {
try {
String pathSep = System.getProperty("path.separator");
ResourceManager resMgr = UIMAFramework.newDefaultResourceManager();
resMgr.setDataPath(JUnitExtension.getFile("TypeSystemDescriptionImplTest/dataPathDir")
.getAbsolutePath()
+ pathSep
+ JUnitExtension.getFile("TypePrioritiesImplTest/dataPathDir").getAbsolutePath()
+ pathSep
+ JUnitExtension.getFile("FsIndexCollectionImplTest/dataPathDir").getAbsolutePath());
File taeDescriptorWithImport = JUnitExtension
.getFile("CasCreationUtilsTest/AggregateTaeWithImports.xml");
AnalysisEngineDescription desc = UIMAFramework.getXMLParser().parseAnalysisEngineDescription(
new XMLInputSource(taeDescriptorWithImport));
ArrayList<AnalysisEngineDescription> mdList = new ArrayList<AnalysisEngineDescription>();
mdList.add(desc);
CAS tcas = CasCreationUtils.createCas(mdList, UIMAFramework
.getDefaultPerformanceTuningProperties(), resMgr);
// check that imports were resolved correctly
assertNotNull(tcas.getTypeSystem().getType("DocumentStructure"));
assertNotNull(tcas.getTypeSystem().getType("NamedEntity"));
assertNotNull(tcas.getTypeSystem().getType("TestType3"));
assertNotNull(tcas.getTypeSystem().getType("Sentence"));
assertNotNull(tcas.getIndexRepository().getIndex("TestIndex"));
assertNotNull(tcas.getIndexRepository().getIndex("ReverseAnnotationIndex"));
assertNotNull(tcas.getIndexRepository().getIndex("DocumentStructureIndex"));
// Check elementType and multipleReferencesAllowed for array feature
Feature arrayFeat = tcas.getTypeSystem().getFeatureByFullName("Paragraph:sentences");
assertNotNull(arrayFeat);
assertFalse(arrayFeat.isMultipleReferencesAllowed());
Type sentenceArrayType = arrayFeat.getRange();
assertNotNull(sentenceArrayType);
assertTrue(sentenceArrayType.isArray());
assertEquals(tcas.getTypeSystem().getType("Sentence"), sentenceArrayType.getComponentType());
Feature arrayFeat2 = tcas.getTypeSystem().getFeatureByFullName(
"Paragraph:testMultiRefAllowedFeature");
assertNotNull(arrayFeat2);
assertTrue(arrayFeat2.isMultipleReferencesAllowed());
// test imports aren't resolved more than once
Object spec1 = desc.getDelegateAnalysisEngineSpecifiers().get("Annotator1");
assertNotNull(spec1);
Object spec2 = desc.getDelegateAnalysisEngineSpecifiers().get("Annotator1");
assertTrue(spec1 == spec2);
// test removal
desc.getDelegateAnalysisEngineSpecifiersWithImports().remove("Annotator1");
assertTrue(desc.getDelegateAnalysisEngineSpecifiers().isEmpty());
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testMergeDelegateAnalysisEngineTypeSystems() throws Exception {
try {
File descFile = JUnitExtension
.getFile("TextAnalysisEngineImplTest/AggregateTaeForMergeTest.xml");
AnalysisEngineDescription desc = UIMAFramework.getXMLParser().parseAnalysisEngineDescription(
new XMLInputSource(descFile));
Map mergedTypes = new HashMap();
TypeSystemDescription typeSys = CasCreationUtils.mergeDelegateAnalysisEngineTypeSystems(desc,
UIMAFramework.newDefaultResourceManager(), mergedTypes);
// test results of merge
Assert.assertEquals(8, typeSys.getTypes().length);
TypeDescription type0 = typeSys.getType("NamedEntity");
Assert.assertNotNull(type0);
Assert.assertEquals("uima.tcas.Annotation", type0.getSupertypeName());
Assert.assertEquals(1, type0.getFeatures().length);
TypeDescription type1 = typeSys.getType("Person");
Assert.assertNotNull(type1);
Assert.assertEquals("NamedEntity", type1.getSupertypeName());
Assert.assertEquals(1, type1.getFeatures().length);
TypeDescription type2 = typeSys.getType("Place");
Assert.assertNotNull(type2);
Assert.assertEquals("NamedEntity", type2.getSupertypeName());
Assert.assertEquals(3, type2.getFeatures().length);
TypeDescription type3 = typeSys.getType("Org");
Assert.assertNotNull(type3);
Assert.assertEquals("uima.tcas.Annotation", type3.getSupertypeName());
Assert.assertEquals(0, type3.getFeatures().length);
TypeDescription type4 = typeSys.getType("DocumentStructure");
Assert.assertNotNull(type4);
Assert.assertEquals("uima.tcas.Annotation", type4.getSupertypeName());
Assert.assertEquals(0, type4.getFeatures().length);
TypeDescription type5 = typeSys.getType("Paragraph");
Assert.assertNotNull(type5);
Assert.assertEquals("DocumentStructure", type5.getSupertypeName());
Assert.assertEquals(0, type5.getFeatures().length);
TypeDescription type6 = typeSys.getType("Sentence");
Assert.assertNotNull(type6);
Assert.assertEquals("DocumentStructure", type6.getSupertypeName());
Assert.assertEquals(0, type6.getFeatures().length);
TypeDescription type7 = typeSys.getType("test.flowController.Test");
Assert.assertNotNull(type7);
Assert.assertEquals("uima.tcas.Annotation", type7.getSupertypeName());
Assert.assertEquals(1, type7.getFeatures().length);
// Place has merged features, Person has different supertype
assertEquals(2, mergedTypes.size());
assertTrue(mergedTypes.containsKey("Place"));
assertTrue(mergedTypes.containsKey("Person"));
// make sure one-arg version doesn't fail
CasCreationUtils.mergeDelegateAnalysisEngineTypeSystems(desc);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testMergeDelegateAnalysisEngineTypePriorities() throws Exception {
try {
File descFile = JUnitExtension
.getFile("TextAnalysisEngineImplTest/AggregateTaeForMergeTest.xml");
AnalysisEngineDescription desc = UIMAFramework.getXMLParser().parseAnalysisEngineDescription(
new XMLInputSource(descFile));
TypePriorities pri = CasCreationUtils.mergeDelegateAnalysisEngineTypePriorities(desc);
// test results of merge
Assert.assertNotNull(pri);
TypePriorityList[] priLists = pri.getPriorityLists();
Assert.assertEquals(3, priLists.length);
String[] list0 = priLists[0].getTypes();
String[] list1 = priLists[1].getTypes();
String[] list2 = priLists[2].getTypes();
// order of the three lists is not defined
Assert.assertTrue((list0.length == 2 && list1.length == 2 && list2.length == 3)
|| (list0.length == 2 && list1.length == 3 && list2.length == 2)
|| (list0.length == 3 && list1.length == 2 && list2.length == 2));
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testMergeDelegateAnalysisEngineFsIndexCollections() throws Exception {
try {
File descFile = JUnitExtension
.getFile("TextAnalysisEngineImplTest/AggregateTaeForMergeTest.xml");
AnalysisEngineDescription desc = UIMAFramework.getXMLParser().parseAnalysisEngineDescription(
new XMLInputSource(descFile));
FsIndexCollection indexColl = CasCreationUtils
.mergeDelegateAnalysisEngineFsIndexCollections(desc);
// test results of merge
FsIndexDescription[] indexes = indexColl.getFsIndexes();
Assert.assertEquals(3, indexes.length);
// order of indexes is not defined
String label0 = indexes[0].getLabel();
String label1 = indexes[1].getLabel();
String label2 = indexes[2].getLabel();
Assert.assertTrue(label0.equals("DocStructIndex") || label1.equals("DocStructIndex")
|| label2.equals("DocStructIndex"));
Assert.assertTrue(label0.equals("PlaceIndex") || label1.equals("PlaceIndex")
|| label2.equals("PlaceIndex"));
Assert.assertTrue(label0.equals("FlowControllerTestIndex")
|| label1.equals("FlowControllerTestIndex")
|| label2.equals("FlowControllerTestIndex"));
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testSetupTypeSystem() throws Exception {
try {
// test that duplicate feature names on supertype and subtype works
// regardless of the order in which the types appear in the TypeSystemDescription
TypeSystemDescription tsd1 = new TypeSystemDescription_impl();
TypeDescription supertype = tsd1.addType("test.Super", "", "uima.cas.TOP");
supertype.addFeature("testfeat", "", "uima.cas.Integer");
TypeDescription subtype = tsd1.addType("test.Sub", "", "test.Super");
subtype.addFeature("testfeat", "", "uima.cas.Integer");
CASMgr casMgr = CASFactory.createCAS();
CasCreationUtils.setupTypeSystem(casMgr, tsd1);
assertNotNull(casMgr.getTypeSystemMgr().getType("test.Super")
.getFeatureByBaseName("testfeat"));
TypeSystemDescription tsd2 = new TypeSystemDescription_impl();
tsd2.setTypes(new TypeDescription[] { subtype, supertype });
casMgr = CASFactory.createCAS();
CasCreationUtils.setupTypeSystem(casMgr, tsd2);
assertNotNull(casMgr.getTypeSystemMgr().getType("test.Super")
.getFeatureByBaseName("testfeat"));
} catch (ResourceInitializationException e) {
JUnitExtension.handleException(e);
}
}
public void testCreateCasCollectionPropertiesResourceManager() throws Exception {
try {
// parse an AE descriptor
File taeDescriptorWithImport = JUnitExtension
.getFile("CasCreationUtilsTest/TaeWithImports.xml");
AnalysisEngineDescription desc = UIMAFramework.getXMLParser().parseAnalysisEngineDescription(
new XMLInputSource(taeDescriptorWithImport));
// create Resource Manager & set data path - necessary to resolve imports
ResourceManager resMgr = UIMAFramework.newDefaultResourceManager();
String pathSep = System.getProperty("path.separator");
resMgr.setDataPath(JUnitExtension.getFile("TypeSystemDescriptionImplTest/dataPathDir")
.getAbsolutePath()
+ pathSep
+ JUnitExtension.getFile("TypePrioritiesImplTest/dataPathDir").getAbsolutePath()
+ pathSep
+ JUnitExtension.getFile("FsIndexCollectionImplTest/dataPathDir").getAbsolutePath());
// call method
ArrayList<AnalysisEngineDescription> descList = new ArrayList<AnalysisEngineDescription>();
descList.add(desc);
CAS cas = CasCreationUtils.createCas(descList, UIMAFramework
.getDefaultPerformanceTuningProperties(), resMgr);
// check that imports were resolved correctly
assertNotNull(cas.getTypeSystem().getType("DocumentStructure"));
assertNotNull(cas.getTypeSystem().getType("NamedEntity"));
assertNotNull(cas.getTypeSystem().getType("TestType3"));
assertNotNull(cas.getIndexRepository().getIndex("TestIndex"));
assertNotNull(cas.getIndexRepository().getIndex("ReverseAnnotationIndex"));
assertNotNull(cas.getIndexRepository().getIndex("DocumentStructureIndex"));
// check of type priority
AnnotationFS fs1 = cas.createAnnotation(cas.getTypeSystem().getType("Paragraph"), 0, 1);
AnnotationFS fs2 = cas.createAnnotation(cas.getTypeSystem().getType("Sentence"), 0, 1);
assertTrue(cas.getAnnotationIndex().compare(fs1, fs2) < 0);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testCreateCasCollection() throws Exception {
try {
// create two Type System description objects
TypeSystemDescription tsd1 = new TypeSystemDescription_impl();
TypeDescription supertype = tsd1.addType("test.Super", "", "uima.tcas.Annotation");
supertype.addFeature("testfeat", "", "uima.cas.Integer");
TypeDescription subtype = tsd1.addType("test.Sub", "", "test.Super");
subtype.addFeature("testfeat", "", "uima.cas.Integer");
TypeSystemDescription tsd2 = new TypeSystemDescription_impl();
TypeDescription fooType = tsd1.addType("test.Foo", "", "uima.cas.TOP");
fooType.addFeature("bar", "", "uima.cas.String");
// create index and priorities descriptions
FsIndexCollection indexes = new FsIndexCollection_impl();
FsIndexDescription index = new FsIndexDescription_impl();
index.setLabel("MyIndex");
index.setTypeName("test.Foo");
index.setKind(FsIndexDescription.KIND_BAG);
indexes.addFsIndex(index);
TypePriorities priorities = new TypePriorities_impl();
TypePriorityList priList = new TypePriorityList_impl();
priList.addType("test.Foo");
priList.addType("test.Sub");
priList.addType("test.Super");
priorities.addPriorityList(priList);
// create a CAS containing all these definitions
ArrayList descList = new ArrayList();
descList.add(tsd1);
descList.add(tsd2);
descList.add(indexes);
descList.add(priorities);
CAS cas = CasCreationUtils.createCas(descList);
// check that type system has been installed
TypeSystem ts = cas.getTypeSystem();
Type supertypeHandle = ts.getType(supertype.getName());
assertNotNull(supertypeHandle);
assertNotNull(supertypeHandle.getFeatureByBaseName("testfeat"));
Type subtypeHandle = ts.getType(subtype.getName());
assertNotNull(subtypeHandle);
assertNotNull(subtypeHandle.getFeatureByBaseName("testfeat"));
Type fooTypeHandle = ts.getType(fooType.getName());
assertNotNull(fooTypeHandle);
assertNotNull(fooTypeHandle.getFeatureByBaseName("bar"));
// check that index exists
assertNotNull(cas.getIndexRepository().getIndex("MyIndex"));
// test that priorities work
cas.createFS(supertypeHandle);
cas.createFS(subtypeHandle);
FSIterator iter = cas.getAnnotationIndex().iterator();
while (iter.isValid()) {
if (iter.get().getType() == subtypeHandle) // expected
break;
if (iter.get().getType() == supertypeHandle) // unexpected
fail();
iter.moveToNext();
}
// test that passing an invalid object causes an error
descList.add(new ConfigurationParameter_impl());
try {
CasCreationUtils.createCas(descList);
fail();
} catch (ResourceInitializationException e) {
// expected
}
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testCreateCasTypeSystemDescription() throws Exception {
try {
//parse type system description
TypeSystemDescription tsDesc = UIMAFramework.getXMLParser().parseTypeSystemDescription(
new XMLInputSource(JUnitExtension.getFile("CasCreationUtilsTest/SupertypeMergeTestMaster.xml")));
// call method
CAS cas = CasCreationUtils.createCas(tsDesc, null, null);
//check that imports were resolved and supertype merged properly
Type subType = cas.getTypeSystem().getType("uima.test.Sub");
assertNotNull(subType);
Type superType = cas.getTypeSystem().getType("uima.test.Super");
assertNotNull(superType);
assertTrue(cas.getTypeSystem().subsumes(superType,subType));
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testMergeDelegateAnalysisEngineMetaData() throws Exception {
try {
File descFile = JUnitExtension
.getFile("TextAnalysisEngineImplTest/AggregateTaeForMergeTest.xml");
AnalysisEngineDescription desc = UIMAFramework.getXMLParser().parseAnalysisEngineDescription(
new XMLInputSource(descFile));
Map mergedTypes = new HashMap();
ProcessingResourceMetaData mergedMetaData = CasCreationUtils
.mergeDelegateAnalysisEngineMetaData(desc, UIMAFramework.newDefaultResourceManager(),
mergedTypes, null);
TypeSystemDescription typeSys = mergedMetaData.getTypeSystem();
TypePriorities pri = mergedMetaData.getTypePriorities();
FsIndexCollection indexColl = mergedMetaData.getFsIndexCollection();
// test results of merge
// Type System
Assert.assertEquals(8, typeSys.getTypes().length);
TypeDescription type0 = typeSys.getType("NamedEntity");
Assert.assertNotNull(type0);
Assert.assertEquals("uima.tcas.Annotation", type0.getSupertypeName());
Assert.assertEquals(1, type0.getFeatures().length);
TypeDescription type1 = typeSys.getType("Person");
Assert.assertNotNull(type1);
Assert.assertEquals("NamedEntity", type1.getSupertypeName());
Assert.assertEquals(1, type1.getFeatures().length);
TypeDescription type2 = typeSys.getType("Place");
Assert.assertNotNull(type2);
Assert.assertEquals("NamedEntity", type2.getSupertypeName());
Assert.assertEquals(3, type2.getFeatures().length);
TypeDescription type3 = typeSys.getType("Org");
Assert.assertNotNull(type3);
Assert.assertEquals("uima.tcas.Annotation", type3.getSupertypeName());
Assert.assertEquals(0, type3.getFeatures().length);
TypeDescription type4 = typeSys.getType("DocumentStructure");
Assert.assertNotNull(type4);
Assert.assertEquals("uima.tcas.Annotation", type4.getSupertypeName());
Assert.assertEquals(0, type4.getFeatures().length);
TypeDescription type5 = typeSys.getType("Paragraph");
Assert.assertNotNull(type5);
Assert.assertEquals("DocumentStructure", type5.getSupertypeName());
Assert.assertEquals(0, type5.getFeatures().length);
TypeDescription type6 = typeSys.getType("Sentence");
Assert.assertNotNull(type6);
Assert.assertEquals("DocumentStructure", type6.getSupertypeName());
Assert.assertEquals(0, type6.getFeatures().length);
TypeDescription type7 = typeSys.getType("test.flowController.Test");
Assert.assertNotNull(type7);
Assert.assertEquals("uima.tcas.Annotation", type7.getSupertypeName());
Assert.assertEquals(1, type7.getFeatures().length);
// Place has merged features, Person has different supertype
assertEquals(2, mergedTypes.size());
assertTrue(mergedTypes.containsKey("Place"));
assertTrue(mergedTypes.containsKey("Person"));
// Type Priorities
Assert.assertNotNull(pri);
TypePriorityList[] priLists = pri.getPriorityLists();
Assert.assertEquals(3, priLists.length);
String[] list0 = priLists[0].getTypes();
String[] list1 = priLists[1].getTypes();
String[] list2 = priLists[2].getTypes();
// order of the three lists is not defined
Assert.assertTrue((list0.length == 2 && list1.length == 2 && list2.length == 3)
|| (list0.length == 2 && list1.length == 3 && list2.length == 2)
|| (list0.length == 3 && list1.length == 2 && list2.length == 2));
// Indexes
FsIndexDescription[] indexes = indexColl.getFsIndexes();
Assert.assertEquals(3, indexes.length);
// order of indexes is not defined
String label0 = indexes[0].getLabel();
String label1 = indexes[1].getLabel();
String label2 = indexes[2].getLabel();
Assert.assertTrue(label0.equals("DocStructIndex") || label1.equals("DocStructIndex")
|| label2.equals("DocStructIndex"));
Assert.assertTrue(label0.equals("PlaceIndex") || label1.equals("PlaceIndex")
|| label2.equals("PlaceIndex"));
Assert.assertTrue(label0.equals("FlowControllerTestIndex")
|| label1.equals("FlowControllerTestIndex")
|| label2.equals("FlowControllerTestIndex"));
// Now test case where aggregate contains a remote, and we want to do the
// merge of the non-remote delegates and report the failure. (This example
// also happens to use import-by-name so we need to set the data path.)
ResourceManager resMgr = UIMAFramework.newDefaultResourceManager();
String pathSep = System.getProperty("path.separator");
resMgr.setDataPath(JUnitExtension.getFile("TypeSystemDescriptionImplTest/dataPathDir")
.getAbsolutePath()
+ pathSep
+ JUnitExtension.getFile("TypePrioritiesImplTest/dataPathDir").getAbsolutePath()
+ pathSep
+ JUnitExtension.getFile("FsIndexCollectionImplTest/dataPathDir").getAbsolutePath());
File descFile2 = JUnitExtension
.getFile("CasCreationUtilsTest/AggregateTaeWithSoapDelegate.xml");
AnalysisEngineDescription desc2 = UIMAFramework.getXMLParser()
.parseAnalysisEngineDescription(new XMLInputSource(descFile2));
Map mergedTypes2 = new HashMap();
Map failedRemotes = new HashMap();
ProcessingResourceMetaData mergedMetaData2 = CasCreationUtils
.mergeDelegateAnalysisEngineMetaData(desc2, resMgr,
mergedTypes2, failedRemotes);
assertTrue(failedRemotes.containsKey("/RemoteDelegate"));
((Exception)failedRemotes.get("/RemoteDelegate")).printStackTrace();
assertTrue(mergedMetaData2.getTypeSystem().getTypes().length > 0);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
}