lucene-java-3.4.0/lucene/src/test/org/apache/lucene/analysis/tokenattributes/TestSimpleAttributeImpls.java

   1 package org.apache.lucene.analysis.tokenattributes;
   2
   3 /**
   4  * Licensed to the Apache Software Foundation (ASF) under one or more
   5  * contributor license agreements.  See the NOTICE file distributed with
   6  * this work for additional information regarding copyright ownership.
   7  * The ASF licenses this file to You under the Apache License, Version 2.0
   8  * (the "License"); you may not use this file except in compliance with
   9  * the License.  You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 import org.apache.lucene.index.Payload;
  21 import org.apache.lucene.util.AttributeImpl;
  22 import org.apache.lucene.util.LuceneTestCase;
  23 import org.apache.lucene.util.AttributeSource.AttributeFactory;
  24 import org.apache.lucene.util._TestUtil;
  25
  26 import java.util.Collections;
  27 import java.util.HashMap;
  28
  29 @Deprecated
  30 public class TestSimpleAttributeImpls extends LuceneTestCase {
  31
  32   public void testFlagsAttribute() throws Exception {
  33     FlagsAttributeImpl att = new FlagsAttributeImpl();
  34     assertEquals(0, att.getFlags());
  35
  36     att.setFlags(1234);
  37     assertEquals("flags=1234", att.toString());
  38
  39     FlagsAttributeImpl att2 = (FlagsAttributeImpl) assertCloneIsEqual(att);
  40     assertEquals(1234, att2.getFlags());
  41
  42     att2 = (FlagsAttributeImpl) assertCopyIsEqual(att);
  43     assertEquals(1234, att2.getFlags());
  44
  45     att.clear();
  46     assertEquals(0, att.getFlags());
  47
  48     _TestUtil.assertAttributeReflection(att,
  49       Collections.singletonMap(FlagsAttribute.class.getName() + "#flags", att.getFlags()));
  50   }
  51
  52   public void testPositionIncrementAttribute() throws Exception {
  53     PositionIncrementAttributeImpl att = new PositionIncrementAttributeImpl();
  54     assertEquals(1, att.getPositionIncrement());
  55
  56     att.setPositionIncrement(1234);
  57     assertEquals("positionIncrement=1234", att.toString());
  58
  59     PositionIncrementAttributeImpl att2 = (PositionIncrementAttributeImpl) assertCloneIsEqual(att);
  60     assertEquals(1234, att2.getPositionIncrement());
  61
  62     att2 = (PositionIncrementAttributeImpl) assertCopyIsEqual(att);
  63     assertEquals(1234, att2.getPositionIncrement());
  64
  65     att.clear();
  66     assertEquals(1, att.getPositionIncrement());
  67
  68     _TestUtil.assertAttributeReflection(att,
  69       Collections.singletonMap(PositionIncrementAttribute.class.getName() + "#positionIncrement", att.getPositionIncrement()));
  70   }
  71
  72   public void testTypeAttribute() throws Exception {
  73     TypeAttributeImpl att = new TypeAttributeImpl();
  74     assertEquals(TypeAttribute.DEFAULT_TYPE, att.type());
  75
  76     att.setType("hallo");
  77     assertEquals("type=hallo", att.toString());
  78
  79     TypeAttributeImpl att2 = (TypeAttributeImpl) assertCloneIsEqual(att);
  80     assertEquals("hallo", att2.type());
  81
  82     att2 = (TypeAttributeImpl) assertCopyIsEqual(att);
  83     assertEquals("hallo", att2.type());
  84
  85     att.clear();
  86     assertEquals(TypeAttribute.DEFAULT_TYPE, att.type());
  87
  88     _TestUtil.assertAttributeReflection(att,
  89       Collections.singletonMap(TypeAttribute.class.getName() + "#type", att.type()));
  90   }
  91
  92   public void testPayloadAttribute() throws Exception {
  93     PayloadAttributeImpl att = new PayloadAttributeImpl();
  94     assertNull(att.getPayload());
  95
  96     Payload pl = new Payload(new byte[]{1,2,3,4});
  97     att.setPayload(pl);
  98
  99     _TestUtil.assertAttributeReflection(att,
 100       Collections.singletonMap(PayloadAttribute.class.getName() + "#payload", pl));
 101
 102     PayloadAttributeImpl att2 = (PayloadAttributeImpl) assertCloneIsEqual(att);
 103     assertEquals(pl, att2.getPayload());
 104     assertNotSame(pl, att2.getPayload());
 105
 106     att2 = (PayloadAttributeImpl) assertCopyIsEqual(att);
 107     assertEquals(pl, att2.getPayload());
 108     assertNotSame(pl, att2.getPayload());
 109
 110     att.clear();
 111     assertNull(att.getPayload());
 112   }
 113
 114   public void testOffsetAttribute() throws Exception {
 115     OffsetAttributeImpl att = new OffsetAttributeImpl();
 116     assertEquals(0, att.startOffset());
 117     assertEquals(0, att.endOffset());
 118
 119     att.setOffset(12, 34);
 120     // no string test here, because order unknown
 121
 122     _TestUtil.assertAttributeReflection(att,
 123       new HashMap<String,Object>() {{
 124         put(OffsetAttribute.class.getName() + "#startOffset", 12);
 125         put(OffsetAttribute.class.getName() + "#endOffset", 34);
 126       }});
 127
 128     OffsetAttributeImpl att2 = (OffsetAttributeImpl) assertCloneIsEqual(att);
 129     assertEquals(12, att2.startOffset());
 130     assertEquals(34, att2.endOffset());
 131
 132     att2 = (OffsetAttributeImpl) assertCopyIsEqual(att);
 133     assertEquals(12, att2.startOffset());
 134     assertEquals(34, att2.endOffset());
 135
 136     att.clear();
 137     assertEquals(0, att.startOffset());
 138     assertEquals(0, att.endOffset());
 139   }
 140
 141   public void testKeywordAttribute() {
 142     AttributeImpl attrImpl = AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY.createAttributeInstance(KeywordAttribute.class);
 143     assertSame(KeywordAttributeImpl.class, attrImpl.getClass());
 144     KeywordAttributeImpl att = (KeywordAttributeImpl) attrImpl;
 145     assertFalse(att.isKeyword());
 146     att.setKeyword(true);
 147     assertTrue(att.isKeyword());
 148
 149     KeywordAttributeImpl assertCloneIsEqual = (KeywordAttributeImpl) assertCloneIsEqual(att);
 150     assertTrue(assertCloneIsEqual.isKeyword());
 151     assertCloneIsEqual.clear();
 152     assertFalse(assertCloneIsEqual.isKeyword());
 153     assertTrue(att.isKeyword());
 154
 155     att.copyTo(assertCloneIsEqual);
 156     assertTrue(assertCloneIsEqual.isKeyword());
 157     assertTrue(att.isKeyword());
 158
 159     _TestUtil.assertAttributeReflection(att,
 160       Collections.singletonMap(KeywordAttribute.class.getName() + "#keyword", att.isKeyword()));
 161   }
 162
 163   public static final AttributeImpl assertCloneIsEqual(AttributeImpl att) {
 164     AttributeImpl clone = (AttributeImpl) att.clone();
 165     assertEquals("Clone must be equal", att, clone);
 166     assertEquals("Clone's hashcode must be equal", att.hashCode(), clone.hashCode());
 167     return clone;
 168   }
 169
 170   public static final AttributeImpl assertCopyIsEqual(AttributeImpl att) throws Exception {
 171     AttributeImpl copy = att.getClass().newInstance();
 172     att.copyTo(copy);
 173     assertEquals("Copied instance must be equal", att, copy);
 174     assertEquals("Copied instance's hashcode must be equal", att.hashCode(), copy.hashCode());
 175     return copy;
 176   }
 177
 178 }