| /* |
| * 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.FSIndexRepository; |
| 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.FSIndexComparator; |
| import org.apache.uima.cas.admin.FSIndexRepositoryMgr; |
| import org.apache.uima.cas.admin.LinearTypeOrder; |
| import org.apache.uima.cas.admin.LinearTypeOrderBuilder; |
| import org.apache.uima.cas.admin.TypeSystemMgr; |
| import org.apache.uima.cas.impl.LinearTypeOrderBuilderImpl; |
| import org.apache.uima.test.junit_extension.JUnitExtension; |
| |
| /** |
| * Test the variations possible for index compare functions |
| * |
| */ |
| public class IndexComparitorTest extends TestCase { |
| |
| CAS cas; |
| |
| TypeSystem ts; |
| |
| Type topType; |
| |
| Type integerType; |
| |
| Type type1; |
| |
| Type type1Sub1; |
| |
| Type type1Sub2; |
| |
| Feature type1Used; |
| |
| Feature type1Ignored; |
| |
| Feature type1Sub1Used; |
| |
| Feature type1Sub1Ignored; |
| |
| Feature type1Sub2Used; |
| |
| Feature type1Sub2Ignored; |
| |
| FSIndexRepositoryMgr irm; |
| |
| FSIndexRepository ir; |
| |
| FeatureStructure fss[][][]; |
| |
| FSIndex sortedType1; |
| |
| FSIndex sortedType1TypeOrder; |
| |
| private FSIndex setType1; |
| |
| private FSIndex bagType1; |
| |
| private FSIndex sortedType1Sub1; |
| |
| private FSIndex setType1Sub1; |
| |
| private FSIndex bagType1Sub1; |
| |
| private FSIndex setType1TypeOrder; |
| |
| private FSIndex bagType1TypeOrder; |
| |
| private FSIndex sortedType1Sub1TypeOrder; |
| |
| private FSIndex setType1Sub1TypeOrder; |
| |
| private FSIndex bagType1Sub1TypeOrder; |
| |
| public IndexComparitorTest(String arg0) { |
| super(arg0); |
| } |
| |
| /** |
| * class which sets up |
| */ |
| |
| private class SetupForIndexCompareTesting implements AnnotatorInitializer { |
| /** |
| * @see org.apache.uima.cas.test.AnnotatorInitializer#initTypeSystem(TypeSystemMgr) |
| */ |
| public void initTypeSystem(TypeSystemMgr tsm) { |
| // Add new types and features. |
| topType = tsm.getTopType(); |
| integerType = tsm.getType("uima.cas.Integer"); |
| |
| type1 = tsm.addType("Type1", topType); |
| type1Sub1 = tsm.addType("Type1Sub1", type1); |
| type1Sub2 = tsm.addType("Type1Sub2", type1); |
| |
| type1Used = tsm.addFeature("used", type1, integerType); |
| type1Ignored = tsm.addFeature("ignored", type1, integerType); |
| |
| type1Sub1Used = tsm.addFeature("used", type1Sub1, integerType); |
| type1Sub1Ignored = tsm.addFeature("ignored", type1Sub1, integerType); |
| |
| type1Sub2Used = tsm.addFeature("used", type1Sub2, integerType); |
| type1Sub2Ignored = tsm.addFeature("ignored", type1Sub2, integerType); |
| } |
| |
| /** |
| * |
| */ |
| public void initIndexes(FSIndexRepositoryMgr parmIrm, TypeSystem parmTs) { |
| IndexComparitorTest.this.ts = parmTs; |
| IndexComparitorTest.this.irm = parmIrm; |
| parmIrm.createIndex(newComparator(type1), "SortedType1", FSIndex.SORTED_INDEX); |
| parmIrm.createIndex(newComparator(type1), "SetType1", FSIndex.SET_INDEX); |
| parmIrm.createIndex(newComparator(type1), "BagType1", FSIndex.BAG_INDEX); |
| parmIrm.createIndex(newComparatorTypePriority(type1), "SortedType1TypeOrder", |
| FSIndex.SORTED_INDEX); |
| parmIrm.createIndex(newComparatorTypePriority(type1), "SetType1TypeOrder", FSIndex.SET_INDEX); |
| parmIrm.createIndex(newComparatorTypePriority(type1), "BagType1TypeOrder", FSIndex.BAG_INDEX); |
| |
| parmIrm.createIndex(newComparator(type1Sub1), "SortedType1Sub1", FSIndex.SORTED_INDEX); |
| parmIrm.createIndex(newComparator(type1Sub1), "SetType1Sub1", FSIndex.SET_INDEX); |
| parmIrm.createIndex(newComparator(type1Sub1), "BagType1Sub1", FSIndex.BAG_INDEX); |
| parmIrm.createIndex(newComparatorTypePriority(type1Sub1), "SortedType1Sub1TypeOrder", |
| FSIndex.SORTED_INDEX); |
| parmIrm.createIndex(newComparatorTypePriority(type1Sub1), "SetType1Sub1TypeOrder", |
| FSIndex.SET_INDEX); |
| parmIrm.createIndex(newComparatorTypePriority(type1Sub1), "BagType1Sub1TypeOrder", |
| FSIndex.BAG_INDEX); |
| |
| } |
| |
| private FSIndexComparator newComparator(Type type) { |
| FSIndexComparator c = irm.createComparator(); |
| c.setType(type); |
| c.addKey(type1Used, FSIndexComparator.STANDARD_COMPARE); |
| return c; |
| } |
| |
| private FSIndexComparator newComparatorTypePriority(Type type) { |
| FSIndexComparator comp = newComparator(type); |
| comp.addKey(newTypeOrder(), FSIndexComparator.STANDARD_COMPARE); |
| return comp; |
| } |
| |
| private LinearTypeOrder newTypeOrder() { |
| LinearTypeOrderBuilder ltob = new LinearTypeOrderBuilderImpl(ts); |
| LinearTypeOrder order; |
| try { |
| ltob.add(new String[] { "Type1", "Type1Sub1", "Type1Sub2" }); |
| order = ltob.getOrder(); |
| } catch (CASException e) { |
| throw new Error(e); |
| } |
| return order; |
| } |
| } |
| |
| public void setUp() throws Exception { |
| try { |
| this.cas = CASInitializer.initCas(new SetupForIndexCompareTesting()); |
| assertNotNull(cas); |
| ir = cas.getIndexRepository(); |
| sortedType1 = ir.getIndex("SortedType1"); |
| setType1 = ir.getIndex("SetType1"); |
| bagType1 = ir.getIndex("BagType1"); |
| sortedType1Sub1 = ir.getIndex("SortedType1Sub1"); |
| setType1Sub1 = ir.getIndex("SetType1Sub1"); |
| bagType1Sub1 = ir.getIndex("BagType1Sub1"); |
| |
| sortedType1TypeOrder = ir.getIndex("SortedType1TypeOrder"); |
| setType1TypeOrder = ir.getIndex("SetType1TypeOrder"); |
| bagType1TypeOrder = ir.getIndex("BagType1TypeOrder"); |
| sortedType1Sub1TypeOrder = ir.getIndex("SortedType1Sub1TypeOrder"); |
| setType1Sub1TypeOrder = ir.getIndex("SetType1Sub1TypeOrder"); |
| bagType1Sub1TypeOrder = ir.getIndex("BagType1Sub1TypeOrder"); |
| |
| fss = new FeatureStructure[3][2][2]; |
| for (int i = 0; i < 2; i++) { |
| for (int j = 0; j < 2; j++) { |
| ir.addFS(fss[0][i][j] = createFs(type1, i, j)); |
| ir.addFS(fss[1][i][j] = createFs(type1Sub1, i, j)); |
| ir.addFS(fss[2][i][j] = createFs(type1Sub2, i, j)); |
| } |
| } |
| } catch (Exception e) { |
| JUnitExtension.handleException(e); |
| } |
| } |
| |
| private FeatureStructure createFs(Type type, int i, int j) { |
| FeatureStructure f = cas.createFS(type); |
| f.setIntValue(type.getFeatureByBaseName("used"), i); |
| f.setIntValue(type.getFeatureByBaseName("ignored"), j); |
| return f; |
| } |
| |
| public void tearDown() { |
| fss = null; |
| this.cas = null; |
| this.ts = null; |
| topType = null; |
| integerType = null; |
| type1 = null; |
| type1Sub1 = null; |
| type1Sub2 = null; |
| |
| type1Used = null; |
| type1Ignored = null; |
| type1Sub1Used = null; |
| type1Sub1Ignored = null; |
| type1Sub2Used = null; |
| type1Sub2Ignored = null; |
| } |
| |
| public void testCompare() throws Exception { |
| try { |
| assertTrue(0 == sortedType1.compare(fss[0][0][0], fss[0][0][1])); |
| assertTrue(1 == sortedType1.compare(fss[0][1][0], fss[0][0][0])); |
| // type ignored in showing equals |
| assertTrue(0 == sortedType1.compare(fss[1][0][0], fss[0][0][0])); |
| assertTrue(0 == sortedType1.compare(fss[1][0][0], fss[2][0][0])); |
| // type not ignored if type-order included |
| assertTrue(0 == sortedType1TypeOrder.compare(fss[0][0][0], fss[0][0][1])); |
| assertTrue(1 == sortedType1TypeOrder.compare(fss[1][0][0], fss[0][0][0])); |
| |
| assertTrue(0 == setType1.compare(fss[0][0][0], fss[0][0][1])); |
| assertTrue(1 == setType1.compare(fss[0][1][0], fss[0][0][0])); |
| // type ignored in showing equals |
| assertTrue(0 == setType1.compare(fss[1][0][0], fss[0][0][0])); |
| assertTrue(0 == setType1.compare(fss[1][0][0], fss[2][0][0])); |
| // type not ignored if type-order included |
| assertTrue(0 == setType1TypeOrder.compare(fss[0][0][0], fss[0][0][1])); |
| assertTrue(1 == setType1TypeOrder.compare(fss[1][0][0], fss[0][0][0])); |
| |
| assertTrue(-1 == bagType1.compare(fss[0][0][0], fss[0][0][1])); |
| assertTrue(1 == bagType1.compare(fss[0][1][0], fss[0][0][0])); |
| assertTrue(1 == bagType1.compare(fss[1][0][0], fss[0][0][0])); |
| assertTrue(-1 == bagType1.compare(fss[1][0][0], fss[2][0][0])); |
| |
| assertTrue(-1 == bagType1TypeOrder.compare(fss[0][0][0], fss[0][0][1])); |
| assertTrue(1 == bagType1TypeOrder.compare(fss[1][0][0], fss[0][0][0])); |
| |
| // test contains |
| FeatureStructure testType1_0_0 = createFs(type1, 0, 0); |
| FeatureStructure testType1_1_0 = createFs(type1, 1, 0); |
| FeatureStructure testType1_0_x = createFs(type1, 0, 17); |
| FeatureStructure testTypeSub1_0_x = createFs(type1Sub1, 0, 17); |
| FeatureStructure testTypeSub1_0_0 = createFs(type1Sub1, 0, 0); |
| |
| assertTrue(sortedType1.contains(testType1_0_0)); |
| assertTrue(sortedType1.contains(testType1_0_x)); |
| assertTrue(sortedType1.contains(testTypeSub1_0_x)); |
| assertTrue(setType1.contains(testType1_0_0)); |
| assertTrue(setType1.contains(testType1_0_x)); |
| assertTrue(setType1.contains(testTypeSub1_0_x)); |
| assertFalse(bagType1.contains(testType1_0_0)); |
| assertFalse(bagType1.contains(testType1_0_x)); |
| assertFalse(bagType1.contains(testTypeSub1_0_x)); |
| |
| assertTrue(sortedType1TypeOrder.contains(testType1_0_0)); |
| assertTrue(sortedType1TypeOrder.contains(testType1_0_x)); |
| // assertTrue(sortedType1TypeOrder.contains(testTypeSub1_0_x)); |
| assertTrue(setType1TypeOrder.contains(testType1_0_0)); |
| assertTrue(setType1TypeOrder.contains(testType1_0_x)); |
| // assertTrue(setType1TypeOrder.contains(testTypeSub1_0_x)); |
| assertFalse(bagType1TypeOrder.contains(testType1_0_0)); |
| assertFalse(bagType1TypeOrder.contains(testType1_0_x)); |
| assertFalse(bagType1TypeOrder.contains(testTypeSub1_0_x)); |
| |
| // for (Iterator it = sortedType1TypeOrder.iterator(); it.hasNext();) { |
| // System.out.println(it.next().toString()); |
| // } |
| // assertTrue(sortedType1TypeOrder.contains(testTypeSub1_0_0)); |
| // assertTrue(sortedType1TypeOrder.contains(testTypeSub1_0_x)); |
| |
| // test find |
| |
| assertNotNull(sortedType1.find(testType1_0_0)); |
| assertNotNull(sortedType1.find(testType1_0_x)); |
| assertNotNull(sortedType1.find(testTypeSub1_0_x)); |
| assertNotNull(setType1.find(testType1_0_0)); |
| assertNotNull(setType1.find(testType1_0_x)); |
| assertNotNull(setType1.find(testTypeSub1_0_x)); |
| assertNull(bagType1.find(testType1_0_0)); |
| assertNull(bagType1.find(testType1_0_x)); |
| assertNull(bagType1.find(testTypeSub1_0_x)); |
| |
| assertNotNull(sortedType1TypeOrder.find(testType1_0_0)); |
| assertNotNull(sortedType1TypeOrder.find(testType1_0_x)); |
| // assertNotNull(sortedType1TypeOrder.find(testTypeSub1_0_x)); |
| assertNotNull(setType1TypeOrder.find(testType1_0_0)); |
| assertNotNull(setType1TypeOrder.find(testType1_0_x)); |
| // assertNotNull(setType1TypeOrder.find(testTypeSub1_0_x)); |
| assertNull(bagType1TypeOrder.find(testType1_0_0)); |
| assertNull(bagType1TypeOrder.find(testType1_0_x)); |
| assertNull(bagType1TypeOrder.find(testTypeSub1_0_x)); |
| |
| // test iterator(fs) |
| assertTrue(sortedType1.iterator(testType1_0_0).isValid()); |
| assertTrue(sortedType1.iterator(testType1_0_x).isValid()); |
| assertTrue(sortedType1.iterator(testTypeSub1_0_x).isValid()); |
| assertTrue(setType1.iterator(testType1_0_0).isValid()); |
| assertTrue(setType1.iterator(testType1_0_x).isValid()); |
| assertTrue(setType1.iterator(testTypeSub1_0_x).isValid()); |
| assertTrue(bagType1.iterator(testType1_0_0).isValid()); |
| assertTrue(bagType1.iterator(testType1_0_x).isValid()); |
| assertTrue(bagType1.iterator(testTypeSub1_0_x).isValid()); |
| |
| assertTrue(sortedType1TypeOrder.iterator(testType1_0_0).isValid()); |
| assertTrue(sortedType1TypeOrder.iterator(testType1_0_x).isValid()); |
| assertTrue(sortedType1TypeOrder.iterator(testTypeSub1_0_x).isValid()); |
| assertTrue(setType1TypeOrder.iterator(testType1_0_0).isValid()); |
| assertTrue(setType1TypeOrder.iterator(testType1_0_x).isValid()); |
| assertTrue(setType1TypeOrder.iterator(testTypeSub1_0_x).isValid()); |
| assertTrue(bagType1TypeOrder.iterator(testType1_0_0).isValid()); |
| assertTrue(bagType1TypeOrder.iterator(testType1_0_x).isValid()); |
| assertTrue(bagType1TypeOrder.iterator(testTypeSub1_0_x).isValid()); |
| |
| // assertTrue(fss[0][0][0].equals(sortedType1.iterator(testType1_0_0).get())); |
| assertTrue(fss[0][1][0].equals(sortedType1.iterator(testType1_1_0).get())); |
| // assertTrue(fss[0][0][0].equals(sortedType1.iterator(testType1_0_x).get())); |
| // assertTrue(fss[0][0][0].equals(sortedType1.iterator(testTypeSub1_0_x).get())); |
| assertTrue(fss[0][0][0].equals(setType1.iterator(testType1_0_0).get())); |
| assertTrue(fss[0][0][0].equals(setType1.iterator(testType1_0_x).get())); |
| assertTrue(fss[0][0][0].equals(setType1.iterator(testTypeSub1_0_x).get())); |
| assertTrue(fss[0][0][0].equals(bagType1.iterator(testType1_0_0).get())); |
| assertTrue(fss[0][0][0].equals(bagType1.iterator(testType1_0_x).get())); |
| assertTrue(fss[0][0][0].equals(bagType1.iterator(testTypeSub1_0_x).get())); |
| |
| // assertTrue(fss[0][0][0].equals(sortedType1.iterator(testType1_0_0).get())); |
| assertTrue(fss[0][1][0].equals(sortedType1.iterator(testType1_1_0).get())); |
| // assertTrue(fss[0][0][0].equals(sortedType1.iterator(testType1_0_x).get())); |
| // assertTrue(fss[0][0][0].equals(sortedType1.iterator(testTypeSub1_0_x).get())); |
| assertTrue(fss[0][0][0].equals(setType1.iterator(testType1_0_0).get())); |
| assertTrue(fss[0][0][0].equals(setType1.iterator(testType1_0_x).get())); |
| assertTrue(fss[0][0][0].equals(setType1.iterator(testTypeSub1_0_x).get())); |
| assertTrue(fss[0][0][0].equals(bagType1.iterator(testType1_0_0).get())); |
| assertTrue(fss[0][0][0].equals(bagType1.iterator(testType1_0_x).get())); |
| assertTrue(fss[0][0][0].equals(bagType1.iterator(testTypeSub1_0_x).get())); |
| |
| } catch (Exception e) { |
| JUnitExtension.handleException(e); |
| } |
| |
| } |
| |
| public static void main(String[] args) { |
| junit.textui.TestRunner.run(IndexComparitorTest.class); |
| } |
| |
| } |
