| /* |
| * 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 junit.framework.TestCase; |
| |
| import org.apache.uima.cas.CAS; |
| import org.apache.uima.cas.CASException; |
| import org.apache.uima.cas.FSIndex; |
| import org.apache.uima.cas.Feature; |
| import org.apache.uima.cas.FeatureStructure; |
| 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.admin.FSIndexComparator; |
| import org.apache.uima.cas.admin.FSIndexRepositoryMgr; |
| import org.apache.uima.cas.admin.TypeSystemMgr; |
| import org.apache.uima.cas.impl.CASCompleteSerializer; |
| import org.apache.uima.cas.impl.CASImpl; |
| import org.apache.uima.cas.impl.Serialization; |
| import org.apache.uima.cas.text.AnnotationFS; |
| import org.apache.uima.resource.ResourceInitializationException; |
| import org.apache.uima.resource.metadata.TypeSystemDescription; |
| import org.apache.uima.util.CasCreationUtils; |
| |
| |
| public class IndexSerializationTest extends TestCase { |
| |
| // Index name constants. |
| public static final String ANNOT_SET_INDEX = "Annotation Set Index"; |
| |
| public static final String ANNOT_BAG_INDEX = "Annotation Bag Index"; |
| |
| public static final String TOKEN_TYPE = "Token"; |
| |
| public static final String TOKEN_TYPE_FEAT = "type"; |
| |
| public static final String TOKEN_TYPE_FEAT_Q = TOKEN_TYPE + TypeSystem.FEATURE_SEPARATOR |
| + TOKEN_TYPE_FEAT; |
| |
| public static final String TOKEN_TYPE_TYPE = "TokenType"; |
| |
| public static final String WORD_TYPE = "Word"; |
| |
| public static final String SEP_TYPE = "Separator"; |
| |
| public static final String EOS_TYPE = "EndOfSentence"; |
| |
| public static final String SENT_TYPE = "Sentence"; |
| |
| private CASMgr casMgr; |
| |
| private CAS cas; |
| |
| private Type annotationType; |
| |
| private Type wordType; |
| |
| private Type separatorType; |
| |
| private Type eosType; |
| |
| private Type tokenType; |
| |
| private Feature tokenTypeFeature; |
| |
| private Type sentenceType; |
| |
| private Feature startFeature; |
| |
| private Feature endFeature; |
| |
| public IndexSerializationTest(String arg) { |
| super(arg); |
| } |
| |
| /** |
| * @see junit.framework.TestCase#setUp() |
| */ |
| protected void setUp() throws Exception { |
| super.setUp(); |
| casMgr = initCAS(); |
| cas = (CASImpl)casMgr; |
| |
| TypeSystem ts = cas.getTypeSystem(); |
| wordType = ts.getType(WORD_TYPE); |
| // assert(wordType != null); |
| separatorType = ts.getType(SEP_TYPE); |
| eosType = ts.getType(EOS_TYPE); |
| tokenType = ts.getType(TOKEN_TYPE); |
| tokenTypeFeature = ts.getFeatureByFullName(TOKEN_TYPE_FEAT_Q); |
| startFeature = ts.getFeatureByFullName(CAS.FEATURE_FULL_NAME_BEGIN); |
| endFeature = ts.getFeatureByFullName(CAS.FEATURE_FULL_NAME_END); |
| sentenceType = ts.getType(SENT_TYPE); |
| annotationType = ts.getType(CAS.TYPE_NAME_ANNOTATION); |
| assertTrue(annotationType != null); |
| } |
| |
| // Initialize the first CAS. |
| private static CASMgr initCAS() { |
| // // Create a CASMgr. Ensures existence of AnnotationFS type. |
| // CASMgr tcas = CASFactory.createCAS(); |
| CASMgr casMgr = CASFactory.createCAS(); |
| try { |
| CasCreationUtils.setupTypeSystem(casMgr, (TypeSystemDescription) null); |
| } catch (ResourceInitializationException e) { |
| e.printStackTrace(); |
| } |
| // Create a writable type system. |
| TypeSystemMgr tsa = casMgr.getTypeSystemMgr(); |
| // Add new types and features. |
| Type topType = tsa.getTopType(); |
| Type annotType = tsa.getType(CAS.TYPE_NAME_ANNOTATION); |
| // assert(annotType != null); |
| tsa.addType(SENT_TYPE, annotType); |
| Type tokenType = tsa.addType(TOKEN_TYPE, annotType); |
| Type tokenTypeType = tsa.addType(TOKEN_TYPE_TYPE, topType); |
| tsa.addType(WORD_TYPE, tokenTypeType); |
| tsa.addType(SEP_TYPE, tokenTypeType); |
| tsa.addType(EOS_TYPE, tokenTypeType); |
| tsa.addFeature(TOKEN_TYPE_FEAT, tokenType, tokenTypeType); |
| // Commit the type system. |
| ((CASImpl) casMgr).commitTypeSystem(); |
| // assert(tsa.isCommitted()); |
| // // Create the CAS indexes. |
| // tcas.initCASIndexes(); |
| // Create the Base indexes. |
| try { |
| casMgr.initCASIndexes(); |
| } catch (CASException e) { |
| e.printStackTrace(); |
| } |
| |
| FSIndexRepositoryMgr irm = casMgr.getIndexRepositoryMgr(); |
| FSIndexComparator comp = irm.createComparator(); |
| Type annotation = tsa.getType(CAS.TYPE_NAME_ANNOTATION); |
| comp.setType(annotation); |
| comp.addKey(annotation.getFeatureByBaseName(CAS.FEATURE_BASE_NAME_BEGIN), |
| FSIndexComparator.STANDARD_COMPARE); |
| comp.addKey(annotation.getFeatureByBaseName(CAS.FEATURE_BASE_NAME_END), |
| FSIndexComparator.REVERSE_STANDARD_COMPARE); |
| irm.createIndex(comp, ANNOT_BAG_INDEX, FSIndex.BAG_INDEX); |
| irm.createIndex(comp, ANNOT_SET_INDEX, FSIndex.SET_INDEX); |
| |
| // Commit the index repository. |
| irm.commit(); |
| // assert(cas.getIndexRepositoryMgr().isCommitted()); |
| |
| // Create the default text Sofa and return CAS view |
| return (CASMgr) casMgr.getCAS().getCurrentView(); |
| } |
| |
| /** |
| * Test driver. |
| */ |
| public void testMain() throws Exception { |
| |
| for (int i = 0; i < 10; i++) { |
| cas.getIndexRepository().addFS(cas.createAnnotation(annotationType, i * 2, (i * 2) + 1)); |
| cas.getIndexRepository().addFS(cas.createAnnotation(sentenceType, i * 2, (i * 2) + 1)); |
| cas.getIndexRepository().addFS(cas.createAnnotation(tokenType, i * 2, (i * 2) + 1)); |
| cas.getIndexRepository().addFS(cas.createAnnotation(tokenType, i * 2, (i * 2) + 1)); |
| cas.getIndexRepository().addFS(cas.createAnnotation(tokenType, i * 2, (i * 2) + 1)); |
| } |
| for (int i = 19; i >= 10; i--) { |
| cas.getIndexRepository().addFS(cas.createAnnotation(annotationType, i * 2, (i * 2) + 1)); |
| cas.getIndexRepository().addFS(cas.createAnnotation(sentenceType, i * 2, (i * 2) + 1)); |
| cas.getIndexRepository().addFS(cas.createAnnotation(tokenType, i * 2, (i * 2) + 1)); |
| cas.getIndexRepository().addFS(cas.createAnnotation(tokenType, i * 2, (i * 2) + 1)); |
| cas.getIndexRepository().addFS(cas.createAnnotation(tokenType, i * 2, (i * 2) + 1)); |
| } |
| |
| AnnotationFS searchAnnot = cas.createAnnotation(annotationType, 0, 1); |
| assertTrue(cas.getAnnotationIndex().find(searchAnnot) != null); |
| assertTrue(cas.getIndexRepository().getIndex(ANNOT_SET_INDEX).find(searchAnnot) != null); |
| // find() does not produce useful results on bag indexes, since the comparator |
| // is not defined. |
| // assertTrue(cas.getIndexRepository().getIndex(ANNOT_BAG_INDEX).find(searchAnnot) != null); |
| |
| searchAnnot.setIntValue(endFeature, 4); |
| assertTrue(cas.getAnnotationIndex().find(searchAnnot) == null); |
| assertTrue(cas.getIndexRepository().getIndex(ANNOT_SET_INDEX).find(searchAnnot) == null); |
| assertTrue(cas.getIndexRepository().getIndex(ANNOT_BAG_INDEX).find(searchAnnot) == null); |
| |
| final int ordSize = cas.getAnnotationIndex().size(); |
| final int setSize = cas.getIndexRepository().getIndex(ANNOT_SET_INDEX).size(); |
| final int bagSize = cas.getIndexRepository().getIndex(ANNOT_BAG_INDEX).size(); |
| // System.out.println("Before serialization\n"); |
| // System.out.println("Size of ordered index: " + ordSize); |
| // System.out.println("Size of set index: " + setSize); |
| // System.out.println("Size of bag index: " + bagSize); |
| |
| CASCompleteSerializer cs; |
| cs = Serialization.serializeCASComplete(casMgr); |
| // casMgr = CASFactory.createCAS(); |
| CASMgr realCasMgr = CASFactory.createCAS(); |
| ((CASImpl) realCasMgr).commitTypeSystem(); |
| Serialization.deserializeCASComplete(cs, realCasMgr); |
| cas = ((CASImpl) realCasMgr).getCurrentView(); |
| casMgr = (CASMgr) cas; |
| |
| // System.out.println("After serialization\n"); |
| FSIndex<? extends FeatureStructure> index = cas.getAnnotationIndex(); |
| assertTrue(index != null); |
| assertTrue(index.getIndexingStrategy() == FSIndex.SORTED_INDEX); |
| // System.out.println("Size of ordered index: " + index.size()); |
| assertTrue(index.size() == ordSize); |
| |
| index = cas.getIndexRepository().getIndex(ANNOT_BAG_INDEX); |
| assertTrue(index != null); |
| assertTrue(index.getIndexingStrategy() == FSIndex.BAG_INDEX); |
| // System.out.println("Size of bag index: " + index.size()); |
| assertTrue(index.size() == bagSize); |
| |
| index = cas.getIndexRepository().getIndex(ANNOT_SET_INDEX); |
| assertTrue(index != null); |
| assertTrue(index.getIndexingStrategy() == FSIndex.SET_INDEX); |
| // System.out.println("Size of set index: " + index.size()); |
| // System.out.println("Should be: " + setSize); |
| assertTrue(index.size() == setSize); |
| |
| } |
| |
| public static void main(String[] args) { |
| junit.textui.TestRunner.run(IndexSerializationTest.class); |
| } |
| |
| } |