| /* |
| * 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.File; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import junit.framework.TestCase; |
| |
| import org.apache.uima.cas.ArrayFS; |
| import org.apache.uima.cas.ByteArrayFS; |
| import org.apache.uima.cas.ShortArrayFS; |
| import org.apache.uima.cas.CAS; |
| import org.apache.uima.cas.CASException; |
| import org.apache.uima.cas.FSIndex; |
| import org.apache.uima.cas.FSIndexRepository; |
| import org.apache.uima.cas.FSIterator; |
| 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.CASAdminException; |
| import org.apache.uima.cas.admin.CASFactory; |
| import org.apache.uima.cas.admin.CASMgr; |
| 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.LowLevelCAS; |
| import org.apache.uima.cas.impl.Serialization; |
| import org.apache.uima.cas.text.AnnotationFS; |
| import org.apache.uima.internal.util.TextStringTokenizer; |
| import org.apache.uima.resource.ResourceInitializationException; |
| 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.FileUtils; |
| |
| /** |
| * Class comment for TokenizerTest.java goes here. |
| * |
| */ |
| public class SerializationReinitTest extends TestCase { |
| |
| 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"; |
| |
| public static final String STRING_SUBTYPE_1 = "StringSubtype1"; |
| |
| public static final String[] STR_1_VALS = { "test1", "test2" }; |
| |
| public static final String OSTR_TYPE = "theType"; |
| |
| public static final String OSTR_TYPE_FEAT = "theString"; |
| |
| public static final String OBYTE_TYPE_FEAT = "theByte"; |
| |
| public static final String OSHORT_TYPE_FEAT = "theShort"; |
| |
| public static final String OBYTEA_TYPE_FEAT = "theByteArray"; |
| |
| public static final String OSHORTA_TYPE_FEAT = "theShortArray"; |
| |
| public static final String OLONG_TYPE_FEAT = "theLong"; |
| |
| private CASMgr casMgr; |
| |
| private CAS cas; |
| |
| private Type wordType; |
| |
| private Type separatorType; |
| |
| private Type eosType; |
| |
| private Type tokenType; |
| |
| private Feature tokenTypeFeature; |
| |
| private Type sentenceType; |
| |
| private Feature startFeature; |
| |
| private Feature endFeature; |
| |
| private Type strSub1; |
| |
| private Type theTypeType; |
| |
| private Feature theStringFeature; |
| |
| private Feature theByteFeature; |
| |
| private Feature theShortFeature; |
| |
| private Feature theByteArrayFeature; |
| |
| private Feature theShortArrayFeature; |
| |
| private Feature theLongFeature; |
| |
| |
| public SerializationReinitTest(String arg) { |
| super(arg); |
| } |
| |
| /** |
| * @see junit.framework.TestCase#setUp() |
| */ |
| public 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); |
| strSub1 = ts.getType(STRING_SUBTYPE_1); |
| assertTrue(strSub1 != null); |
| theTypeType = ts.getType(OSTR_TYPE); |
| theStringFeature = ts.getFeatureByFullName(OSTR_TYPE + TypeSystem.FEATURE_SEPARATOR + OSTR_TYPE_FEAT); |
| theByteFeature = ts.getFeatureByFullName(OSTR_TYPE + TypeSystem.FEATURE_SEPARATOR + OBYTE_TYPE_FEAT); |
| theByteArrayFeature = ts.getFeatureByFullName(OSTR_TYPE + TypeSystem.FEATURE_SEPARATOR + OBYTEA_TYPE_FEAT); |
| theShortFeature = ts.getFeatureByFullName(OSTR_TYPE + TypeSystem.FEATURE_SEPARATOR + OSHORT_TYPE_FEAT); |
| theShortArrayFeature = ts.getFeatureByFullName(OSTR_TYPE + TypeSystem.FEATURE_SEPARATOR + OSHORTA_TYPE_FEAT); |
| theLongFeature = ts.getFeatureByFullName(OSTR_TYPE + TypeSystem.FEATURE_SEPARATOR + OLONG_TYPE_FEAT); |
| } |
| |
| public void tearDown() { |
| casMgr = null; |
| cas = null; |
| wordType = null; |
| // assert(wordType != null); |
| separatorType = null; |
| eosType = null; |
| tokenType = null; |
| tokenTypeFeature = null; |
| startFeature = null; |
| endFeature = null; |
| sentenceType = null; |
| strSub1 = null; |
| } |
| |
| // Initialize the first CAS. |
| private static CASMgr initCAS() throws CASException { |
| // Create an initial CASMgr from the factory. |
| // CASMgr cas = CASFactory.createCAS(); |
| // assert(tsa != null); |
| // Create a CASMgr. Ensures existence of AnnotationFS type. |
| // CASMgr tcas = CASFactory.createCAS(); |
| CASMgr aCas = CASFactory.createCAS(); |
| try { |
| CasCreationUtils.setupTypeSystem(aCas, (TypeSystemDescription) null); |
| } catch (ResourceInitializationException e) { |
| e.printStackTrace(); |
| } |
| // Create a writable type system. |
| TypeSystemMgr tsa = aCas.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); |
| tsa.addStringSubtype(STRING_SUBTYPE_1, STR_1_VALS); |
| Type stringType = tsa.getType(CAS.TYPE_NAME_STRING); |
| Type byteType = tsa.getType(CAS.TYPE_NAME_BYTE); |
| Type byteArrayType = tsa.getType(CAS.TYPE_NAME_BYTE_ARRAY); |
| Type shortType = tsa.getType(CAS.TYPE_NAME_SHORT); |
| Type shortArrayType = tsa.getType(CAS.TYPE_NAME_SHORT_ARRAY); |
| Type longType = tsa.getType(CAS.TYPE_NAME_LONG); |
| Type theTypeType = tsa.addType(OSTR_TYPE, annotType); |
| tsa.addFeature(OSTR_TYPE_FEAT, theTypeType, stringType); |
| tsa.addFeature(OBYTE_TYPE_FEAT, theTypeType, byteType); |
| tsa.addFeature(OSHORT_TYPE_FEAT, theTypeType, shortType); |
| tsa.addFeature(OBYTEA_TYPE_FEAT, theTypeType, byteArrayType); |
| tsa.addFeature(OSHORTA_TYPE_FEAT, theTypeType, shortArrayType); |
| tsa.addFeature(OLONG_TYPE_FEAT, theTypeType, longType); |
| // Commit the type system. |
| ((CASImpl) aCas).commitTypeSystem(); |
| // assert(tsa.isCommitted()); |
| // // Create the CAS indexes. |
| // tcas.initCASIndexes(); |
| // Create the Base indexes. |
| try { |
| aCas.initCASIndexes(); |
| } catch (CASException e) { |
| e.printStackTrace(); |
| } |
| |
| // Commit the index repository. |
| aCas.getIndexRepositoryMgr().commit(); |
| // assert(cas.getIndexRepositoryMgr().isCommitted()); |
| |
| // Create the default text Sofa and return CAS view |
| return (CASMgr) aCas.getCAS().getCurrentView(); |
| } |
| |
| public void testReset() { |
| cas.reset(); |
| casMgr.enableReset(false); |
| boolean exc = false; |
| try { |
| cas.reset(); |
| } catch (CASAdminException e) { |
| assertTrue(e.getError() == CASAdminException.FLUSH_DISABLED); |
| exc = true; |
| } |
| assertTrue(exc); |
| casMgr.enableReset(true); |
| cas.reset(); |
| } |
| |
| // Tokenize text. |
| private void tokenize() throws Exception { |
| // System.out.println("Tokenizing text."); |
| |
| // Create FSs for the token types. |
| FeatureStructure wordFS = cas.createFS(wordType); |
| FeatureStructure sepFS = cas.createFS(separatorType); |
| FeatureStructure eosFS = cas.createFS(eosType); |
| |
| String text = cas.getDocumentText(); |
| TextStringTokenizer tokenizer = new TextStringTokenizer(text); |
| tokenizer.setSeparators("/-*&@"); |
| tokenizer.addWhitespaceChars(","); |
| tokenizer.setEndOfSentenceChars(".!?"); |
| tokenizer.setShowWhitespace(false); |
| int tokenTypeCode; |
| int wordCounter = 0; |
| int sepCounter = 0; |
| int endOfSentenceCounter = 0; |
| AnnotationFS tokenAnnot; |
| while (tokenizer.isValid()) { |
| tokenAnnot = cas.createAnnotation(tokenType, tokenizer.getTokenStart(), tokenizer |
| .getTokenEnd()); |
| tokenTypeCode = tokenizer.getTokenType(); |
| switch (tokenTypeCode) { |
| case TextStringTokenizer.EOS: { |
| ++endOfSentenceCounter; |
| tokenAnnot.setFeatureValue(tokenTypeFeature, eosFS); |
| break; |
| } |
| case TextStringTokenizer.SEP: { |
| ++sepCounter; |
| tokenAnnot.setFeatureValue(tokenTypeFeature, sepFS); |
| break; |
| } |
| case TextStringTokenizer.WSP: { |
| break; |
| } |
| case TextStringTokenizer.WCH: { |
| ++wordCounter; |
| tokenAnnot.setFeatureValue(tokenTypeFeature, wordFS); |
| // if ((wordCounter % 100000) == 0) { |
| // System.out.println("Number of words tokenized: " + wordCounter); |
| // } |
| break; |
| } |
| default: { |
| throw new Exception("Something went wrong, fire up that debugger!"); |
| } |
| } |
| cas.getIndexRepository().addFS(tokenAnnot); |
| tokenizer.setToNext(); |
| // System.out.println("Token: " + tokenizer.nextToken()); |
| } |
| // time = System.currentTimeMillis() - time; |
| // System.out.println("Number of words: " + wordCounter); |
| // int allTokens = wordCounter + sepCounter + endOfSentenceCounter; |
| // System.out.println("Number of tokens: " + allTokens); |
| // System.out.println("Time used: " + new TimeSpan(time)); |
| |
| // FSIterator it = cas.getAnnotationIndex(tokenType).iterator(); |
| // int count = 0; |
| // while (it.isValid()) { |
| // ++count; |
| // it.moveToNext(); |
| // } |
| // System.out.println("Number of tokens in index: " + count); |
| } |
| |
| // Very (!) primitive EOS detection. |
| private void createSentences() throws CASException { |
| // TypeSystem ts = cas.getTypeSystem(); |
| // Type eosType = ts.getType(EOS_TYPE); |
| // Type tokenType = ts.getType(TOKEN_TYPE); |
| // //assert(tokenType != null); |
| // Type sentenceType = ts.getType(SENT_TYPE); |
| // Feature tokenTypeFeature = ts.getFeature(TOKEN_TYPE_FEAT); |
| // Feature startFeature = ts.getFeature(CAS.START_FEAT); |
| // Feature endFeature = ts.getFeature(CAS.END_FEAT); |
| |
| // System.out.println("\nCreating sentence annotations."); |
| |
| // Get a handle to the index repository. |
| FSIndexRepository indexRepository = cas.getIndexRepository(); |
| // assert(indexRepository != null); |
| Iterator labelIt = indexRepository.getLabels(); |
| assertTrue(labelIt != null); |
| // Get the standard index for tokens. |
| FSIndex tokenIndex = cas.getAnnotationIndex(tokenType); |
| // assert(tokenIndex != null); |
| // Get an iterator over tokens. |
| FSIterator it = tokenIndex.iterator(); |
| // assert(it != null); |
| // Now create sentences. We do this as follows: a sentence starts where |
| // the first token after an EOS starts, and ends with an EOS. |
| long time = System.currentTimeMillis(); |
| int endOfSentenceCounter = 0; |
| it.moveToFirst(); |
| boolean lookForStart = true; |
| int start = 0, end; // Initialize start to pacify compiler. |
| FeatureStructure tokenFS, sentFS; |
| while (it.isValid()) { |
| if (lookForStart) { |
| // If we're looking for the start of a sentence, just grab the start |
| // of the current FS. |
| start = it.get().getIntValue(startFeature); |
| lookForStart = false; |
| } else { |
| // Check if we've reached the end of a sentence. |
| tokenFS = it.get(); |
| if (tokenFS.getFeatureValue(tokenTypeFeature).getType() == eosType) { |
| end = tokenFS.getIntValue(endFeature); |
| sentFS = cas.createFS(sentenceType); |
| sentFS.setIntValue(startFeature, start); |
| sentFS.setIntValue(endFeature, end); |
| cas.getIndexRepository().addFS(sentFS); |
| ++endOfSentenceCounter; |
| lookForStart = true; |
| } |
| } |
| it.moveToNext(); |
| } |
| time = System.currentTimeMillis() - time; |
| // System.out.println("Created " + endOfSentenceCounter + " sentences: " + new TimeSpan(time)); |
| } |
| |
| private static final Pattern nlPattern = Pattern.compile("(?m)(.*?$)"); |
| /** |
| * Test driver. |
| */ |
| public void testMain() throws Exception { |
| |
| // System.out.println("Setting up CAS."); |
| // Create the initial CAS. |
| long time = System.currentTimeMillis(); |
| time = System.currentTimeMillis() - time; |
| // System.out.println("CAS set up: " + new TimeSpan(time)); |
| |
| time = System.currentTimeMillis(); |
| // Read the document into a String. I'm sure there are better ways to |
| File textFile = JUnitExtension.getFile("data/moby.txt"); |
| String moby = FileUtils.file2String(textFile); |
| // String moby = file2String(System.getProperty("cas.data.test") + "moby.txt"); |
| String line; |
| // BufferedReader br = new BufferedReader(new StringReader(moby)); |
| StringBuffer buf = new StringBuffer(10000); |
| ArrayList docs = new ArrayList(); |
| Matcher m = nlPattern.matcher(moby); |
| while (m.find()) { |
| line = m.group(); |
| if (line.startsWith(".. <p")) { |
| docs.add(buf.toString()); |
| buf.setLength(0); |
| } else { |
| buf.append(line + "\n"); |
| } |
| } |
| // while ((line = br.readLine()) != null) { |
| // if (line.startsWith(".. <p")) { |
| // docs.add(buf.toString()); |
| // buf = new StringBuffer(); |
| // } else { |
| // buf.append(line + "\n"); |
| // } |
| // } |
| m.appendTail(buf); |
| docs.add(buf.toString()); |
| buf = null; |
| |
| final int numDocs = docs.size(); |
| final int max = 30; |
| int docCount = 0; |
| long overallTime = System.currentTimeMillis(); |
| int numTok, numSent; |
| CASSerializer cs; |
| while (docCount < max) { |
| for (int i = 0; i < numDocs && docCount < max; i++) { |
| // System.out.println("Processing document: " + i); |
| // Set document text in first CAS. |
| cas.setDocumentText((String) docs.get(i)); |
| |
| tokenize(); |
| numTok = cas.getAnnotationIndex(tokenType).size(); |
| assertTrue(numTok > 0); |
| // System.out.println(" Number of tokens: " + numTok); |
| |
| // System.out.println("Serializing..."); |
| cs = Serialization.serializeCAS(cas); |
| cas = Serialization.createCAS(casMgr, cs); |
| |
| assertTrue(numTok == cas.getAnnotationIndex(tokenType).size()); |
| |
| createSentences(); |
| numSent = cas.getAnnotationIndex(sentenceType).size(); |
| assertTrue(numSent > 0); |
| // System.out.println(" Number of sentences: " + numSent); |
| |
| // System.out.println("Serializing..."); |
| cs = Serialization.serializeCAS(cas); |
| cas = Serialization.createCAS(casMgr, cs); |
| |
| assertTrue(numTok == cas.getAnnotationIndex(tokenType).size()); |
| assertTrue(numSent == cas.getAnnotationIndex(sentenceType).size()); |
| |
| // System.out.println("Serializing..."); |
| cs = Serialization.serializeCAS(cas); |
| cas = Serialization.createCAS(casMgr, cs); |
| |
| assertTrue(numTok == cas.getAnnotationIndex(tokenType).size()); |
| assertTrue(numSent == cas.getAnnotationIndex(sentenceType).size()); |
| // System.out.println(" Verify: " + numTok + " tokens, " + numSent + " sentences."); |
| |
| casMgr.reset(); |
| |
| ++docCount; |
| } |
| // System.out.println("Number of documents processed: " + docCount); |
| } |
| overallTime = System.currentTimeMillis() - overallTime; |
| // System.out.println("Time taken over all: " + new TimeSpan(overallTime)); |
| |
| } |
| |
| /** |
| * Test setCAS(). |
| */ |
| public void testSetCAS() throws Exception { |
| |
| // Read the document into a String. |
| File textFile = JUnitExtension.getFile("data/moby.txt"); |
| String moby = FileUtils.file2String(textFile); |
| // String moby = file2String(System.getProperty("cas.data.test") + "moby.txt"); |
| String line; |
| // BufferedReader br = new BufferedReader(new StringReader(moby)); |
| StringBuffer buf = new StringBuffer(10000); |
| ArrayList docs = new ArrayList(); |
| Matcher m = nlPattern.matcher(moby); |
| while (m.find()) { |
| line = m.group(); |
| if (line.startsWith(".. <p")) { |
| docs.add(buf.toString()); |
| buf.setLength(0); |
| } else { |
| buf.append(line + "\n"); |
| } |
| } |
| |
| // while ((line = br.readLine()) != null) { |
| // if (line.startsWith(".. <p")) { |
| // docs.add(buf.toString()); |
| // buf = new StringBuffer(); |
| // } else { |
| // buf.append(line + "\n"); |
| // } |
| // } |
| // docs.add(buf.toString()); |
| m.appendTail(buf); |
| docs.add(buf.toString()); |
| buf = null; |
| |
| final int numDocs = docs.size(); |
| final int max = 30; |
| int docCount = 0; |
| long overallTime = System.currentTimeMillis(); |
| int numTok, numSent; |
| while (docCount < max) { |
| for (int i = 0; i < numDocs && docCount < max; i++) { |
| // System.out.println("Processing document: " + i); |
| // Set document text in first CAS. |
| cas.setDocumentText((String) docs.get(i)); |
| |
| tokenize(); |
| numTok = cas.getAnnotationIndex(tokenType).size(); |
| assertTrue(numTok > 0); |
| // System.out.println(" Number of tokens: " + numTok); |
| |
| // System.out.println("Serializing..."); |
| // CASMgr casMgr = CASFactory.createCAS(); |
| // casMgr.setCAS(cas); |
| // cas = (CAS) casMgr.getCAS(); |
| /* setCAS is no longer used or implemented |
| * You cannot use this method to set up a new cas with a copy of |
| * the contents of another cas, including its indexes |
| CASMgr realCasMgr = CASFactory.createCAS(cas.getTypeSystem()); |
| realCasMgr.setCAS(((CASImpl) cas).getBaseCAS()); |
| cas = ((CASImpl) realCasMgr).getCurrentView(); |
| casMgr = (CASMgr) cas; |
| */ |
| |
| assertTrue(numTok == cas.getAnnotationIndex(tokenType).size()); |
| |
| createSentences(); |
| numSent = cas.getAnnotationIndex(sentenceType).size(); |
| assertTrue(numSent > 0); |
| // System.out.println(" Number of sentences: " + numSent); |
| |
| // System.out.println("Serializing..."); |
| // casMgr = CASFactory.createCAS(); |
| // casMgr.setCAS(cas); |
| // cas = (CAS) casMgr.getCAS(); |
| /* setCAS is no longer used or implemented |
| * You cannot use this method to set up a new cas with a copy of |
| * the contents of another cas, including its indexes |
| realCasMgr = CASFactory.createCAS(); |
| realCasMgr.setCAS(((CASImpl) cas).getBaseCAS()); |
| cas = ((CASImpl) realCasMgr).getCurrentView(); |
| casMgr = (CASMgr) cas; |
| */ |
| |
| assertTrue(numTok == cas.getAnnotationIndex(tokenType).size()); |
| assertTrue(numSent == cas.getAnnotationIndex(sentenceType).size()); |
| |
| // System.out.println("Serializing..."); |
| // casMgr = CASFactory.createCAS(); |
| // casMgr.setCAS(cas); |
| // cas = (CAS) casMgr.getCAS(); |
| /* setCAS is no longer used or implemented |
| * You cannot use this method to set up a new cas with a copy of |
| * the contents of another cas, including its indexes |
| realCasMgr = CASFactory.createCAS(); |
| realCasMgr.setCAS(((CASImpl) cas).getBaseCAS()); |
| cas = ((CASImpl) realCasMgr).getCurrentView(); |
| casMgr = (CASMgr) cas; |
| */ |
| |
| assertTrue(numTok == cas.getAnnotationIndex(tokenType).size()); |
| assertTrue(numSent == cas.getAnnotationIndex(sentenceType).size()); |
| // System.out.println(" Verify: " + numTok + " tokens, " + numSent + " sentences."); |
| |
| casMgr.reset(); |
| |
| ++docCount; |
| } |
| // System.out.println("Number of documents processed: " + docCount); |
| } |
| overallTime = System.currentTimeMillis() - overallTime; |
| // System.out.println("Time taken over all: " + new TimeSpan(overallTime)); |
| |
| } |
| |
| |
| /** Test basic blob serialization |
| */ |
| public void testBlob() throws Exception { |
| |
| /* |
| * Test that FS, indexes and strings work after repeated blob serialization |
| * For each iteration, add two new FS, serialize and test all created so |
| * The first FS sets the string feature using standard API => goes into stringlist |
| * The second FS sets the string feature using lowlevel API => goes into stringheap |
| * |
| * Throw in tests of the byte, short and long heaps as well |
| * |
| */ |
| String testString = "testString"; |
| cas.reset(); |
| LowLevelCAS ll_cas = cas.getLowLevelCAS(); |
| FSIndexRepository ir = cas.getIndexRepository(); |
| int ll_strfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theStringFeature); |
| int ll_bytefeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theByteFeature); |
| int ll_shortfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theShortFeature); |
| int ll_bytearrayfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theByteArrayFeature); |
| int ll_shortarrayfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theShortArrayFeature); |
| int ll_longfeatcode = ll_cas.ll_getTypeSystem().ll_getCodeForFeature(theLongFeature); |
| |
| for (int cycle=0; cycle<10; cycle+=2) { |
| FeatureStructure newFS1 = cas.createFS(theTypeType); |
| ir.addFS(newFS1); |
| newFS1.setIntValue(startFeature, cycle); |
| newFS1.setIntValue(endFeature, cycle+1); |
| // set string using normal string feature create |
| newFS1.setStringValue(theStringFeature, testString); |
| newFS1.setByteValue(theByteFeature, (byte)cycle); |
| newFS1.setShortValue(theShortFeature, (short)cycle); |
| newFS1.setLongValue(theLongFeature, (long)cycle); |
| ByteArrayFS newBA1 = cas.createByteArrayFS(1); |
| ShortArrayFS newSA1 = cas.createShortArrayFS(1); |
| newBA1.set(0, (byte)cycle); |
| newSA1.set(0, (short)cycle); |
| newFS1.setFeatureValue(theByteArrayFeature, newBA1); |
| newFS1.setFeatureValue(theShortArrayFeature, newSA1); |
| |
| FeatureStructure newFS2 = cas.createFS(theTypeType); |
| ByteArrayFS newBA2 = cas.createByteArrayFS(1); |
| ShortArrayFS newSA2 = cas.createShortArrayFS(1); |
| newFS2.setIntValue(startFeature, cycle+1); |
| newFS2.setIntValue(endFeature, cycle+2); |
| ir.addFS(newFS2); |
| // set string using lowlevel string create API |
| final int llfs2 = ll_cas.ll_getFSRef(newFS2); |
| final int llba2 = ll_cas.ll_getFSRef(newBA2); |
| final int llsa2 = ll_cas.ll_getFSRef(newSA2); |
| ll_cas.ll_setCharBufferValue(llfs2, ll_strfeatcode, |
| testString.toCharArray(), 0, testString.length()); |
| ll_cas.ll_setByteValue(llfs2, ll_bytefeatcode, (byte)(cycle+1)); |
| ll_cas.ll_setShortValue(llfs2, ll_shortfeatcode, (short)(cycle+1)); |
| ll_cas.ll_setLongValue(llfs2, ll_longfeatcode, (long)(cycle+1)); |
| ll_cas.ll_setByteArrayValue(llba2, 0, (byte)(cycle+1)); |
| ll_cas.ll_setShortArrayValue(llsa2, 0, (short)(cycle+1)); |
| newFS2.setFeatureValue(theByteArrayFeature, newBA2); |
| newFS2.setFeatureValue(theShortArrayFeature, newSA2); |
| |
| ByteArrayOutputStream fos = new ByteArrayOutputStream(); |
| Serialization.serializeCAS(cas, fos); |
| cas.reset(); |
| ByteArrayInputStream fis = new ByteArrayInputStream(fos.toByteArray()); |
| Serialization.deserializeCAS(cas, fis); |
| |
| FSIndex idx = cas.getAnnotationIndex(theTypeType); |
| FSIterator iter = idx.iterator(); |
| for (int tc=0; tc<cycle+1; tc++) { |
| FeatureStructure testFS = iter.get(); |
| iter.moveToNext(); |
| assertTrue(tc == testFS.getIntValue(startFeature)); |
| assertTrue(testString.equals(testFS.getStringValue(theStringFeature))); |
| assertTrue(tc == testFS.getByteValue(theByteFeature)); |
| assertTrue(tc == testFS.getShortValue(theShortFeature)); |
| assertTrue(tc == testFS.getLongValue(theLongFeature)); |
| ByteArrayFS ba = (ByteArrayFS)testFS.getFeatureValue(theByteArrayFeature); |
| assertTrue(tc == ba.get(0)); |
| ShortArrayFS sa = (ShortArrayFS)testFS.getFeatureValue(theShortArrayFeature); |
| assertTrue(tc == sa.get(0)); |
| } |
| } |
| } |
| |
| public static void main(String[] args) { |
| junit.textui.TestRunner.run(SerializationReinitTest.class); |
| } |
| |
| } |
