| /* |
| * 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.fit.factory; |
| |
| import static java.util.Arrays.asList; |
| import static org.apache.uima.fit.factory.AnalysisEngineFactory.createEngine; |
| import static org.apache.uima.fit.factory.AnalysisEngineFactory.createEngineDescription; |
| import static org.apache.uima.fit.factory.AnalysisEngineFactory.createEngineFromPath; |
| import static org.apache.uima.fit.factory.TypeSystemDescriptionFactory.createTypeSystemDescription; |
| import static org.assertj.core.api.Assertions.assertThat; |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.lang.reflect.Array; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import org.apache.commons.io.FileUtils; |
| import org.apache.uima.UIMAException; |
| import org.apache.uima.UIMAFramework; |
| import org.apache.uima.analysis_component.AnalysisComponent; |
| import org.apache.uima.analysis_engine.AnalysisEngine; |
| import org.apache.uima.analysis_engine.AnalysisEngineDescription; |
| import org.apache.uima.analysis_engine.AnalysisEngineProcessException; |
| import org.apache.uima.analysis_engine.metadata.SofaMapping; |
| import org.apache.uima.cas.CAS; |
| import org.apache.uima.cas.FSIterator; |
| import org.apache.uima.fit.ComponentTestBase; |
| import org.apache.uima.fit.component.JCasAnnotator_ImplBase; |
| import org.apache.uima.fit.component.NoOpAnnotator; |
| import org.apache.uima.fit.descriptor.OperationalProperties; |
| import org.apache.uima.fit.descriptor.ResourceMetaData; |
| import org.apache.uima.fit.factory.testAes.Annotator1; |
| import org.apache.uima.fit.factory.testAes.Annotator2; |
| import org.apache.uima.fit.factory.testAes.Annotator3; |
| import org.apache.uima.fit.factory.testAes.Annotator4; |
| import org.apache.uima.fit.factory.testAes.ParameterizedAE; |
| import org.apache.uima.fit.factory.testAes.SerializationTestAnnotator; |
| import org.apache.uima.fit.factory.testAes.ViewNames; |
| import org.apache.uima.fit.pipeline.SimplePipeline; |
| import org.apache.uima.fit.type.AnalyzedText; |
| import org.apache.uima.fit.type.Sentence; |
| import org.apache.uima.fit.type.Token; |
| import org.apache.uima.fit.util.CasIOUtil; |
| import org.apache.uima.fit.util.JCasUtil; |
| import org.apache.uima.jcas.JCas; |
| import org.apache.uima.jcas.tcas.Annotation; |
| import org.apache.uima.pear.tools.PackageBrowser; |
| import org.apache.uima.pear.tools.PackageInstaller; |
| import org.apache.uima.resource.PearSpecifier; |
| import org.apache.uima.resource.ResourceInitializationException; |
| import org.apache.uima.resource.metadata.Capability; |
| import org.apache.uima.resource.metadata.ConfigurationParameter; |
| import org.apache.uima.resource.metadata.ConfigurationParameterDeclarations; |
| import org.apache.uima.resource.metadata.ConfigurationParameterSettings; |
| import org.apache.uima.resource.metadata.FsIndexDescription; |
| import org.apache.uima.resource.metadata.ProcessingResourceMetaData; |
| 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.util.XMLInputSource; |
| import org.custommonkey.xmlunit.XMLAssert; |
| import org.custommonkey.xmlunit.XMLUnit; |
| import org.junit.Test; |
| |
| public class AnalysisEngineFactoryTest extends ComponentTestBase { |
| |
| @Test |
| public void testViewAE() throws Exception { |
| AnalysisEngineDescription aed = AnalysisEngineFactory.createEngineDescription( |
| Annotator4.class, typeSystemDescription); |
| AnalysisEngine ae = AnalysisEngineFactory.createEngine(aed, "A"); |
| |
| JCas aView = jCas.createView("A"); |
| tokenBuilder.buildTokens(aView, "'Verb' is a noun!?"); |
| ae.process(jCas); |
| assertEquals("'Verb' is a noun!?", jCas.getView("A").getDocumentText()); |
| assertEquals("NN", JCasUtil.selectByIndex(aView, Token.class, 0).getPos()); |
| } |
| |
| @Test |
| public void testCreateAnalysisEngineFromPath() throws UIMAException, IOException { |
| AnalysisEngine engine = createEngineFromPath( |
| "src/main/resources/org/apache/uima/fit/component/NoOpAnnotator.xml"); |
| assertNotNull(engine); |
| } |
| |
| @Test |
| public void testCreateAnalysisEngineWithPrioritizedTypes() throws UIMAException { |
| String[] prioritizedTypeNames = new String[] { "org.apache.uima.fit.type.Token", |
| "org.apache.uima.fit.type.Sentence" }; |
| AnalysisEngine engine = AnalysisEngineFactory.createEngine( |
| org.apache.uima.fit.component.NoOpAnnotator.class, typeSystemDescription, |
| prioritizedTypeNames, (Object[]) null); |
| |
| typePriorities = engine.getAnalysisEngineMetaData().getTypePriorities(); |
| assertEquals(1, typePriorities.getPriorityLists().length); |
| TypePriorityList typePriorityList = typePriorities.getPriorityLists()[0]; |
| assertEquals(2, typePriorityList.getTypes().length); |
| assertEquals("org.apache.uima.fit.type.Token", typePriorityList.getTypes()[0]); |
| assertEquals("org.apache.uima.fit.type.Sentence", typePriorityList.getTypes()[1]); |
| |
| jCas = engine.newJCas(); |
| tokenBuilder.buildTokens(jCas, "word"); |
| FSIterator<Annotation> tokensInSentence = jCas.getAnnotationIndex().subiterator( |
| JCasUtil.selectByIndex(jCas, Sentence.class, 0)); |
| assertFalse(tokensInSentence.hasNext()); |
| |
| prioritizedTypeNames = new String[] { "org.apache.uima.fit.type.Sentence", |
| "org.apache.uima.fit.type.Token" }; |
| engine = AnalysisEngineFactory.createEngine( |
| org.apache.uima.fit.component.NoOpAnnotator.class, typeSystemDescription, |
| prioritizedTypeNames, (Object[]) null); |
| jCas = engine.newJCas(); |
| tokenBuilder.buildTokens(jCas, "word"); |
| tokensInSentence = jCas.getAnnotationIndex().subiterator( |
| JCasUtil.selectByIndex(jCas, Sentence.class, 0)); |
| assertTrue(tokensInSentence.hasNext()); |
| |
| } |
| |
| @Test |
| public void testAggregate() throws UIMAException { |
| tokenBuilder.buildTokens(jCas, "Anyone up for a game of Foosball?"); |
| |
| SofaMapping[] sofaMappings = new SofaMapping[] { |
| SofaMappingFactory.createSofaMapping(Annotator1.class, ViewNames.PARENTHESES_VIEW, "A"), |
| SofaMappingFactory.createSofaMapping(Annotator2.class, ViewNames.SORTED_VIEW, "B"), |
| SofaMappingFactory.createSofaMapping(Annotator2.class, ViewNames.SORTED_PARENTHESES_VIEW, |
| "C"), |
| SofaMappingFactory.createSofaMapping(Annotator2.class, ViewNames.PARENTHESES_VIEW, "A"), |
| SofaMappingFactory.createSofaMapping(Annotator3.class, ViewNames.INITIAL_VIEW, "B") }; |
| |
| List<Class<? extends AnalysisComponent>> primitiveAEClasses = new ArrayList<Class<? extends AnalysisComponent>>(); |
| primitiveAEClasses.add(Annotator1.class); |
| primitiveAEClasses.add(Annotator2.class); |
| primitiveAEClasses.add(Annotator3.class); |
| |
| AnalysisEngine aggregateEngine = AnalysisEngineFactory.createEngine(primitiveAEClasses, |
| typeSystemDescription, null, sofaMappings); |
| |
| aggregateEngine.process(jCas); |
| |
| assertEquals("Anyone up for a game of Foosball?", jCas.getDocumentText()); |
| assertEquals("Any(o)n(e) (u)p f(o)r (a) g(a)m(e) (o)f F(oo)sb(a)ll?", jCas.getView("A") |
| .getDocumentText()); |
| assertEquals("?AFaaabeeffgllmnnoooooprsuy", jCas.getView("B").getDocumentText()); |
| assertEquals("(((((((((())))))))))?AFaaabeeffgllmnnoooooprsuy", jCas.getView("C") |
| .getDocumentText()); |
| assertEquals("yusrpooooonnmllgffeebaaaFA?", jCas.getView(ViewNames.REVERSE_VIEW) |
| .getDocumentText()); |
| |
| } |
| |
| @Test |
| public void testAggregate2() throws UIMAException, IOException { |
| tokenBuilder.buildTokens(jCas, "Anyone up for a game of Foosball?"); |
| |
| SofaMapping[] sofaMappings = new SofaMapping[] { |
| SofaMappingFactory.createSofaMapping("ann1", ViewNames.PARENTHESES_VIEW, "A"), |
| SofaMappingFactory.createSofaMapping("ann2", ViewNames.SORTED_VIEW, "B"), |
| SofaMappingFactory.createSofaMapping("ann2", ViewNames.SORTED_PARENTHESES_VIEW, "C"), |
| SofaMappingFactory.createSofaMapping("ann2", ViewNames.PARENTHESES_VIEW, "A"), |
| SofaMappingFactory.createSofaMapping("ann3", ViewNames.INITIAL_VIEW, "B") }; |
| |
| List<AnalysisEngineDescription> primitiveDescriptors = new ArrayList<AnalysisEngineDescription>(); |
| primitiveDescriptors.add(AnalysisEngineFactory.createEngineDescription(Annotator1.class, |
| typeSystemDescription, (TypePriorities) null)); |
| primitiveDescriptors.add(AnalysisEngineFactory.createEngineDescription(Annotator2.class, |
| typeSystemDescription, (TypePriorities) null)); |
| primitiveDescriptors.add(AnalysisEngineFactory.createEngineDescription(Annotator3.class, |
| typeSystemDescription, (TypePriorities) null)); |
| |
| List<String> componentNames = Arrays.asList("ann1", "ann2", "ann3"); |
| |
| AnalysisEngine aggregateEngine = AnalysisEngineFactory.createEngine(primitiveDescriptors, |
| componentNames, null, sofaMappings); |
| |
| aggregateEngine.process(jCas); |
| |
| assertEquals("Anyone up for a game of Foosball?", jCas.getDocumentText()); |
| assertEquals("Any(o)n(e) (u)p f(o)r (a) g(a)m(e) (o)f F(oo)sb(a)ll?", jCas.getView("A") |
| .getDocumentText()); |
| assertEquals("?AFaaabeeffgllmnnoooooprsuy", jCas.getView("B").getDocumentText()); |
| assertEquals("(((((((((())))))))))?AFaaabeeffgllmnnoooooprsuy", jCas.getView("C") |
| .getDocumentText()); |
| assertEquals("yusrpooooonnmllgffeebaaaFA?", jCas.getView(ViewNames.REVERSE_VIEW) |
| .getDocumentText()); |
| |
| CasIOUtil.readJCas(jCas, new File("src/test/resources/data/docs/test.xmi")); |
| AnalysisEngine ae1 = AnalysisEngineFactory.createEngine(NoOpAnnotator.class, |
| typeSystemDescription); |
| |
| SimplePipeline.runPipeline(jCas, ae1, aggregateEngine); |
| |
| } |
| |
| @Test |
| public void testReflectPrimitiveDescription() throws ResourceInitializationException { |
| AnalysisEngineDescription aed = AnalysisEngineFactory.createEngineDescription( |
| Annotator2.class, typeSystemDescription, typePriorities); |
| Capability[] capabilities = aed.getAnalysisEngineMetaData().getCapabilities(); |
| assertEquals(1, capabilities.length); |
| String[] inputSofas = capabilities[0].getInputSofas(); |
| assertArrayEquals(new String[] { CAS.NAME_DEFAULT_SOFA, ViewNames.PARENTHESES_VIEW }, |
| inputSofas); |
| String[] outputSofas = capabilities[0].getOutputSofas(); |
| assertArrayEquals(new String[] { ViewNames.SORTED_VIEW, ViewNames.SORTED_PARENTHESES_VIEW }, |
| outputSofas); |
| |
| aed = AnalysisEngineFactory.createEngineDescription(ParameterizedAE.class, |
| typeSystemDescription, typePriorities); |
| capabilities = aed.getAnalysisEngineMetaData().getCapabilities(); |
| assertEquals(1, capabilities.length); |
| inputSofas = capabilities[0].getInputSofas(); |
| assertArrayEquals(new String[] { CAS.NAME_DEFAULT_SOFA }, inputSofas); |
| outputSofas = capabilities[0].getOutputSofas(); |
| assertArrayEquals(new String[] {}, outputSofas); |
| |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_STRING_1, |
| ConfigurationParameter.TYPE_STRING, true, false, "pineapple"); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_STRING_2, |
| ConfigurationParameter.TYPE_STRING, false, true, new String[] { "coconut", "mango" }); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_STRING_3, |
| ConfigurationParameter.TYPE_STRING, false, false, null); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_STRING_4, |
| ConfigurationParameter.TYPE_STRING, true, true, new String[] { "apple" }); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_STRING_5, |
| ConfigurationParameter.TYPE_STRING, false, true, new String[] { "" }); |
| |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_BOOLEAN_1, |
| ConfigurationParameter.TYPE_BOOLEAN, true, false, Boolean.FALSE); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_BOOLEAN_2, |
| ConfigurationParameter.TYPE_BOOLEAN, false, false, null); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_BOOLEAN_3, |
| ConfigurationParameter.TYPE_BOOLEAN, true, true, new Boolean[] { true, true, false }); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_BOOLEAN_4, |
| ConfigurationParameter.TYPE_BOOLEAN, true, true, new Boolean[] { true, false, true }); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_BOOLEAN_5, |
| ConfigurationParameter.TYPE_BOOLEAN, true, true, new Boolean[] { false }); |
| |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_INT_1, |
| ConfigurationParameter.TYPE_INTEGER, true, false, 0); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_INT_2, |
| ConfigurationParameter.TYPE_INTEGER, true, false, 42); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_INT_3, |
| ConfigurationParameter.TYPE_INTEGER, true, true, new Integer[] { 42, 111 }); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_INT_4, |
| ConfigurationParameter.TYPE_INTEGER, true, true, new Integer[] { 2 }); |
| |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_FLOAT_1, |
| ConfigurationParameter.TYPE_FLOAT, true, false, 0.0f); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_FLOAT_2, |
| ConfigurationParameter.TYPE_FLOAT, false, false, 3.1415f); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_FLOAT_3, |
| ConfigurationParameter.TYPE_FLOAT, true, false, null); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_FLOAT_4, |
| ConfigurationParameter.TYPE_FLOAT, false, true, null); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_FLOAT_5, |
| ConfigurationParameter.TYPE_FLOAT, false, true, |
| new Float[] { 0.0f, 3.1415f, 2.7182818f }); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_FLOAT_6, |
| ConfigurationParameter.TYPE_FLOAT, true, true, null); |
| testConfigurationParameter(aed, ParameterizedAE.PARAM_FLOAT_7, |
| ConfigurationParameter.TYPE_FLOAT, true, true, new Float[] { 1.1111f, 2.2222f, 3.333f }); |
| |
| AnalysisEngine ae = AnalysisEngineFactory |
| .createEngine(aed, ParameterizedAE.PARAM_FLOAT_3, 3.1415f, |
| ParameterizedAE.PARAM_FLOAT_6, new Float[] { 2.71828183f }, "file2", "foo/bar"); |
| Object paramValue = ae.getAnalysisEngineMetaData().getConfigurationParameterSettings() |
| .getParameterValue(ParameterizedAE.PARAM_FLOAT_3); |
| assertEquals(paramValue, 3.1415f); |
| paramValue = ae.getAnalysisEngineMetaData().getConfigurationParameterSettings() |
| .getParameterValue(ParameterizedAE.PARAM_FLOAT_6); |
| assertEquals(((Float[]) paramValue)[0].floatValue(), 2.71828183f, 0.00001f); |
| |
| } |
| |
| private void testConfigurationParameter(AnalysisEngineDescription aed, String parameterName, |
| String parameterType, boolean mandatory, boolean multiValued, Object parameterValue) { |
| ConfigurationParameterDeclarations cpd = aed.getMetaData() |
| .getConfigurationParameterDeclarations(); |
| ConfigurationParameter cp = cpd.getConfigurationParameter(null, parameterName); |
| assertNotNull("Parameter [" + parameterName + "] does not exist!", cp); |
| assertEquals("Parameter [" + parameterName + "] has wrong name", parameterName, cp.getName()); |
| assertEquals("Parameter [" + parameterName + "] has wrong type", parameterType, cp.getType()); |
| assertEquals("Parameter [" + parameterName + "] has wrong mandatory flag", mandatory, |
| cp.isMandatory()); |
| assertEquals("Parameter [" + parameterName + "] has wrong multi-value flag", multiValued, |
| cp.isMultiValued()); |
| ConfigurationParameterSettings cps = aed.getMetaData().getConfigurationParameterSettings(); |
| Object actualValue = cps.getParameterValue(parameterName); |
| if (parameterValue == null) { |
| assertNull(actualValue); |
| } else if (!multiValued) { |
| if (parameterType.equals(ConfigurationParameter.TYPE_FLOAT)) { |
| assertEquals(((Float) parameterValue).floatValue(), ((Float) actualValue).floatValue(), |
| .001f); |
| } else { |
| assertEquals(parameterValue, actualValue); |
| } |
| } else { |
| assertEquals(Array.getLength(parameterValue), Array.getLength(actualValue)); |
| for (int i = 0; i < Array.getLength(parameterValue); ++i) { |
| assertEquals(Array.get(parameterValue, i), Array.get(actualValue, i)); |
| } |
| } |
| |
| } |
| |
| @Test |
| public void testPrimitiveDescription() throws ResourceInitializationException { |
| |
| AnalysisEngineDescription aed = AnalysisEngineFactory.createEngineDescription( |
| NoOpAnnotator.class, typeSystemDescription); |
| assertNotNull(aed); |
| // assertEquals("org.apache.uima.fit.type.TypeSystem", |
| // aed.getAnalysisEngineMetaData().getTypeSystem().getImports()[0].getName()); |
| } |
| |
| /** |
| * Test that a {@link OperationalProperties} annotation on an ancestor of a analysis engine class |
| * is found and taken into account. |
| */ |
| @Test |
| public void testComponentAnnotationOnAncestor() throws Exception { |
| AnalysisEngineDescription desc1 = AnalysisEngineFactory.createEngineDescription( |
| PristineAnnotatorClass.class, (Object[]) null); |
| assertTrue( |
| "Multiple deployment should be allowed on " + desc1.getAnnotatorImplementationName(), |
| desc1.getAnalysisEngineMetaData().getOperationalProperties() |
| .isMultipleDeploymentAllowed()); |
| |
| AnalysisEngineDescription desc2 = AnalysisEngineFactory.createEngineDescription( |
| UnannotatedAnnotatorClass.class, (Object[]) null); |
| assertFalse( |
| "Multiple deployment should be prohibited on " + desc2.getAnnotatorImplementationName(), |
| desc2.getAnalysisEngineMetaData().getOperationalProperties() |
| .isMultipleDeploymentAllowed()); |
| |
| AnalysisEngineDescription desc3 = AnalysisEngineFactory.createEngineDescription( |
| AnnotatedAnnotatorClass.class, (Object[]) null); |
| assertTrue( |
| "Multiple deployment should be allowed on " + desc3.getAnnotatorImplementationName(), |
| desc3.getAnalysisEngineMetaData().getOperationalProperties() |
| .isMultipleDeploymentAllowed()); |
| } |
| |
| /* |
| * This test case illustrates that UIMA throws an exception unless the multipleDeploymentAllowed |
| * flag is properly set to false when mixing multi-deployment and non-multi-deployment AEs. |
| */ |
| @Test(expected = ResourceInitializationException.class) |
| public void testAAEMultipleDeploymentPolicyProblem() throws Exception { |
| { |
| AnalysisEngineDescription desc1 = AnalysisEngineFactory.createEngineDescription( |
| PristineAnnotatorClass.class, (Object[]) null); |
| assertTrue( |
| "Multiple deployment should be allowed on " + desc1.getAnnotatorImplementationName(), |
| desc1.getAnalysisEngineMetaData().getOperationalProperties() |
| .isMultipleDeploymentAllowed()); |
| |
| AnalysisEngineDescription desc2 = AnalysisEngineFactory.createEngineDescription( |
| UnannotatedAnnotatorClass.class, (Object[]) null); |
| assertFalse( |
| "Multiple deployment should be prohibited on " |
| + desc2.getAnnotatorImplementationName(), desc2.getAnalysisEngineMetaData() |
| .getOperationalProperties().isMultipleDeploymentAllowed()); |
| |
| AnalysisEngineDescription aae = AnalysisEngineFactory |
| .createEngineDescription(desc1, desc2); |
| aae.getAnalysisEngineMetaData().getOperationalProperties().setMultipleDeploymentAllowed(true); |
| UIMAFramework.produceAnalysisEngine(aae); |
| } |
| } |
| |
| @Test |
| public void testAAEMultipleDeploymentPolicy() throws Exception { |
| { |
| AnalysisEngineDescription desc1 = AnalysisEngineFactory.createEngineDescription( |
| PristineAnnotatorClass.class, (Object[]) null); |
| assertTrue( |
| "Multiple deployment should be allowed on " + desc1.getAnnotatorImplementationName(), |
| desc1.getAnalysisEngineMetaData().getOperationalProperties() |
| .isMultipleDeploymentAllowed()); |
| |
| AnalysisEngineDescription desc2 = AnalysisEngineFactory.createEngineDescription( |
| UnannotatedAnnotatorClass.class, (Object[]) null); |
| assertFalse( |
| "Multiple deployment should be prohibited on " |
| + desc2.getAnnotatorImplementationName(), desc2.getAnalysisEngineMetaData() |
| .getOperationalProperties().isMultipleDeploymentAllowed()); |
| |
| AnalysisEngineDescription aae = AnalysisEngineFactory |
| .createEngineDescription(desc1, desc2); |
| UIMAFramework.produceAnalysisEngine(aae); |
| |
| assertFalse("Multiple deployment should be prohibited on AAE", aae |
| .getAnalysisEngineMetaData().getOperationalProperties().isMultipleDeploymentAllowed()); |
| } |
| |
| { |
| AnalysisEngineDescription desc1 = AnalysisEngineFactory.createEngineDescription( |
| PristineAnnotatorClass.class, (Object[]) null); |
| assertTrue( |
| "Multiple deployment should be allowed on " + desc1.getAnnotatorImplementationName(), |
| desc1.getAnalysisEngineMetaData().getOperationalProperties() |
| .isMultipleDeploymentAllowed()); |
| |
| AnalysisEngineDescription desc3 = AnalysisEngineFactory.createEngineDescription( |
| AnnotatedAnnotatorClass.class, (Object[]) null); |
| assertTrue( |
| "Multiple deployment should be allowed on " + desc3.getAnnotatorImplementationName(), |
| desc3.getAnalysisEngineMetaData().getOperationalProperties() |
| .isMultipleDeploymentAllowed()); |
| |
| AnalysisEngineDescription aae = AnalysisEngineFactory |
| .createEngineDescription(desc1, desc3); |
| UIMAFramework.produceAnalysisEngine(aae); |
| |
| assertTrue("Multiple deployment should be prohibited on AAE", aae.getAnalysisEngineMetaData() |
| .getOperationalProperties().isMultipleDeploymentAllowed()); |
| } |
| } |
| |
| @Test |
| public void testResourceMetaData() throws Exception { |
| AnalysisEngineDescription desc = AnalysisEngineFactory |
| .createEngineDescription(AnnotatorWithMetaDataClass.class); |
| |
| org.apache.uima.resource.metadata.ResourceMetaData meta = desc.getMetaData(); |
| |
| assertEquals("dummy", meta.getName()); |
| assertEquals("1.0", meta.getVersion()); |
| assertEquals("Just a dummy", meta.getDescription()); |
| assertEquals("ASL 2.0", meta.getCopyright()); |
| assertEquals("uimaFIT", meta.getVendor()); |
| } |
| |
| @ResourceMetaData(name = "dummy", version = "1.0", description = "Just a dummy", copyright = "ASL 2.0", vendor = "uimaFIT") |
| public static class AnnotatorWithMetaDataClass extends JCasAnnotator_ImplBase { |
| @Override |
| public void process(JCas aJCas) throws AnalysisEngineProcessException { |
| // Dummy |
| } |
| } |
| |
| public static class PristineAnnotatorClass extends JCasAnnotator_ImplBase { |
| @Override |
| public void process(JCas aJCas) throws AnalysisEngineProcessException { |
| // Dummy |
| } |
| } |
| |
| @org.apache.uima.fit.descriptor.OperationalProperties(multipleDeploymentAllowed = false) |
| public static class AncestorClass extends JCasAnnotator_ImplBase { |
| @Override |
| public void process(JCas aJCas) throws AnalysisEngineProcessException { |
| // Dummy |
| } |
| } |
| |
| public static class UnannotatedAnnotatorClass extends AncestorClass { |
| // Dummy |
| } |
| |
| @org.apache.uima.fit.descriptor.OperationalProperties(multipleDeploymentAllowed = true) |
| public static class AnnotatedAnnotatorClass extends UnannotatedAnnotatorClass { |
| // Vessel for the annotation |
| } |
| |
| @Test |
| public void testIssue5a() throws ResourceInitializationException { |
| AnalysisEngineFactory.createEngineDescription(ParameterizedAE.class, typeSystemDescription); |
| } |
| |
| @Test(expected = ResourceInitializationException.class) |
| public void testIssue5b() throws ResourceInitializationException { |
| AnalysisEngineFactory.createEngine(ParameterizedAE.class, typeSystemDescription); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testUnbalancedComponentAndNames() throws ResourceInitializationException { |
| List<AnalysisEngineDescription> descriptions = new ArrayList<AnalysisEngineDescription>(); |
| descriptions.add(AnalysisEngineFactory.createEngineDescription(NoOpAnnotator.class)); |
| descriptions.add(AnalysisEngineFactory.createEngineDescription(NoOpAnnotator.class)); |
| List<String> names = new ArrayList<String>(); |
| |
| createEngineDescription(descriptions, names, null, null, null); |
| } |
| |
| /** |
| * Configuring new types on an aggregate is not allowed, but configuring new priorities is |
| * allowed. Just testing if it actually works. |
| * |
| * @see <a href="https://issues.apache.org/jira/browse/UIMA-2891">UIMA-2891</a> |
| */ |
| @Test |
| public void testExtraTypeConfigsOnAggregate() throws Exception { |
| TypeSystemDescription typeSystem = TypeSystemDescriptionFactory.createTypeSystemDescription(); |
| TypePriorities extraPrios = TypePrioritiesFactory.createTypePriorities(Sentence.class, |
| Token.class); |
| |
| // This one doesn't use any auto-configuration |
| AnalysisEngineDescription ae = createEngineDescription(UnannotatedAnnotatorClass.class, |
| typeSystem, null, null, null, null, null, null); |
| |
| // Try configuring priorities on the aggregate |
| AnalysisEngineDescription aae = createEngineDescription(asList(ae), asList("ae1"), |
| extraPrios, null, null); |
| |
| AnalysisEngine engine = createEngine(aae); |
| ProcessingResourceMetaData meta = engine.getProcessingResourceMetaData(); |
| |
| // When the meta data from the ae and the aae are merged in the engine, then it should be a |
| // new instance. |
| assertFalse("Merged meta-data is same instance as original", |
| aae.getMetaData().hashCode() == meta.hashCode()); |
| assertFalse("Merged meta-data is same instance as original", |
| ae.getMetaData().hashCode() == meta.hashCode()); |
| |
| // Check that the priorities arrived |
| TypePriorities expected = ((ProcessingResourceMetaData) aae.getMetaData()).getTypePriorities(); |
| TypePriorities actual = meta.getTypePriorities(); |
| assertArrayEquals(expected.getPriorityLists()[0].getTypes(), |
| actual.getPriorityLists()[0].getTypes()); |
| } |
| |
| @Test |
| public void serializeComponent() throws Exception { |
| File reference = new File("src/test/resources/data/reference/SerializationTestAnnotator.xml"); |
| |
| File target = new File("target/test-output/AnalysisEngineFactoryTest/SerializationTestAnnotator.xml"); |
| target.getParentFile().mkdirs(); |
| |
| AnalysisEngineDescription desc = createEngineDescription(SerializationTestAnnotator.class); |
| try (OutputStream os = new FileOutputStream(target)) { |
| desc.toXML(os); |
| } |
| |
| String actual = FileUtils.readFileToString(target, "UTF-8"); |
| String expected = FileUtils.readFileToString(reference, "UTF-8"); |
| XMLUnit.setIgnoreWhitespace(true); |
| XMLAssert.assertXMLEqual(expected, actual); |
| // assertEquals(expected, actual); |
| } |
| |
| @Test |
| public void testPear() throws Exception { |
| // Install PEAR package |
| PackageBrowser instPear = PackageInstaller.installPackage( |
| new File("target/test-output/AnalysisEngineFactoryTest/testPear"), |
| new File("src/test/resources/pear/DateTime.pear"), true); |
| |
| // Create analysis engine from the installed PEAR package |
| XMLInputSource in = new XMLInputSource(instPear.getComponentPearDescPath()); |
| PearSpecifier specifier = UIMAFramework.getXMLParser().parsePearSpecifier(in); |
| |
| AnalysisEngine ae = createEngine(createEngineDescription(specifier)); |
| |
| // Create a CAS with a sample document text and process the CAS |
| CAS cas = ae.newCAS(); |
| cas.setDocumentText("Sample text to process with a date 05/29/07 and a time 9:45 AM"); |
| cas.setDocumentLanguage("en"); |
| ae.process(cas); |
| } |
| |
| @Test |
| public void thatCreateEngineDescriptorAutoDetectionWorks() throws Exception |
| { |
| AnalysisEngineDescription aed = createEngineDescription(NoOpAnnotator.class); |
| |
| TypeSystemDescription tsd = createTypeSystemDescription(); |
| assertThat(tsd.getType(Token.class.getName())) |
| .as("Token type auto-detection") |
| .isNotNull(); |
| assertThat(tsd.getType(Sentence.class.getName())) |
| .as("Sentence type auto-detection") |
| .isNotNull(); |
| assertThat(tsd.getType(AnalyzedText.class.getName())) |
| .as("AnalyzedText type auto-detection") |
| .isNotNull(); |
| |
| TypePriorityList[] typePrioritiesLists = typePriorities.getPriorityLists(); |
| assertThat(typePrioritiesLists.length).isEqualTo(1); |
| assertThat(typePrioritiesLists[0].getTypes()) |
| .as("Type priorities auto-detection") |
| .containsExactly(Sentence.class.getName(), AnalyzedText.class.getName(), Token.class.getName()); |
| |
| FsIndexDescription[] indexes = aed.getAnalysisEngineMetaData().getFsIndexCollection().getFsIndexes(); |
| assertThat(indexes.length).isEqualTo(1); |
| assertThat(indexes[0]) |
| .extracting(FsIndexDescription::getLabel, FsIndexDescription::getTypeName, FsIndexDescription::getKind) |
| .containsExactly("Automatically Scanned Index", Token.class.getName(), FsIndexDescription.KIND_SORTED); |
| } |
| } |
